package de.intevation.gnv.utils;

import java.io.File;
import java.io.IOException;
import java.io.Serializable;
import java.net.MalformedURLException;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.log4j.Logger;
import org.geotools.data.DataStoreFactorySpi;
import org.geotools.data.DataUtilities;
import org.geotools.data.DefaultTransaction;
import org.geotools.data.FeatureStore;
import org.geotools.data.Transaction;
import org.geotools.data.shapefile.ShapefileDataStore;
import org.geotools.data.shapefile.ShapefileDataStoreFactory;
import org.geotools.feature.FeatureCollection;
import org.geotools.feature.FeatureCollections;
import org.geotools.feature.SchemaException;
import org.geotools.feature.simple.SimpleFeatureBuilder;
import org.geotools.referencing.crs.DefaultGeographicCRS;
import org.opengis.feature.simple.SimpleFeature;
import org.opengis.feature.simple.SimpleFeatureType;

import com.vividsolutions.jts.geom.Geometry;
import com.vividsolutions.jts.geom.MultiLineString;
import com.vividsolutions.jts.geom.MultiPolygon;
import com.vividsolutions.jts.io.ParseException;
import com.vividsolutions.jts.io.WKTReader;

import de.intevation.gnv.geobackend.base.Result;
import de.intevation.gnv.geobackend.base.ResultDescriptor;

/**
 * @author Sascha L. Teichmann (sascha.teichmann@intevation.de)
 */
public final class ShapeFileWriter
{
    private static Logger log = Logger.getLogger(
        ShapeFileWriter.class);

    private ShapeFileWriter() {
    }

    public static boolean writeMultiLineStringsToFile(
        File                                shapeFile,
        Integer                             parameterId,
        Integer                             layer,
        Date                                date,
        List<Pair<Object, MultiLineString>> multiLineStrings
    ) {
        return writeMultiLineStringsToFile(
            shapeFile,
            parameterId,
            layer,
            date,
            multiLineStrings, 
            "isolines");
    }

    public static boolean writeMultiLineStringsToFile(
        File                                shapeFile,
        Integer                             parameterId,
        Integer                             layer,
        Date                                date,
        List<Pair<Object, MultiLineString>> multiLineStrings,
        String                              name
    ) {
        Map<String, Serializable> params = new HashMap<String, Serializable>();

        try {
            params.put("url", shapeFile.toURI().toURL());
        }
        catch (MalformedURLException mue) {
            log.error(mue.getLocalizedMessage(), mue);
            return false;
        }

        params.put("create spatial index", Boolean.TRUE);


        if (name == null) {
            name = shapeFile.getName();
        }

        SimpleFeatureType TYPE;
        
        try { 
            TYPE = DataUtilities.createType(
                name,
                "geom:MultiLineString:srid=4326," +
                "PARAMETER:Integer," + 
                "LAYER:Integer,"     +
                "DATE:Date,"         +
                "VALUE:Double");
        }
        catch (SchemaException se) {
            log.error(se.getLocalizedMessage(), se);
            return false;
        }

        SimpleFeatureBuilder featureBuilder =
            new SimpleFeatureBuilder(TYPE);

        FeatureCollection<SimpleFeatureType, SimpleFeature> collection = 
            FeatureCollections.newCollection();

        for (Pair<Object, MultiLineString> pair: multiLineStrings) {
            featureBuilder.add(pair.getB());
            featureBuilder.add(parameterId);
            featureBuilder.add(layer);
            featureBuilder.add(date);
            featureBuilder.add(pair.getA());
            SimpleFeature feature = featureBuilder.buildFeature(null);
            collection.add(feature);
        }

        DataStoreFactorySpi dataStoreFactory = new ShapefileDataStoreFactory();

        Transaction transaction = null;

        boolean success = false;
        try {
            ShapefileDataStore newDataStore =
                (ShapefileDataStore)dataStoreFactory.createNewDataStore(params);

            newDataStore.createSchema(TYPE);
            newDataStore.forceSchemaCRS(DefaultGeographicCRS.WGS84);

            transaction = new DefaultTransaction("create");

            String typeName = newDataStore.getTypeNames()[0];

            FeatureStore<SimpleFeatureType, SimpleFeature> featureStore =
                (FeatureStore<SimpleFeatureType, SimpleFeature>)
                    newDataStore.getFeatureSource(typeName);

            featureStore.setTransaction(transaction);

            featureStore.addFeatures(collection);
            transaction.commit();
            success = true;
        } 
        catch (IOException ioe) {
            log.error(ioe.getLocalizedMessage(), ioe);
        }
        finally {
            if (transaction != null) {
                if (!success) {
                    try { transaction.rollback(); }
                    catch (IOException ioe) {}
                }
                try { transaction.close(); }
                catch (IOException ioe) {}
            }
        }

        return success;
    }

