Application: gvSIG desktop

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.fmap.dal.store.simplereader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.Reader;

import java.util.Locale;

import java.util.Map;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.ArrayUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.feature.EditableFeatureAttributeDescriptor;

import org.gvsig.fmap.dal.feature.EditableFeatureType;

import org.gvsig.fmap.dal.store.simplereader.simplereaders.SimpleReader;

import org.gvsig.tools.dynobject.Tags;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author fdiaz

 */

public abstract class SimpleReaderFeatureTypeLoader {

    private static final Logger LOGGER = LoggerFactory.getLogger(SimpleReaderFeatureTypeLoader.class);

    protected boolean all_fields_declare_type;

    protected final SimpleReaderStoreParameters parameters;

    public SimpleReaderFeatureTypeLoader(SimpleReaderStoreParameters parameters) {

        this.parameters = parameters;

    }

    protected abstract String getProviderName();

    protected abstract SimpleReader getSimpleReader(Reader in) throws IOException;

    protected FieldTypeParser[] getFieldTypes(String headers[], AutomaticDetectionOfTypes.DetectedValue automaticTypes[]) {

        String fullFileName = parameters.getFile()==null? "":parameters.getFile().getAbsolutePath();

        FieldTypeParser[] fieldTypes = new FieldTypeParser[headers.length];

        for (int i = 0; i < fieldTypes.length; i++) {

            fieldTypes[i] = new FieldTypeParser(getProviderName(), fullFileName);

        }

        if (automaticTypes != null) {

            for (int i = 0; i < fieldTypes.length && i < automaticTypes.length; i++) {

                fieldTypes[i].detectedValue = automaticTypes[i];

                fieldTypes[i].type = automaticTypes[i].getType();

            }

        }

        this.all_fields_declare_type = true;

        for (int i = 0; i < fieldTypes.length; i++) {

            if (!fieldTypes[i].parse(headers[i])) {

                LOGGER.warn("Can't parse header of field "+i+ "( "+headers[i]+") in '"+getProviderName()+"' file '" + fullFileName + "'.");

            }

            if( fieldTypes[i].type == DataTypes.UNKNOWN ) {

                all_fields_declare_type = false;

                fieldTypes[i].type = DataTypes.STRING;

            }

        }

        String param_types_def = SimpleReaderStoreParameters.getRawFieldTypes(parameters);

        if (StringUtils.isNotBlank(param_types_def)) {

            String sep = SimpleReaderStoreParameters.getDelimiter(param_types_def);

            if (StringUtils.isNotBlank(sep)) {

                String[] param_types = param_types_def.split(sep);

                FieldTypeParser parser = new FieldTypeParser(getProviderName(), fullFileName);

                for (String param_type : param_types) {

                    parser.clear();

                    parser.parse(param_type);

                    for (FieldTypeParser fieldType : fieldTypes) {

                        if (StringUtils.equalsIgnoreCase(fieldType.name, parser.name)) {

                            fieldType.copyFrom(parser);

                            break;

                        }

                    }

                }

            }

        }

        return fieldTypes;

    }

    protected void fillFeatureType(EditableFeatureType fType, FieldTypeParser[] fieldTypes) {

        String fullFileName = parameters.getFile()==null? "":parameters.getFile().getAbsolutePath();

        Tags ftypeTags = fType.getTags();

        for (FieldTypeParser fieldType : fieldTypes) {

            EditableFeatureAttributeDescriptor fad = fType.add(fieldType.name, fieldType.type);

            if( fieldType.detectedValue!=null ) {

                fad.setDisplaySize(Math.max(fieldType.detectedValue.getDisplaySize(), fieldType.size));

                fad.setSize(Math.max(fieldType.detectedValue.getDisplaySize(), fieldType.size));

                if( fad.getPrecision()<fieldType.detectedValue.getPrecision() ) {

                    fad.setPrecision(fieldType.detectedValue.getPrecision());

                }

                if( fad.getScale()<fieldType.detectedValue.getScale()) {

                    fad.setScale(fieldType.detectedValue.getScale());

                }

            } else {

                fad.setDisplaySize(fieldType.size);

            }

            if (fieldType.type == DataTypes.GEOMETRY ) {

                fad.setGeometryType(fieldType.geomType, fieldType.geomSubtype);

                if( fType.getDefaultGeometryAttributeName() == null ) {

                    fType.setDefaultGeometryAttributeName(fieldType.name);

                }

            } 

            Locale locale = null;

            if (fieldType.type == DataTypes.TIMESTAMP ) {

                if(!SimpleReaderStoreParameters.isBlankOrDefaultLocale(parameters)){

                    locale = SimpleReaderStoreParameters.getLocale(parameters);

                }

            } else {

                locale = SimpleReaderStoreParameters.getLocale(parameters);

            }

            fad.setLocale(locale);

            for (Map.Entry<String, String> entry : fieldType.assignments.entrySet()) {

                try {

                    switch(entry.getKey().toLowerCase()) {

                        case "expression":

                            // Los campos calculados los procesamos en una segunda

                            // pasada, cuando ya estan definidos el resto de los campos

                            // ya que pueden requerir campos que aun no se han definido.

                            break;

                        default:

                                fad.set(entry.getKey(), entry.getValue());

                            }

                } catch (Exception ex) {

                    LOGGER.warn("Can't set property '"+entry.getKey()+"' of '"+fad.getName()+"'.", ex);

                }

            }            

            Tags tags = fad.getTags();

            for (Map.Entry<String, String> entry : fieldType.tags.entrySet()) {

                tags.set(entry.getKey(), entry.getValue());

            }

            for (Map.Entry<String, String> entry : fieldType.typetags.entrySet()) {

                ftypeTags.set(entry.getKey(), entry.getValue());

            }

            for (Map.Entry<String, String> entry : fieldType.typeAssignments.entrySet()) {

                try {

                    fType.set(entry.getKey(), entry.getValue());

                } catch(Exception ex) {

                    LOGGER.warn("Can't set attribute '"+entry.getKey()+"' in the feature type.", ex);

                }

            }

        }

        // Processamos ahora los campos calculados

        for (FieldTypeParser fieldType : fieldTypes) {

            EditableFeatureAttributeDescriptor fad = fType.getEditableAttributeDescriptor(fieldType.name);

            for (Map.Entry<String, String> entry : fieldType.assignments.entrySet()) {

                try {

                    switch(entry.getKey().toLowerCase()) {

                        case "expression":

                            fad.set(entry.getKey(), entry.getValue());

                            break;

                    }

                } catch (Exception ex) {

                    LOGGER.warn("Can't set property '"+entry.getKey()+"' in '"+fad.getName()+"' of '"+fullFileName+"'.", ex);

                }

            }

        }

    }

