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.csv;

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.OutputStreamWriter;

import java.io.Writer;

import java.nio.file.Files;

import java.util.HashMap;

import java.util.Locale;

import java.util.Map;

import org.apache.commons.lang3.ArrayUtils;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.text.StringEscapeUtils;

import org.gvsig.fmap.dal.DataTypes;

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

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

import org.gvsig.fmap.dal.feature.exception.PerformEditingException;

import org.gvsig.fmap.dal.feature.spi.FeatureProvider;

import org.gvsig.fmap.dal.store.csv.simplereaders.CSVReaderSuperCSV;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.SpatialIndex;

import org.gvsig.fmap.geom.operation.GeometryOperationException;

import org.gvsig.fmap.geom.operation.GeometryOperationNotSupportedException;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.Coercion;

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dynobject.Tags;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.supercsv.io.CsvListWriter;

import org.supercsv.prefs.CsvPreference;

/**

 *

 * @author osc

 */

@SuppressWarnings("UseSpecificCatch")

public class CSVFeatureWriter {

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

  private Map<String,Envelope> envelopes = null;

  private boolean calculate_envelope = false;

  private CsvListWriter listWriter = null;

  private CsvPreference csvpreferences = null;

  private Writer writer = null;

  private FeatureType ftype;

  private File file;

  private String[] values;

  private FeatureAttributeDescriptor[] descriptors;

  private Coercion convert = null;

//  private CoercionContext converContext = null;

  private int errorcounts = 0;

  private Throwable lasterror = null;

  private CSVStoreParameters storeParameters;

  private String charset = null;

  private boolean includeMetadataInHeader;

    private Locale locale;

    private GeometryManager geometryManager;

    private Map<String,SpatialIndex> spatialIndexes;

  public void initialize(

          CSVStoreParameters storeParameters, 

          File file, 

          FeatureType ftype, 

          CsvPreference csvpreferences

    ) {

      this.initialize(storeParameters, file, ftype, csvpreferences, null);

  }

  public void initialize(

          CSVStoreParameters storeParameters, 

          File file, 

          FeatureType ftype, 

          CsvPreference csvpreferences,

          Map<String,SpatialIndex> spatialIndex

    ) {

    this.file = file;

    this.ftype = ftype;

    this.storeParameters = storeParameters;

    if (csvpreferences == null) {

      this.csvpreferences = CSVStoreParameters.getPredefinedCSVPreferences(storeParameters);

    } else {

      this.csvpreferences = csvpreferences;

    }

    if (this.ftype != null) {

      this.descriptors = this.ftype.getAttributeDescriptors();

      if (ftype.getDefaultGeometryAttributeName() != null) {

        this.calculate_envelope = true;

      }

    }

    this.convert = ToolsLocator.getDataTypesManager().getCoercion(DataTypes.STRING);

//    this.converContext = DataTypeUtils.coerceContextLocale(CSVStoreParameters.getLocale(this.storeParameters));

    this.errorcounts = 0;

    this.charset = CSVStoreParameters.getCharset(storeParameters);

    this.includeMetadataInHeader = CSVStoreParameters.getIncludeMetadataInHeader(storeParameters);

    this.locale = CSVStoreParameters.getLocale(storeParameters);

    this.geometryManager = GeometryLocator.getGeometryManager();

    this.spatialIndexes = spatialIndex;

    if( spatialIndex != null ) {

        for (SpatialIndex index : spatialIndex.values()) {

            index.removeAll();

        }

    }

  }

  public void beginAppend() {

    try {

      FileOutputStream fos = new FileOutputStream(file, true);

      if (this.charset != null) {

        this.writer = new OutputStreamWriter(fos, this.charset);

      } else {

        this.writer = new OutputStreamWriter(fos);

      }

      this.listWriter = new CsvListWriter(this.writer, this.csvpreferences);

      if (ftype != null) {

        this.descriptors = ftype.getAttributeDescriptors();

        int n = 0;

        for (FeatureAttributeDescriptor descriptor : descriptors) {

          if (descriptor.getEvaluator() == null) {

            n++;

          }

        }

        this.values = new String[n];

      }

    } catch (IOException e) {

      LOGGER.warn("Can't open file for write (" + file.getAbsolutePath() + ").", e);

      throw new RuntimeException(e);

    }

  }

