/*
 * Copyright (c) 2015 The Regents of the University of California.
 * All rights reserved.
 *
 * '$Author: crawl $'
 * '$Date: 2015-12-16 21:30:37 +0000 (Wed, 16 Dec 2015) $' 
 * '$Revision: 34341 $'
 * 
 * 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.kml;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;

import de.micromata.opengis.kml.v_2_2_0.Kml;
import ptolemy.actor.TypedAtomicActor;
import ptolemy.actor.TypedIOPort;
import ptolemy.actor.parameters.PortParameter;
import ptolemy.data.DateToken;
import ptolemy.data.StringToken;
import ptolemy.data.Token;
import ptolemy.data.type.BaseType;
import ptolemy.kernel.CompositeEntity;
import ptolemy.kernel.util.IllegalActionException;
import ptolemy.kernel.util.NameDuplicationException;

/** Add a timestamp to a KML file.
 * 
 *  @author Daniel Crawl
 *  @version $Id: WriteTimestampToKML.java 34341 2015-12-16 21:30:37Z crawl $
 */
public class WriteTimestampToKML extends TypedAtomicActor {

    public WriteTimestampToKML(CompositeEntity container, String name)
            throws IllegalActionException, NameDuplicationException {
        super(container, name);

        input = new TypedIOPort(this, "input", true, false);
        input.setTypeEquals(BaseType.STRING);
 
        filename = new PortParameter(this, "filename");
        filename.setTypeEquals(BaseType.STRING);
        filename.getPort().setTypeEquals(BaseType.STRING);
        
        date = new TypedIOPort(this, "date", true, false);
        date.setTypeEquals(BaseType.DATE);
        
        output = new TypedIOPort(this, "output", false, true);
        output.setTypeEquals(BaseType.STRING);
    }
    
    @Override
    public void fire() throws IllegalActionException {
        
        super.fire();
        
        String inKMLNameStr = ((StringToken)input.get(0)).stringValue();
        if(inKMLNameStr.trim().isEmpty()) {
            throw new IllegalActionException(this, "Input KML is empty.");
        }
        
        File inKML = new File(inKMLNameStr);
        if(!inKML.exists()) {
            throw new IllegalActionException(this, "Input KML does not exist: " + inKML);
        }
        
        filename.update();
        File outKML = null;
        Token token = filename.getToken();
        if(token != null) {
            String outKMLNameStr = ((StringToken)token).stringValue();
            if(outKMLNameStr.trim().isEmpty()) {
                throw new IllegalActionException(this, "Output KML name is empty.");
            }
            outKML = new File(outKMLNameStr);
        } else {
            outKML = inKML;
        }
        
        Date dateVal = new Date(((DateToken)date.get(0)).getValue());
        String formattedDateStr;
        synchronized(KML_TIMESTAMP_FORMAT) {
            formattedDateStr = KML_TIMESTAMP_FORMAT.format(dateVal);
        }
        
        Kml[] kmls = null;
        if(inKMLNameStr.toLowerCase().endsWith(".kmz")) {
            try {
                kmls = Kml.unmarshalFromKmz(inKML);
            } catch (IOException e) {
                throw new IllegalActionException(this, e, "Error unmarshalling KMZ.");
            }
            // TODO
            throw new IllegalActionException(this, "Reading from KMZ not supported.");
        } else {
            kmls = new Kml[1];
            kmls[0] = Kml.unmarshal(inKML);
        }
        
        for(Kml kml: kmls) {
            //_addTimestampToFeature(kml.getFeature(), formattedDateStr);
            kml.getFeature().createAndSetTimeStamp().setWhen(formattedDateStr);
        }
        
        if(outKML.getName().toLowerCase().endsWith("kmz") || kmls.length > 1) {
            try {
                Kml[] otherKMLs = new Kml[kmls.length - 1];
                System.arraycopy(kmls, 1, otherKMLs, 0, otherKMLs.length);
                kmls[0].marshalAsKmz(outKML.getAbsolutePath(), otherKMLs);
            } catch (IOException e) {
                throw new IllegalActionException(this, e, "Error writing KMZ to " + outKML);
            }
        } else {
            try {
                kmls[0].marshal(outKML);
            } catch (FileNotFoundException e) {
                throw new IllegalActionException(this, e, "Error writing to " + outKML);
            }            
        }
        
        output.broadcast(new StringToken(outKML.getAbsolutePath()));
    }

    /** The KML to read. */
    public TypedIOPort input;
    
    /** The name of the KML file to write. If not specified, then the input KML
     *  will be overwritten. If the input file is a KMZ containing more than
     *  one KML, then the output is written as a KMZ. 
     */
    public PortParameter filename;
    
    /** The timestamp to set. */
    public TypedIOPort date;
    
    /** The name of the updated KML file. */
    public TypedIOPort output;

    /** Format for KML timestamps. */
    public final static SimpleDateFormat KML_TIMESTAMP_FORMAT = new SimpleDateFormat("yyyy-MM-dd'T'HH:mmXXX");
    
    /** Set the timestamp to a Feature and all contained Features. */
    /*
    private void _addTimestampToFeature(Feature feature, String formattedDateStr) {
        if(feature instanceof Placemark) {
            ((Placemark)feature).createAndSetTimeStamp().setWhen(formattedDateStr);
        } else {
            List<Feature> subFeatures = null;
            if(feature instanceof Document) {
                subFeatures = ((Document)feature).getFeature();
            } else if(feature instanceof Folder) {
                subFeatures = ((Folder)feature).getFeature();
            }
            
            if(subFeatures != null) {
                for(Feature subFeature : subFeatures) {
                    _addTimestampToFeature(subFeature, formattedDateStr);
                }
            }
        }
    }
    */
    
}