    public boolean loadFeatureType(EditableFeatureType featureType, boolean  detectTypes, SimpleTaskStatus status) throws IOException {

        InputStreamReader in = null;

        SimpleReader reader = null;

        try {

            in = SimpleReaderUtils.openFile(

                    parameters.getFile(),

                    SimpleReaderStoreParameters.getCharset(parameters)

            );

            reader = getSimpleReader(in);

            String[] headers = getHeaders(reader);

            AutomaticDetectionOfTypes.DetectedValue[] detectedTypes = null;

            if( detectTypes ) {

                detectedTypes = automaticDetectionOfTypes(headers, status);

            }

            if( StringUtils.isBlank(headers[headers.length-1]) &&

                (detectedTypes==null || detectedTypes[headers.length-1].isBlank()) ) {

                headers = ArrayUtils.remove(headers, headers.length-1);

            }

            if (detectedTypes != null && detectedTypes.length > headers.length) {

                // Se han detectado mas columnas que las que hay en la cabezera,

                // a?adimos mas columnas a la cabezera.

                String[] headers2 = new String[detectedTypes.length];

                for (int i = 0; i < headers2.length; i++) {

                    if (i < headers.length) {

                        headers2[i] = headers[i];

                    } else {

                        headers2[i] = getFixedHeader(i);

                    }

                }

                headers = headers2;

            }

            for (int i = 0; i < headers.length; i++) {

                if (StringUtils.isBlank(headers[i])) {

                    headers[i] = getFixedHeader(i);

                }

            }

            // Initialize the feature types

            fillFeatureType(featureType,  headers, detectedTypes);

            return this.all_fields_declare_type;

        } finally {

            IOUtils.closeQuietly(in);

            IOUtils.closeQuietly(reader);

        }

    }

    protected String[] getHeaders(SimpleReader reader) throws RuntimeException, IOException {

        String headers[];

        headers = SimpleReaderStoreParameters.getHeaders(parameters);

        return headers;

    }

    protected String[] getFixedHeaders(int count) {

        String[] headers = new String[count];

        for (int i = 0; i < headers.length; i++) {

            headers[i] = getFixedHeader(i);

        }

        return headers;

    }

    protected String getFixedHeader(int column) {

        char[] header = new char[3];

        String s = String.format("%03d", column);

        header[0] = (char) (s.charAt(0) + 17);

        header[1] = (char) (s.charAt(1) + 17);

        header[2] = (char) (s.charAt(2) + 17);

        return String.valueOf(header);

    }

    private AutomaticDetectionOfTypes.DetectedValue[] automaticDetectionOfTypes(String[] headers, SimpleTaskStatus status) throws IOException {

        String fullFileName = parameters.getFile()==null? "NULL":parameters.getFile().getAbsolutePath();

        boolean automatic_types_detection = SimpleReaderStoreParameters.getAutomaticTypesDetection(parameters);

        if (!automatic_types_detection) {

            return null;

        }

        AutomaticDetectionOfTypes.DetectedValue[] types = null;

        Reader in = null;

        SimpleReader reader = null;

        try {

            in = SimpleReaderUtils.openFile(

                    parameters.getFile(),

                    SimpleReaderStoreParameters.getCharset(parameters)

            );

            reader = getSimpleReader(in);

            AutomaticDetectionOfTypes x = new AutomaticDetectionOfTypes(

                    fullFileName

            );

            types = x.detect(

                    headers.length,

                    reader,

                    isFirstLineHeader(),

                    SimpleReaderStoreParameters.getLocale(parameters),

                    status

            );

        } catch (Exception ex) {

            int lineno = 0;

            if (reader != null) {

                lineno = reader.getLine();

            }

            throw new RuntimeException("Problems reading file '" + fullFileName + "' near line " + lineno + ".", ex);

        } finally {

            IOUtils.closeQuietly(reader);

            IOUtils.closeQuietly(in);

        }

        return types;

    }

    protected boolean isFirstLineHeader() {

        return false;

    }

    protected void fillFeatureType(EditableFeatureType fType, String headers[], AutomaticDetectionOfTypes.DetectedValue automaticTypes[]) {

        fType.setHasOID(true);

        FieldTypeParser[] fieldTypes = getFieldTypes(headers, automaticTypes);

        fillFeatureType(fType, fieldTypes);

    }

    public boolean isAllFieldsDeclareType() {

        return this.all_fields_declare_type;

    }

}