    public static boolean writeMultiPolygonsToFile(
        File                       shapeFile,
        Integer                    parameterId,
        Integer                    layer,
        Date                       date,
        Map<Integer, MultiPolygon> multiPolygons
    ) {
        return writeMultiPolygonsToFile(
            shapeFile, 
            parameterId,
            layer,
            date,
            multiPolygons, 
            "polygons");
    }

    
    public static String writeDataToFile(File shapeFile,
                                          String name,
                                          Collection<Result> data){
        String geomType = null;
        
        WKTReader wktReader = new WKTReader();
        
        Map<String, Serializable> params = new HashMap<String, Serializable>();

        try {
            params.put("url", shapeFile.toURI().toURL());
        }
        catch (MalformedURLException mue) {
            log.error(mue.getLocalizedMessage(), mue);
            return null;
        }

        params.put("create spatial index", Boolean.TRUE);


        if (name == null) {
            name = shapeFile.getName();
        }

        SimpleFeatureType type = null;
        SimpleFeatureBuilder featureBuilder = null;
        FeatureCollection<SimpleFeatureType, SimpleFeature> collection = 
            FeatureCollections.newCollection();
        int j = 0;
        for (Result result: data) {
            j++;
            try {
                Geometry g = wktReader.read(result.getString(0));
                ResultDescriptor rd = result.getResultDescriptor();
                int columns = rd.getColumnCount();
                if (type == null){
                    try { 
                        geomType = g.getGeometryType().toUpperCase();
                        String schema = "geom:"+g.getGeometryType()+":srid=4326";
                        for (int i = 1; i < columns; i++){
                            schema+=","+rd.getColumnName(i)+
                                    ":"+rd.getColumnClassName(i);
                        }
                        type = DataUtilities.createType(name, schema);
                    }
                    catch (SchemaException se) {
                        log.error(se.getLocalizedMessage(), se);
                        return null;
                    }
                    featureBuilder = new SimpleFeatureBuilder(type);
                }
                featureBuilder.add(g);
                for (int i = 1; i < columns; i++){
                    featureBuilder.add(result.getObject(i));
                }
                SimpleFeature feature = featureBuilder.buildFeature(null);
                collection.add(feature);
            } catch (ParseException e) {
                log.error("cannot create geometry "+j+" for "+result.getString(0));
            } catch (java.lang.IllegalArgumentException e){
                log.error("cannot create geometry for "+result.getString(0));
            }
        }

        DataStoreFactorySpi dataStoreFactory = new ShapefileDataStoreFactory();

        Transaction transaction = null;

        boolean success = false;
        try {
            ShapefileDataStore newDataStore =
                (ShapefileDataStore)dataStoreFactory.createNewDataStore(params);

            newDataStore.createSchema(type);
            newDataStore.forceSchemaCRS(DefaultGeographicCRS.WGS84);

            transaction = new DefaultTransaction("create");

            String typeName = newDataStore.getTypeNames()[0];

            FeatureStore<SimpleFeatureType, SimpleFeature> featureStore =
                (FeatureStore<SimpleFeatureType, SimpleFeature>)
                    newDataStore.getFeatureSource(typeName);

            featureStore.setTransaction(transaction);

            featureStore.addFeatures(collection);
            transaction.commit();
            success = true;
        } 
        catch (IOException ioe) {
            log.error(ioe.getLocalizedMessage(), ioe);
        }
        finally {
            if (transaction != null) {
                if (!success) {
                    try { transaction.rollback(); }
                    catch (IOException ioe) {}
                }
                try { transaction.close(); }
                catch (IOException ioe) {}
            }
        }

        return geomType;
        
    }
    