  public void begin() {

    try {

      FileOutputStream fos = new FileOutputStream(file, false);

      if (this.charset != null) {

        this.writer = new OutputStreamWriter(fos, this.charset);

      } else {

        this.writer = new OutputStreamWriter(fos);

      }

    } catch (IOException e) {

      LOGGER.warn("Can't open file for write (" + file.getAbsolutePath() + ").", e);

      throw new RuntimeException(e);

    }

    this.listWriter = new CsvListWriter(this.writer, this.csvpreferences);

    int n = 0;

    for (FeatureAttributeDescriptor descriptor : descriptors) {

      if (!descriptor.isComputed()) { //descriptor.getEvaluator() == null) {

        n++;

      }

    }

    String[] header = new String[n];

    this.values = new String[n];

    n = 0;

      for (FeatureAttributeDescriptor descriptor : descriptors) {

          if (!descriptor.isComputed()) {

              if (includeMetadataInHeader) {

                header[n++] = (String) descriptor.get("all");

              } else {

                header[n++] = (String) descriptor.getName();

              }

          }

      }

      if (includeMetadataInHeader) {

        Tags tags = this.ftype.getTags();

        if( tags!=null && !tags.isEmpty() ) {

          String s = header[0];

            for (String tagName : tags) {

                String value = tags.getString(tagName, null);

                if( value!=null ) {

                    String sep = "/";

                    if(value.contains(sep)){

                        value = StringEscapeUtils.escapeHtml3(value);

                        value = StringUtils.replace(value, sep, "&#"+((int)(sep.charAt(0)))+";");

                        s += sep+"typetagesc"+sep+"html"+sep+tagName+"="+value;

                    } else {

                        s += sep+"typetag"+sep+tagName+"="+value;

                    }

                }

            }

            header[0] = s;

        }

      }

    try {

      listWriter.writeHeader(header);

    } catch (Exception e) {

      LOGGER.warn("Can't write header '" + ArrayUtils.toString(header) + "' file for write (" + file.getAbsolutePath() + ").", e);

      throw new RuntimeException(e);

    }

  }

  public void add(FeatureProvider feature) {

    if (this.calculate_envelope) {

        if (envelopes == null) {

            envelopes = new HashMap<>();

        }

        for (FeatureAttributeDescriptor featureAttributeDescriptor : ftype) {

            if(featureAttributeDescriptor.getType()==DataTypes.GEOMETRY){

                String geomName = featureAttributeDescriptor.getName();

                Geometry geom = (Geometry) feature.get(geomName);

                Envelope env = envelopes.get(geomName);

                if (env == null) {

                    if (geom == null) {

                        envelopes.put(geomName, null);

                    } else {

                        try {

                            envelopes.put(geomName, (Envelope) geom.getEnvelope().clone());

                        } catch (CloneNotSupportedException e) {

                            LOGGER.warn("Este error no deberia pasar, siempre se puede hacer un clone de un envelope.", e);

                        }

                    }

                } else {

                    if (geom != null){

                        env.add(geom.getEnvelope());

                    }

                }

            }

        }

    }

    if(spatialIndexes == null){

        spatialIndexes = new HashMap<>();

    }

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

      FeatureAttributeDescriptor descriptor = descriptors[i];

      if (descriptor.getEvaluator() == null) {

        Object value = feature.get(i);

        try {

          if( descriptor.getType()==DataTypes.GEOMETRY ) {

              String geomName = descriptor.getName();

              Geometry geom = (Geometry) value;

              if(geom != null){

                SpatialIndex index = spatialIndexes.get(geomName);

                if(index != null){

                    index.insert(geom, feature.getOID());

                }

                if( StringUtils.equalsIgnoreCase("WKT", CSVStoreParameters.getGeometryFormat(storeParameters))) {

                  values[i] = geom.convertToWKT();

                } else {

                  values[i] = geom.convertToHexWKB();

                }

              }

          } else {

            values[i] = (String) this.convert.coerce(value, descriptor.getCoercionContext());

          }

        } catch (CoercionException|GeometryOperationNotSupportedException|GeometryOperationException e) {

          try {

            values[i] = value.toString();

          } catch (Exception ex) {

            values[i] = "";

          }

          if (errorcounts++ <= 10) {

            this.lasterror = e;

            LOGGER.warn("Can't convert value of field " + i + " to string in CVS file '" + this.file.getAbsolutePath() + "'.", e);

            if (errorcounts == 10) {

              LOGGER.warn("Too many error writing CVS file '" + this.file.getAbsolutePath() + "', don't output more.");

            }

          }

        }

        values[i] = CSVReaderSuperCSV.escapeCRLF(values[i]);

      }

    }

    try {

      this.listWriter.write(values);

    } catch (IOException e) {

      if (errorcounts++ <= 10) {

        this.lasterror = e;

        LOGGER.warn("Can't write values to CVS file '" + this.file.getAbsolutePath() + "'.", e);

        if (errorcounts == 10) {

          LOGGER.warn("Too many error writing CVS file '" + this.file.getAbsolutePath() + "', don't output more.");

        }

      }

    }

  }

  public void end() throws PerformEditingException {

    if (this.errorcounts > 0) {

      throw new PerformEditingException(this.file.getAbsolutePath(), lasterror);

    }

    if (listWriter != null) {

      try {

        listWriter.close();

      } catch (Exception ex) {

        // Ignore error

      }

      listWriter = null;

    }

    if (writer != null) {

      try {

        writer.close();

      } catch (Exception ex) {

        // Ignore error

      }

      writer = null;

    }

    File indexFile = null;

    try {

        indexFile = CSVReaderSuperCSV.getIndexFile(this.file);

        if(indexFile != null){

            Files.deleteIfExists(indexFile.toPath());

        }

    } catch (Exception ex){

        LOGGER.warn("Can't delete index file '"+(indexFile == null?"null":indexFile.getAbsolutePath())+"'", ex);

    }

    if( spatialIndexes!=null ) {

        for (SpatialIndex index : spatialIndexes.values()) {

            index.flush();

        }

    }

  }

  public Map<String,Envelope> getEnvelopes() {

    return this.envelopes;

  }

}