/*
 * Copyright (c) 2014-2015 The Regents of the University of California.
 * All rights reserved.
 *
 * '$Author: crawl $'
 * '$Date: 2018-03-15 18:14:49 +0000 (Thu, 15 Mar 2018) $' 
 * '$Revision: 34676 $'
 * 
 * Permission is hereby granted, without written agreement and without
 * license or royalty fees, to use, copy, modify, and distribute this
 * software and its documentation for any purpose, provided that the above
 * copyright notice and the following two paragraphs appear in all copies
 * of this software.
 *
 * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY
 * FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
 * THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE
 * PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF
 * CALIFORNIA HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES,
 * ENHANCEMENTS, OR MODIFICATIONS.
 *
 */
package org.kepler.gis.util;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Map;
import java.util.Set;

import javax.xml.parsers.ParserConfigurationException;

import org.apache.commons.io.FileUtils;
import org.apache.commons.io.FilenameUtils;
import org.geotools.GML;
import org.geotools.GML.Version;
import org.geotools.data.DataStore;
import org.geotools.data.DataStoreFinder;
import org.geotools.data.DataUtilities;
import org.geotools.data.FeatureSource;
import org.geotools.data.FileDataStoreFinder;
import org.geotools.data.ogr.OGRDataStoreFactory;
import org.geotools.data.ogr.bridj.BridjOGRDataStoreFactory;
import org.geotools.data.simple.SimpleFeatureCollection;
import org.geotools.data.simple.SimpleFeatureIterator;
import org.geotools.feature.DefaultFeatureCollection;
import org.geotools.feature.simple.SimpleFeatureBuilder;
import org.geotools.feature.simple.SimpleFeatureTypeBuilder;
import org.geotools.filter.text.ecql.ECQL;
import org.geotools.geojson.feature.FeatureJSON;
import org.geotools.geometry.jts.JTS;
import org.geotools.geometry.jts.ReferencedEnvelope;
import org.geotools.kml.KMLConfiguration;
import org.geotools.referencing.CRS;
import org.geotools.xml.Parser;
import org.json.JSONException;
import org.json.JSONObject;
import org.kepler.gis.data.VectorToken;
import org.opengis.feature.Feature;
import org.opengis.feature.simple.SimpleFeature;
import org.opengis.feature.simple.SimpleFeatureType;
import org.opengis.filter.Filter;
import org.opengis.geometry.MismatchedDimensionException;
import org.opengis.geometry.coordinate.Polygon;
import org.opengis.referencing.FactoryException;
import org.opengis.referencing.crs.CoordinateReferenceSystem;
import org.opengis.referencing.operation.MathTransform;
import org.opengis.referencing.operation.TransformException;
import org.xml.sax.SAXException;

import com.vividsolutions.jts.geom.Geometry;

import ptolemy.kernel.util.IllegalActionException;
import ptolemy.util.MessageHandler;

/** A collection of utilities for vectors/features.
 * 
 *  @author Daniel Crawl
 *  @version $Id: VectorUtilities.java 34676 2018-03-15 18:14:49Z crawl $
 *  
 */
public class VectorUtilities {

    /** Close all data stores opened in this thread while reading files. */
    public static void closeDataStores() {
        
        synchronized(_dataStoresMap) {
            Set<DataStore> dataStores = _dataStoresMap.get(Thread.currentThread());
            if(dataStores != null) {
                for(DataStore store : dataStores) {
                    //System.out.println(Thread.currentThread().getId() + " closing " + store);
                    store.dispose();
                }
                dataStores.clear();
                _dataStoresMap.remove(Thread.currentThread());
            }
        }
    }

    /** Create an empty feature schema
     *  @param defaultCRS The default CRS. can be null.
     *  @return an empty feature schema.
     */
    public static SimpleFeatureType createEmptySchema(CoordinateReferenceSystem defaultCRS) {
        SimpleFeatureTypeBuilder builder = new SimpleFeatureTypeBuilder();
        builder.setName("unknown");
        if(defaultCRS != null) {
            builder.setCRS(defaultCRS);
        }
        builder.add("geom", Polygon.class);
        return builder.buildFeatureType();
    }