    public static boolean writeMultiPolygonsToFile(
        File                       shapeFile,
        Integer                    parameterId,
        Integer                    layer,
        Date                       date,
        Map<Integer, MultiPolygon> multiPolygons,
        String                     name
    ) {
        Map<String, Serializable> params = new HashMap<String, Serializable>();

        try {
            params.put("url", shapeFile.toURI().toURL());
        }
        catch (MalformedURLException mue) {
            log.error(mue.getLocalizedMessage(), mue);
            return false;
        }

        params.put("create spatial index", Boolean.TRUE);


        if (name == null) {
            name = shapeFile.getName();
        }

        SimpleFeatureType TYPE;
        
        try { 
            TYPE = DataUtilities.createType(
                name,
                "geom:MultiPolygon:srid=4326," +
                "PARAMETER:Integer," + 
                "LAYER:Integer,"     +
                "DATE:Date,"         +
                "CLASS:Integer");
        }
        catch (SchemaException se) {
            log.error(se.getLocalizedMessage(), se);
            return false;
        }

        SimpleFeatureBuilder featureBuilder =
            new SimpleFeatureBuilder(TYPE);

        FeatureCollection<SimpleFeatureType, SimpleFeature> collection = 
            FeatureCollections.newCollection();

        for (Map.Entry<Integer, MultiPolygon> entry:
            multiPolygons.entrySet()
        ) {
            featureBuilder.add(entry.getValue());
            featureBuilder.add(parameterId);
            featureBuilder.add(layer);
            featureBuilder.add(date);
            featureBuilder.add(entry.getKey());
            SimpleFeature feature = featureBuilder.buildFeature(null);
            collection.add(feature);
        }

        DataStoreFactorySpi dataStoreFactory = new ShapefileDataStoreFactory();

        Transaction transaction = null;

        boolean success = false;
        try {
            ShapefileDataStore newDataStore =
                (ShapefileDataStore)dataStoreFactory.createNewDataStore(params);

            newDataStore.createSchema(TYPE);
            newDataStore.forceSchemaCRS(DefaultGeographicCRS.WGS84);

            transaction = new DefaultTransaction("create");

            String typeName = newDataStore.getTypeNames()[0];

            FeatureStore<SimpleFeatureType, SimpleFeature> featureStore =
                (FeatureStore<SimpleFeatureType, SimpleFeature>)
                    newDataStore.getFeatureSource(typeName);

            featureStore.setTransaction(transaction);

            featureStore.addFeatures(collection);
            transaction.commit();
            success = true;
        } 
        catch (IOException ioe) {
            log.error(ioe.getLocalizedMessage(), ioe);
        }
        finally {
            if (transaction != null) {
                if (!success) {
                    try { transaction.rollback(); }
                    catch (IOException ioe) {}
                }
                try { transaction.close(); }
                catch (IOException ioe) {}
            }
        }

        return success;
    }

    private static final Double asDouble(Object a) {
        if (a instanceof Double) {
            return (Double)a;
        }
        if (a instanceof Number) {
            return Double.valueOf(((Number)a).doubleValue());
        }
        return 0d;
    }
}
// vim:set ts=4 sw=4 si et sta sts=4 fenc=utf8 :