/*
 * 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.net.URI;
import java.net.URISyntaxException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashSet;
import java.util.Set;

import org.geotools.feature.DefaultFeatureCollection;
import org.kepler.gis.data.VectorToken;

/**
 * Utility functions and classes for interfacing with the Pylaski REST API
 *
 * @see https://github.com/words-sdsc/wifire/blob/master/pylaski.ipynb
 * 
 * @author Ben Fleming
 * @version $Id: PylaskiUtilities.java 34553 2017-03-27 21:55:16Z crawl $
 */
public class PylaskiUtilities {
    /** This class cannot be instantiated. */
    private PylaskiUtilities() {
    }

    /**
     * Maps the selection enums (see above) to their string counterparts. Used
     * when building URI's.
     *
     * @param selection
     *            The selection enum
     * @return The string counterpart
     */
    public static String getSelectionString(Selection selection) {
        switch (selection) {
        case CLOSEST_TO:
            return "closestTo";
        case BOUNDING_BOX:
            return "boundingBox";
        case WITHIN_RADIUS:
            return "withinRadius";
        }

        return null;
    }

    /**
     * Merges two vector tokens together into one. Feature collections inside
     * vectors are weaved together. If one vector token is null, the other will
     * simply be returned.
     *
     * TODO: This probably belongs in the VectorUtilities class
     *
     * @param tokenA
     *            The first vector token
     * @param tokenB
     *            The second vector token
     * @return VectorToken as a merge between tokenA and tokenB
     * @throws Exception
     *             Raised if both tokens are null
     */
    public static VectorToken mergeVectors(VectorToken tokenA, VectorToken tokenB) throws Exception {
        if (tokenA == null && tokenB == null) {
            throw new Exception("Both vector tokens cannot be null.");
        }

        if (tokenA == null) {
            return tokenB;
        }

        if (tokenB == null) {
            return tokenA;
        }

        DefaultFeatureCollection features = new DefaultFeatureCollection();

        features.addAll(tokenA.getVectors());
        features.addAll(tokenB.getVectors());

        return new VectorToken(features);
    }

    /** The host URL of the REST API - all requests are made to this URL */
    public static final String DEFAULT_HOST = "https://firemap.sdsc.edu:5443";

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

    /**
     * Station selection types
     */
    public enum Selection {
        CLOSEST_TO, BOUNDING_BOX, WITHIN_RADIUS,
    }

    /**
     * Configure settings for sending REST API requests.
     */
    public static class Settings {
        // Properties

        // The host URL of the REST API - all requests are made to this URL
        public String host = DEFAULT_HOST;

        // The station selection type
        private Selection _selection = Selection.CLOSEST_TO;

        // Search coordinates
        private double _minLat = 0.0;
        private double _minLon = 0.0;
        private double _maxLat = 0.0;
        private double _maxLon = 0.0;
        private double _radius = 0.0;

        // Search timestamps
        private Date _from;
        private Date _to;

        // Observables to request
        private Set<String> _observables;

        // Public methods

        /**
         * Constructor
         */
        public Settings() {
            _observables = new HashSet<>();
        }

        /**
         * The selection type (inferred from the location settings).
         *
         * @return Selection enum
         */
        public Selection getSelectionType() {
            return _selection;
        }

        /**
         * Sets the location to a single coordinate. This creates a "closest to"
         * selection search.
         *
         * @param lat
         *            Latitude
         * @param lon
         *            Longitude
         */
        public void setLocation(double lat, double lon) {
            _selection = Selection.CLOSEST_TO;

            _minLat = lat;
            _minLon = lon;
        }

        /**
         * Sets the location to within a radius around a single coordinate. This
         * creates a "within radius" selection search.
         *
         * @param lat
         *            Latitude
         * @param lon
         *            Longitude
         * @param radius
         *            Radius (in meters)
         */
        public void setLocation(double lat, double lon, double radius) {
            _selection = Selection.WITHIN_RADIUS;

            _minLat = lat;
            _minLon = lon;
            _radius = radius;
        }

        /**
         * Sets the location to within a rectangle. This creates a "bounding
         * box" selection search.
         *
         * @param minLat
         *            Minimum latitude
         * @param minLon
         *            Minimum longitude
         * @param maxLat
         *            Maximum latitude
         * @param maxLon
         *            Maximum longitude
         */
        public void setLocation(double minLat, double minLon, double maxLat, double maxLon) {
            _selection = Selection.BOUNDING_BOX;

            _minLat = minLat;
            _minLon = minLon;
            _maxLat = maxLat;
            _maxLon = maxLon;
        }

        /**
         * Sets the date range for data search. If the "to" date exceeds the
         * current date, a forecast URI will be possible to generate (see
         * below). If both "from" and "to" dates excee the current date, a data
         * URI will not be possible to generate.
         *
         * @param from
         *            A date object to search from
         * @param to
         *            A date object to search to - must be after the "from" date
         * @throws Exception
         *             Raised if "to" date is at or before the "from" date
         */
        public void setDate(Date from, Date to) throws Exception {
            if (!from.before(to)) {
                throw new Exception("From date must be before the to date.");
            }

            _from = from;
            _to = to;
        }