    /** Create a vector token from reading a file containing features. */
    public static VectorToken readFile(File inputFile)
            throws IllegalActionException, IOException {
        return readFile(inputFile, null, null);
    }
    
    /** Create a vector token from a specific type in a file containing features.
     *  @param inputFile the file to read
     *  @param typeNameStr the feature type in the file to read. this can be
     *  null, but must be specified if more than one feature type is present
     *  in the file.
     */
    public static VectorToken readFile(File inputFile, String typeNameStr) 
            throws IllegalActionException, IOException {
        return readFile(inputFile, typeNameStr, null);
    }

    /** Create a vector token from a specific type in a file containing features.
     *  @param inputFile the file to read
     *  @param typeNameStr the feature type in the file to read. this can be
     *  null, but must be specified if more than one feature type is present
     *  in the file.
     *  @param crs The coordinate reference system used if not specified in the file.
     */
    public static VectorToken readFile(File inputFile, String typeNameStr, CoordinateReferenceSystem defaultCRS)
            throws IllegalActionException, IOException {
        
        //System.out.println("reading " + inputFile);
        
        SimpleFeatureCollection features;
        
        final String filenameStr = inputFile.getAbsolutePath();
        
        if(filenameStr.toLowerCase().endsWith(".json") ||
                filenameStr.toLowerCase().endsWith(".geojson")) {
            try {
                return readGeoJSONString(FileUtils.readFileToString(inputFile), defaultCRS);
            } catch (JSONException e) {
                throw new IOException("Error parsing " + inputFile +
                    ": " + e.getMessage(), e);
            }
        } else if(filenameStr.toLowerCase().endsWith(".gml")) {
            try {
                // TODO defaultCRS
                return readGMLString(FileUtils.readFileToString(inputFile));
            } catch(IOException | IllegalActionException e) {
                throw new IOException("Error parsing " + inputFile +
                    ": " + e.getMessage(), e);
            }            
        } else if(filenameStr.toLowerCase().endsWith(".kml")) {
            
            Parser parser = new Parser(new KMLConfiguration());
            
            try(FileInputStream stream = new FileInputStream(inputFile)) {
                SimpleFeature feature = (SimpleFeature) parser.parse(stream);
                Collection<SimpleFeature> collection =
                        (Collection<SimpleFeature>) feature.getAttribute("Feature");
                features = new DefaultFeatureCollection();
                ((DefaultFeatureCollection) features).addAll(collection);
                
                if(defaultCRS != null &&
                    features.getSchema().getCoordinateReferenceSystem() == null) {
                    features = setCRS(features, defaultCRS);
                }                
                return new VectorToken(features);
            } catch (IOException | SAXException | ParserConfigurationException e) {
                throw new IOException("Error reading KML file " + filenameStr, e);
            }

        }
        
        DataStore store = _getDataStoreForFile(inputFile);
        
        try {
            return _getVectorDataFromStore(store, typeNameStr, defaultCRS);
        } catch(Exception e) {
            throw new IOException("Error reading vector data from file " + inputFile, e);
        }
    }

    /** Read a string containing either GML or GeoJSON. */
    public static VectorToken readGeoString(String geoString, CoordinateReferenceSystem defaultCRS)
        throws IllegalActionException, IOException, JSONException {
    
        // see if it looks like GML
        if(geoString.startsWith("<?xml") || geoString.startsWith("<gml")) {
            return readGMLString(geoString /*, TODO defaultCRS*/);
        }
        
        // try geojson
        return readGeoJSONString(geoString, defaultCRS);
    }

    /** Read a string containing GeoJSON. */
    public static VectorToken readGeoJSONString(String geoJSON) throws IOException, JSONException, IllegalActionException {
        return readGeoJSONString(geoJSON, null);
    }
    
    /** Read a string containing GeoJSON using a default CRS. The default
     *  CRS is only used if the GeoJSON string does not contain the CRS. 
     */
    public static VectorToken readGeoJSONString(String geoJSON, CoordinateReferenceSystem defaultCRS) throws IOException, JSONException, IllegalActionException {
        
        SimpleFeatureCollection features = readGeoJSONString(geoJSON, defaultCRS, null);
        return new VectorToken(features);
    }
    
