/*
 * Copyright (c) 2017 The Regents of the University of California.
 * All rights reserved.
 *
 * '$Author: crawl $'
 * '$Date: 2017-03-27 21:55:16 +0000 (Mon, 27 Mar 2017) $' 
 * '$Revision: 34553 $'
 * 
 * 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.actor.pylaski;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;

import org.geotools.data.simple.SimpleFeatureCollection;
import org.geotools.data.simple.SimpleFeatureIterator;
import org.kepler.gis.data.VectorToken;
import org.opengis.feature.simple.SimpleFeature;

import ptolemy.actor.lib.Transformer;
import ptolemy.actor.parameters.PortParameter;
import ptolemy.data.ArrayToken;
import ptolemy.data.DoubleToken;
import ptolemy.data.IntToken;
import ptolemy.data.StringToken;
import ptolemy.data.Token;
import ptolemy.data.type.ArrayType;
import ptolemy.data.type.BaseType;
import ptolemy.kernel.CompositeEntity;
import ptolemy.kernel.util.IllegalActionException;
import ptolemy.kernel.util.NameDuplicationException;
import ptolemy.kernel.util.SingletonAttribute;

/** Extract measurements in query results from GetPylaskiMeasurements.
 *
 * @author Ben Fleming
 * @version $Id: PylaskiProperty.java 34553 2017-03-27 21:55:16Z crawl $
 */
public class PylaskiProperty extends Transformer
{
        //
        public PortParameter propertyName;

        // The format of the date/time values provided by the Pylaski API
        public static final String DATE_FORMAT = "yyyy-MM-dd HH:mm:ssZ";

        /**
         *
         * @param container
         * @param name
         * @throws NameDuplicationException
         * @throws IllegalActionException
         */
        public PylaskiProperty(CompositeEntity container, String name)
        throws NameDuplicationException, IllegalActionException
        {
                super(container, name);

                input.setTypeEquals(VectorToken.VECTOR);
                output.setTypeEquals(new ArrayType(BaseType.DOUBLE));

                propertyName = new PortParameter(this, "name");
                propertyName.setStringMode(true);
                propertyName.setTypeEquals(BaseType.STRING);
                propertyName.getPort().setTypeEquals(BaseType.STRING);
                new SingletonAttribute(propertyName.getPort(), "_showName");
        }

        /**
         *
         * @throws IllegalActionException
         */
        @Override
        public void fire()
        throws IllegalActionException
        {
                super.fire();

                propertyName.update();

                StringToken nameToken = (StringToken) propertyName.getToken();
                String nameStr = (nameToken == null ? "" : nameToken.stringValue()).trim();

                if(nameStr.isEmpty())
                {
                        throw new IllegalActionException(this, "Property name must not be empty.");
                }

                ArrayList<Token> propertyValues = new ArrayList<>();

                VectorToken vectorToken = (VectorToken) input.get(0);
                SimpleFeatureCollection features = vectorToken.getVectors();

                SimpleFeature closestDataFeature = null;
                SimpleFeature closestForecastFeature = null;

                try(SimpleFeatureIterator iterator = features.features())
                {
                        while(iterator.hasNext())
                        {
                                SimpleFeature feature = iterator.next();

                                // TODO Get closest distance
                                // So far can't do this as required data is stripped out
                                // Include a "must-have" property list IO port/parameter

                                Object distanceMap = feature.getAttribute("distanceFromLocation");
                                //System.out.println(distanceMap);
                                // Object propertyValue = feature.getAttribute(nameStr);

                                if(closestDataFeature == null)
                                {
                                        closestDataFeature = feature;
                                }
                        }
                }

                if(closestDataFeature != null)
                {
                        propertyValues.addAll(_getPropertyValueTokens(nameStr, closestDataFeature));
                }

                if(closestForecastFeature != null)
                {
                        propertyValues.addAll(_getPropertyValueTokens(nameStr, closestForecastFeature));
                }

                if(propertyValues.isEmpty())
                {
                        throw new IllegalActionException(this, "Property " + nameStr + " was not found in features.");
                }

                output.broadcast(new ArrayToken(propertyValues.toArray(new Token[propertyValues.size()])));
        }

        /**
         *
         * @param property
         * @param value
         * @return
         */
        private Token _getPropertyValueToken(String property, Object value)
                throws IllegalActionException
        {
                switch(property)
                {
                        case "temperature":
                        case "wind_speed":
                        {
                                return new DoubleToken(value == null ? 0 : (Double) value);
                        }

                        case "timestamp":
                        {
                                DateFormat df = new SimpleDateFormat(DATE_FORMAT);

                                try
                                {
                                        Date timestamp = df.parse(value.toString());

                                        return new DoubleToken((double) timestamp.getTime());
                                }
                                catch(ParseException e)
                                {
                                        //System.out.println("TIMESTAMP COULD NOT BE PARSED");
                                        throw new IllegalActionException(this, e, "Timestamp couldn't be parsed.");
                                }
                        }
                }

                if(value instanceof Double)
                {
                        return new DoubleToken((Double) value);
                }

                if(value instanceof Integer)
                {
                        return new IntToken((Integer) value);
                }

                return new StringToken(value.toString());
        }

        /**
         *
         * @param property
         * @param values
         * @return
         */
        private ArrayList<Token> _getPropertyValueTokens(String property, Object values)
            throws IllegalActionException
        {
                ArrayList<Token> tokenValues = new ArrayList<>();

                if(values instanceof ArrayList)
                {
                        for(Object value : (ArrayList<?>) values)
                        {
                                tokenValues.add(_getPropertyValueToken(property, value));
                        }
                }
                else
                {
                        tokenValues.add(_getPropertyValueToken(property, values));
                }

                return tokenValues;
        }

        /**
         *
         * @param property
         * @param feature
         * @return
         */
        private ArrayList<Token> _getPropertyValueTokens(String property, SimpleFeature feature)
                throws IllegalActionException
        {
                return _getPropertyValueTokens(property, feature.getAttribute(property));
        }
}