package uk.ac.cam.ch.ami.amievents.log;



import org.apache.commons.io.IOUtils;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.Text;

import uk.ac.cam.ch.ami.ColorList;

import uk.ac.cam.ch.ami.amievents.AmiEventType;

import uk.ac.cam.ch.ami.amievents.events.AmiEvent;

import uk.ac.cam.ch.ami.amievents.events.CommentAmiEvent;



import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.transform.OutputKeys;

import javax.xml.transform.Transformer;

import javax.xml.transform.TransformerFactory;

import javax.xml.transform.dom.DOMSource;

import javax.xml.transform.stream.StreamResult;

import java.awt.*;

import java.io.*;

import java.sql.Timestamp;

import java.text.SimpleDateFormat;

import java.util.HashMap;

import java.util.Map;

import java.util.TreeMap;



/**

 * Generate an XML file which can be read by Timeline (http://thetimelineproj.sourceforge.net)

 *

 * Created by IntelliJ IDEA.

 * User: alt36

 * Date: Oct 12, 2010

 * Time: 1:54:10 PM

 */

public class TimelineXMLWriter {



    public void WriteXML(File saveDir, AmiEventLog eventlog) {

        TreeMap<Timestamp, AmiEvent> allEvents = eventlog.getAllEventsLog();



        try{

            DocumentBuilderFactory dbfac = DocumentBuilderFactory.newInstance();

            DocumentBuilder docBuilder = dbfac.newDocumentBuilder();

            Document doc = docBuilder.newDocument();



            // Creating the XML tree



            // create the root element and add it to the document

            Element root = doc.createElement("timeline");

            doc.appendChild(root);



            // elements which are all children of the root element

            Element ver = doc.createElement("version");

            root.appendChild(ver);

            Text vertext = doc.createTextNode("0.10.2");

            ver.appendChild(vertext);



            Element categories = doc.createElement("categories");

            Element events = doc.createElement("events");

            Element view = doc.createElement("view");

            root.appendChild(categories);

            root.appendChild(events);

            root.appendChild(view);



            Map<AmiEventType, Color> colormap = new HashMap<AmiEventType, Color>();

            ColorList c = new ColorList();

            colormap.put(AmiEventType.PHYSICAL_EVENT, c.getPhysicalEventColor());

            colormap.put(AmiEventType.COMMENT_EVENT, c.getCommentEventColor());

            colormap.put(AmiEventType.USER_EVENT, c.getUserEventColor());

            colormap.put(AmiEventType.CHEMICAL_EVENT, c.getChemicalEventColor());

            colormap.put(AmiEventType.EQUIPMENT_EVENT, c.getEquipmentEventColor());

            colormap.put(AmiEventType.SENSOR_EVENT, c.getSensorEventColor());



            AmiEventType[] types=AmiEventType.values();



            // create list of categories



            for(AmiEventType t : types) {

                Element category = doc.createElement("category");

                categories.appendChild(category);

                Element name = doc.createElement("name");

                Element color = doc.createElement("color");

                category.appendChild(name);

                category.appendChild(color);

                Text text = doc.createTextNode(t.toString());

                name.appendChild(text);

                Color col = colormap.get(t);

                text = doc.createTextNode(col.getRed()+","+col.getGreen()+","+col.getBlue());

                color.appendChild(text);



            }



            // add all of the events

            for(AmiEvent e : allEvents.values()) {

                if(!e.isToBeDeleted()) {

                    Element event = doc.createElement("event");

                    events.appendChild(event);



                    Element start=doc.createElement("start");

                    Element end=doc.createElement("end");

                    Element text=doc.createElement("text");

                    Element category=doc.createElement("category");



                    event.appendChild(start);

                    event.appendChild(end);

                    event.appendChild(text);

                    event.appendChild(category);



                    Text content = doc.createTextNode(e.getTimelineStart());

                    start.appendChild(content);



                    content = doc.createTextNode(e.getTimelineEnd());

                    end.appendChild(content);



                    content = doc.createTextNode(e.getTimelineText());

                    text.appendChild(content);



                    content = doc.createTextNode(e.getAmiEventType().toString());

                    category.appendChild(content);



                    if(e.getAmiEventType() == AmiEventType.COMMENT_EVENT) {

                        Element description = doc.createElement("description");

                        event.appendChild(description);

                        CommentAmiEvent commentEvent = (CommentAmiEvent)e;

                        content = doc.createTextNode(commentEvent.getComment());

                        description.appendChild(content);

                    }





                }



            }



            // set the "displayed period" to cover the range of all the events,

            // with an (arbitrary) half hour buffer either side

            Element displayedPeriod = doc.createElement("displayed_period");

            view.appendChild(displayedPeriod);

            Element start = doc.createElement("start");

            Element end = doc.createElement("end");

            displayedPeriod.appendChild(start);

            displayedPeriod.appendChild(end);



            long halfHour = 30*60*1000; // milliseconds in half an hour

            // the allEvents TreeMap is sorted with most recent events first, hence the earliest event is the last in

            // the log

            Timestamp earliest = new Timestamp(allEvents.lastKey().getTime()-halfHour);

            Timestamp latest = new Timestamp(allEvents.firstKey().getTime()+halfHour);

            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");



            Text content = doc.createTextNode(sdf.format(earliest));

            start.appendChild(content);



            content = doc.createTextNode(sdf.format(latest));

            end.appendChild(content);



            // hidden categories

            Element hiddenCategories = doc.createElement("hidden_categories");

            view.appendChild(hiddenCategories);

            for(AmiEventType t : types)    {

                if(!eventlog.isEventTypeHidden(t)) {

                    Element name = doc.createElement("name");

                    hiddenCategories.appendChild(name);

                    content = doc.createTextNode(t.toString());

                    name.appendChild(content);

                }

            }

            /////////////////

            //Output the XML



            //set up a transformer

            TransformerFactory transfac = TransformerFactory.newInstance();

            Transformer trans = transfac.newTransformer();

            trans.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "no");

            trans.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4");

            trans.setOutputProperty(OutputKeys.INDENT, "yes");



            // create string from xml tree

            StringWriter sw = new StringWriter();

            StreamResult result = new StreamResult(sw);

            DOMSource source = new DOMSource(doc);

            trans.transform(source, result);

            String xmlString = sw.toString();



            // write XML to file

            BufferedWriter out=null;

            try{

                out = new BufferedWriter(new FileWriter(saveDir.getPath() + IOUtils.DIR_SEPARATOR + "log.timeline"));

                out.write(xmlString);



            } catch (IOException e) {

                e.printStackTrace();

            } finally {

                out.close();

            }



        } catch (Exception e) {

            e.printStackTrace();

        }

    }



}