    /** Read a string containing GeoJSON.
     *  @param geoJSON the geojson string.
     *  @param defaultCRS CRS used if one not found in geojson string.
     *  @param defaultType feture type used if one not found in geojson string.
     *  @return Features in geojson string.
     */
    public static SimpleFeatureCollection readGeoJSONString(String geoJSON, CoordinateReferenceSystem defaultCRS, SimpleFeatureType defaultType) throws IOException, JSONException, IllegalActionException {
        
        FeatureJSON featureJSON = new FeatureJSON();
        
        if(defaultType != null) {
            featureJSON.setFeatureType(defaultType);
        }
        
        byte[] bytes = geoJSON.getBytes();
        
        JSONObject json;
        try {
            json = new JSONObject(geoJSON);
        } catch (JSONException e) {
            throw new IOException("Error converting string to JSON.", e);
        }
        
        if(!json.has("type")) {
            throw new IOException("No type field in GeoJSON string.");
        }
        String type = json.getString("type");
        
        SimpleFeatureCollection features = null;
        
        if(type.equals("FeatureCollection")) {
            try(InputStream stream = new ByteArrayInputStream(bytes)) {
                features =  (SimpleFeatureCollection) featureJSON.readFeatureCollection(stream);
            } 
        } else if(type.equals("Feature")) {            
            try(InputStream stream = new ByteArrayInputStream(bytes)) {
                SimpleFeature feature = featureJSON.readFeature(stream);
                features = DataUtilities.collection(feature);
            }
        } else {
            System.err.println("WARNING: unhandled type of GeoJSON: " + type);
            features = DataUtilities.collection(new LinkedList<SimpleFeature>());
        }
        
        // see if the GeoJSON string does not have a CRS and we were
        // given a default CRS
        if(defaultCRS != null && !json.has("crs")) {
            features = setCRS(features, defaultCRS);       
        }
        
        return features;
    }
        
    /** Read a string containing GML. */
    public static VectorToken readGMLString(String gmlString) throws IOException, IllegalActionException {
        
        // TODO try version 3, too. how can we distinguish?
        
        GML gml = new GML(Version.GML2);
        
        try(InputStream stream = new ByteArrayInputStream(gmlString.getBytes())) {
            SimpleFeatureCollection features;
            try {
                features = gml.decodeFeatureCollection(stream);
            } catch (SAXException | ParserConfigurationException e) {
                throw new IOException("Error parsing GML: " + e.getMessage(), e);
            }
            //System.out.println(toGeoJSONString(features));
            return new VectorToken(features);
        }
    }

    /** Get a vector token from a WFS service.
     *  @param urlStr the WFS url
     *  @param typeNameStr the feature type to read. can be null, but must
     *  be specified if more than one type exists on in the WFS service.
     * 
     */
    public static VectorToken readWFS(String urlStr, String typeNameStr) throws IOException, IllegalActionException {
        
        String getCapabilities = null;
        
        if(urlStr.toLowerCase().contains("request=getcapabilities")) {
            getCapabilities = urlStr;
        } else {
            getCapabilities = urlStr + "?service=wfs&version=1.0.0&REQUEST=GetCapabilities";
        }

        System.out.println("Using WFS url: " + getCapabilities);
        
        Map<String,Object> connectionParameters = new HashMap<String,Object>();
        connectionParameters.put("WFSDataStoreFactory:GET_CAPABILITIES_URL", getCapabilities);
        // NOTE: the default timeout is 3000ms, which is too small
        // for some servers
        connectionParameters.put("WFSDataStoreFactory:TIMEOUT", 20000);
        
        DataStore store = DataStoreFinder.getDataStore(connectionParameters);

        return _getVectorDataFromStore(store, typeNameStr, null);
    }

    /** Reproject a set of features.
     *  @param features The set of features.
     *  @param destCRS The new coordinate reference system.
     *  @return The reprojected set of features.
     */
    public static SimpleFeatureCollection reproject(SimpleFeatureCollection features,
        CoordinateReferenceSystem destCRS) throws IllegalActionException {
        return reproject(features, features.getSchema().getCoordinateReferenceSystem(),
            destCRS);
    }
    