        /**
         * Sets the date around a central time.
         *
         * @param at
         *            A date object to search around
         * @param buffer
         *            A buffer to pad the date with (in milliseconds)
         * @throws Exception
         *             An exception that should never be raised when using this
         *             particular method
         */
        public void setDate(Date at, int buffer) throws Exception {
            Date from = new Date(at.getTime() - buffer);
            Date to = new Date(at.getTime() + buffer);

            setDate(from, to);
        }

        /**
         * Sets the date around a central time. Uses a default buffer of +/- 2
         * hours.
         *
         * @param at
         *            A date object to search around
         * @throws Exception
         *             An exception that should never be raised when using this
         *             particular method
         */
        public void setDate(Date at) throws Exception {
            // 2 hour buffer
            setDate(at, 2 * 60 * 60 * 1000);
        }

        /**
         * Removes the date range filter. This will result in the REST API
         * returning the latest readings.
         */
        public void removeDate() {
            _from = null;
            _to = null;
        }

        /**
         * Adds an observable to be requested from the API.
         *
         * @param observable
         *            An observable as a string - refer to the Pylaski
         *            documentation (link above)
         */
        public void addObservable(String observable) {
            _observables.add(observable);
        }

        /**
         * Removes a previously added observable.
         *
         * @param observable
         *            An observable as a string
         */
        public void removeObservable(String observable) {
            _observables.remove(observable);
        }

        /**
         * Sets the list of observables.
         *
         * @param observables
         *            A list of observables - refer to the Pylaski documentation
         *            (link above)
         */
        public void setObservables(String[] observables) {
            _observables.clear();

            for (String observable : observables) {
                _observables.add(observable);
            }
        }

        /**
         * Generates the REST URI for retrieving past and present observable
         * data.
         *
         * @return A request URI
         * @throws URISyntaxException
         *             If the URI is invalid
         */
        public URI getDataURI() throws URISyntaxException {
            Date now = new Date();
            StringBuilder p = new StringBuilder(_getBaseParams());

            if (_from == null && _to == null) {
                return new URI(host + "/stations/data/latest?" + p.toString());
            }

            if (_from == null || _from.before(now)) {
                DateFormat df = new SimpleDateFormat(DATE_FORMAT);

                if (_from != null) {
                    p.append("from=").append(df.format(_from)).append("&");
                }

                if (_to != null) {
                    // Cap the "to" date at the latest date
                    Date to = _to.after(now) ? now : _to;
                    p.append("to=").append(df.format(to)).append("&");
                }

                return new URI(host + "/stations/data?" + p.toString());
            }

            return null;
        }

        /**
         * Generates the REST URI for retrieving future/forecast observable
         * data.
         *
         * @param hrrrx
         *            Whether to use the HRRRx forecast data
         * @return A request URI
         * @throws URISyntaxException
         *             If the URI is invalid
         */
        public URI getForecastURI(boolean hrrrx) throws URISyntaxException {
            Date now = new Date();
            StringBuilder p = new StringBuilder(_getBaseParams());

            p.append("hrrrx=").append(hrrrx ? "true" : "false").append("&");

            // Dates don't seem to do anything using the REST service, but put
            // them in for good measure
            if (_to != null && _to.after(now)) {
                DateFormat df = new SimpleDateFormat(DATE_FORMAT);

                if (_from != null) {
                    // Cap the "from" date at the latest date
                    Date from = _from.before(now) ? now : _from;
                    p.append("from=").append(df.format(from)).append("&");
                }

                p.append("to=").append(df.format(_to)).append("&");

                return new URI(host + "/forecast?" + p.toString());
            }

            return null;
        }

        /**
         * Generates the REST URI for retrieving future/forecast observable
         * data. Defaults the HRRRx setting to false.
         *
         * @return A request URI
         * @throws URISyntaxException
         *             If the URI is invalid
         */
        public URI getForecastURI() throws URISyntaxException {
            return getForecastURI(false);
        }

        // Private methods

        /**
         * Generates shared URI parameters for past/present and forecast URI's
         *
         * @return A string of URI parameters
         */
        private String _getBaseParams() {
            StringBuilder p = new StringBuilder();

            p.append("selection=").append(getSelectionString(_selection)).append("&");

            if (_selection == Selection.BOUNDING_BOX) {
                p.append("minLat=").append(_minLat).append("&");
                p.append("minLon=").append(_minLon).append("&");
                p.append("maxLat=").append(_maxLat).append("&");
                p.append("maxLon=").append(_maxLon).append("&");
            } else {
                p.append("lat=").append(_minLat).append("&");
                p.append("lon=").append(_minLon).append("&");
            }

            if (_selection == Selection.WITHIN_RADIUS) {
                p.append("radius=").append(_radius).append("&");
            }

            for (String observable : _observables) {
                p.append("observable=").append(observable).append("&");
            }

            return p.toString();
        }
    }
}