    /** Reproject a set of features from the specified coordinate reference system.
     *  @param features The set of features.
     *  @param crs The source coordinate reference system.
     *  @param destCRS The new coordinate reference system.
     *  @return The reprojected set of features.
     */
    public static SimpleFeatureCollection reproject(SimpleFeatureCollection features,
        CoordinateReferenceSystem crs, CoordinateReferenceSystem destCRS)
        throws IllegalActionException {

        if(crs == null) {
            throw new IllegalActionException("Source CRS is null.");
        }
        
        if(crs.equals(destCRS)) {
            return features;
        }

        MathTransform transform;
        try {
            transform = CRS.findMathTransform(crs, destCRS, true);
        } catch (FactoryException e) {
            throw new IllegalActionException(
                "Error finding reprojection transformation: " + e.getMessage());
        }
        
        SimpleFeatureType transformedSchema = SimpleFeatureTypeBuilder.retype(features.getSchema(), destCRS);
            
        DefaultFeatureCollection newCollection =
            new DefaultFeatureCollection(features.getID(), transformedSchema);
        SimpleFeatureBuilder builder = new SimpleFeatureBuilder(transformedSchema);
        
        try(SimpleFeatureIterator iterator = features.features();) {
            while(iterator.hasNext()) {
                SimpleFeature feature = (SimpleFeature) iterator.next();
                Geometry geometry = (Geometry) feature.getDefaultGeometry();
                Geometry reprojectedGeometry = JTS.transform(geometry, transform);
                
                builder.init(feature);
                SimpleFeature newFeature = builder.buildFeature(feature.getID());
                newFeature.setDefaultGeometry(reprojectedGeometry);
                newCollection.add(newFeature);
            }
            
        } catch (MismatchedDimensionException | TransformException e) {
            throw new IllegalActionException("Error reprojecting features: " + e.getMessage());
        }
        
        return newCollection;
    }
    
    /** Set the coordinate reference system for a set of features. */
    public static SimpleFeatureCollection setCRS(SimpleFeatureCollection features, CoordinateReferenceSystem defaultCRS) {
        
        SimpleFeatureType schema = features.getSchema();
        
        SimpleFeatureType transformedSchema;
        if(schema == null) {
            transformedSchema = createEmptySchema(defaultCRS);
        } else {
            transformedSchema = SimpleFeatureTypeBuilder.retype(schema, defaultCRS);
        }
        
        DefaultFeatureCollection newCollection =
            new DefaultFeatureCollection(features.getID(), transformedSchema);
        SimpleFeatureBuilder builder = new SimpleFeatureBuilder(transformedSchema);
        
        try(SimpleFeatureIterator iterator = features.features();) {
            while(iterator.hasNext()) {
                SimpleFeature feature = (SimpleFeature) iterator.next();
                Geometry geometry = (Geometry) feature.getDefaultGeometry();
                
                builder.init(feature);
                SimpleFeature newFeature = builder.buildFeature(feature.getID());
                newFeature.setDefaultGeometry(geometry);
                newCollection.add(newFeature);
            }
        }
        return newCollection;
    }

    /** Convert a set of features into a GeoJSON string. */
    public static String toGeoJSONString(SimpleFeatureCollection features) {
        
        FeatureJSON featureJSON = new FeatureJSON();
        featureJSON.setEncodeFeatureCollectionCRS(true);
        try {
            return featureJSON.toString(features);
        } catch (IOException e) {
            MessageHandler.error("Error writing feature collection.", e);
            return "";
        }
    }

    ////////////////////////////////////////////////////////////////////////
    //// private methods                                                ////

    /** Get the data store for a file. */
    private static DataStore _getDataStoreForFile(File file) throws IOException {
        
        if(file.getName().endsWith(".shp")) {        
            return FileDataStoreFinder.getDataStore(file);
        } else {
            String extension = FilenameUtils.getExtension(file.getName());            
            Map<String, String> connectionParams = new HashMap<String, String>();
            connectionParams.put("DriverName", extension.toUpperCase());
            connectionParams.put("DatasourceName", file.getAbsolutePath());
            return _ogrFactory.createDataStore(connectionParams);
        }        
    }

    /** Create a vector token from reading a data store.
     *  @param store the data store
     *  @param typeNameStr the feature type to read. can be null, but must be
     *  specified if the data store contains more than one type.
     *  @param defaultCRS The coordinate reference system used if not specified in the file.
     */
    private static VectorToken _getVectorDataFromStore(DataStore store,
            String typeNameStr, CoordinateReferenceSystem defaultCRS)
            throws IllegalActionException, IOException {
        
        synchronized(_dataStoresMap) {
            Set<DataStore> stores = _dataStoresMap.get(Thread.currentThread());
            if(stores == null) {
                stores = new HashSet<DataStore>();
                _dataStoresMap.put(Thread.currentThread(), stores);
            }
            stores.add(store);
            //System.out.println(Thread.currentThread().getId() + " opened " + inputFile);
        }

        String[] typeNames = store.getTypeNames();
        
        if(typeNames.length == 0) {
            throw new IllegalActionException("No type names found in data store.");
        }
                
        if(typeNameStr == null) {
            if(typeNames.length == 1) {
                return new VectorToken(store.getFeatureSource(typeNames[0]), defaultCRS);
            } else {
                throw new IllegalActionException("More than one feature type found in the input.\n" +
                        "Specify the type in the typeName parameter.");
            }
        }
        
        for(String name : typeNames) {
            if(name.equals(typeNameStr)) {
                return new VectorToken(store.getFeatureSource(typeNameStr), defaultCRS);
            }
        }
        
        throw new IllegalActionException("Type " + typeNameStr +
                " was not found in the data store.");
        
    }
        
    ////////////////////////////////////////////////////////////////////////
    //// private variables                                              ////

    /** Factory to read vector/feature files using GDAL via Bridj. */
    private static OGRDataStoreFactory _ogrFactory = new BridjOGRDataStoreFactory();

    /** Mapping of thread to data store. */
    private static Map<Thread,Set<DataStore>> _dataStoresMap =
            new HashMap<Thread,Set<DataStore>>();
    
    
    /** For debugging, ignore. */
    public static void main(String[] args) {
        
        try {
            String getCapabilities = "http://mapserver.flightgear.org/ms?Service=WFS&Version=1.0.0&request=GetCapabilities";
    
            Map<String,Object> connectionParameters = new HashMap<String,Object>();
            connectionParameters.put("WFSDataStoreFactory:GET_CAPABILITIES_URL", getCapabilities );
            connectionParameters.put("WFSDataStoreFactory:TIMEOUT", 20000);

            // Step 2 - connection
            DataStore data = DataStoreFinder.getDataStore( connectionParameters );
    
            // Step 3 - discovery
            //String typeNames[] = data.getTypeNames();
            //String typeName = typeNames[0];
            String typeName = "cs_lake";
            SimpleFeatureType schema = data.getSchema( typeName );
            
            // Step 4 - target
            FeatureSource<SimpleFeatureType, SimpleFeature> source = data.getFeatureSource( typeName );
            System.out.println( "Metadata Bounds:"+ source.getBounds() );
    
            // Step 5 - query
            String geomName = schema.getGeometryDescriptor().getLocalName();
            System.out.println("geom name = " + geomName);
            
            /*
            ReferencedEnvelope bbox = new ReferencedEnvelope(-117.6488, 32.501, -116.058, 33.66,
                    DefaultGeographicCRS.WGS84 );
    
            FilterFactory2 ff = CommonFactoryFinder.getFilterFactory2( GeoTools.getDefaultHints() );
            Filter filter = ff.bbox(ff.property(geomName), bbox);
             */
            
            Filter filter = ECQL.toFilter("BBOX(msGeometry, -117.6488, 32.501, -116.058, 33.66)");
            
            SimpleFeatureCollection features = (SimpleFeatureCollection) source.getFeatures( filter );
    
            System.out.println("filter = " + filter);

            System.out.println("there are " + features.size() + " features");
            
            ReferencedEnvelope bounds = new ReferencedEnvelope();
            try(SimpleFeatureIterator iterator = features.features()) {
                while( iterator.hasNext() ){
                    Feature feature = (Feature) iterator.next();
                    bounds.include( feature.getBounds() );
                }
                System.out.println( "Calculated Bounds:"+ bounds );    
            }       
            
            //System.out.println(toGeoJSONString(features));
            
        } catch(Throwable t) {
            System.err.println("Error: " + t.getMessage());
        }
    }
}