package de.intevation.flys.exports;

import de.intevation.artifactdatabase.state.ArtifactAndFacet;
import de.intevation.flys.artifacts.FLYSArtifact;
import de.intevation.flys.artifacts.model.FacetTypes;
import de.intevation.flys.artifacts.model.HistoricalWQTimerange;
import de.intevation.flys.artifacts.model.Timerange;
import de.intevation.flys.artifacts.model.WQTimerange;
import de.intevation.flys.jfree.StyledTimeSeries;
import de.intevation.flys.utils.FLYSUtils;

import java.util.Date;

import org.apache.log4j.Logger;
import org.jfree.data.general.SeriesException;
import org.jfree.data.time.Day;
import org.jfree.data.time.RegularTimePeriod;
import org.jfree.data.time.TimeSeries;
import org.jfree.data.time.TimeSeriesCollection;
import org.w3c.dom.Document;


/**
 * @author <a href="mailto:ingo.weinzierl@intevation.de">Ingo Weinzierl</a>
 */
public class HistoricalDischargeCurveGenerator
extends      TimeseriesChartGenerator
implements   FacetTypes
{
    private static Logger logger =
        Logger.getLogger(HistoricalDischargeCurveGenerator.class);


    public static final String I18N_CHART_TITLE =
        "chart.historical.discharge.title";

    public static final String I18N_CHART_SUBTITLE =
        "chart.historical.discharge.subtitle";

    public static final String I18N_XAXIS_LABEL =
        "chart.historical.discharge.xaxis.label";

    public static final String I18N_YAXIS_LABEL =
        "chart.historical.discharge.yaxis.label";

    public static final String I18N_YAXIS_SECOND_LABEL =
        "chart.historical.discharge.yaxis.second.label";


    public static enum YAXIS {
        Q(0);
        protected int idx;
        private YAXIS(int c) {
            idx = c;
        }
    }


    @Override
    protected YAxisWalker getYAxisWalker() {
        return new YAxisWalker() {
            @Override
            public int length() {
                return YAXIS.values().length;
            }

            @Override
            public String getId(int idx) {
                YAXIS[] yaxes = YAXIS.values();
                return yaxes[idx].toString();
            }
        };
    }


    @Override
    protected String getDefaultChartTitle() {
        return msg(I18N_CHART_TITLE, I18N_CHART_TITLE);
    }


    @Override
    protected String getDefaultChartSubtitle() {
        String[] args = new String[] {
            FLYSUtils.getReferenceGaugeName((FLYSArtifact) master)
        };

        return msg(I18N_CHART_SUBTITLE, "", args);
    }


    @Override
    protected String getDefaultXAxisLabel() {
        return msg(I18N_XAXIS_LABEL, I18N_XAXIS_LABEL);
    }

    @Override
    protected String getDefaultYAxisLabel(int pos) {
        if (pos == 0) {
            return msg(I18N_YAXIS_LABEL, I18N_YAXIS_LABEL);
        }
        else if (pos == 1) {
            return msg(I18N_YAXIS_SECOND_LABEL, I18N_YAXIS_SECOND_LABEL);
        }
        else {
            return "NO TITLE FOR Y AXIS: " + pos;
        }
    }


    @Override
    public void doOut(
        ArtifactAndFacet artifactFacet,
        Document         theme,
        boolean          visible
    ) {
        String name = artifactFacet.getFacetName();
        logger.debug("HistoricalDischargeCurveGenerator.doOut: " + name);
        logger.debug("Theme description is: " + artifactFacet.getFacetDescription());


        if (name.equals(HISTORICAL_DISCHARGE_Q)) {
            doHistoricalDischargeOut(
                (FLYSArtifact) artifactFacet.getArtifact(),
                artifactFacet.getData(context),
                artifactFacet.getFacetDescription(),
                theme,
                visible);
        }
        else if (name.equals(HISTORICAL_DISCHARGE_Q_DIFF)) {
            doHistoricalDischargeDifferenceOut(
                (FLYSArtifact) artifactFacet.getArtifact(),
                artifactFacet.getData(context),
                artifactFacet.getFacetDescription(),
                theme,
                visible);
        }
        else if (FacetTypes.IS.MANUALPOINTS(name)) {
            doPoints (artifactFacet.getData(context),
                      artifactFacet,
                      theme, visible, YAXIS.Q.idx);
        }
        // TODO ADD THE CASE FOR DISPLAYING W VALUES
        else {
           logger.warn("doOut(): unknown facet name: " + name);
           return;
        }
    }


    protected void doHistoricalDischargeOut(
        FLYSArtifact artifact,
        Object       data,
        String       desc,
        Document     theme,
        boolean      visible)
    {
        logger.debug("doHistoricalDischargeOut(): description = " + desc);

        WQTimerange wqt = (WQTimerange) data;

        TimeSeriesCollection tsc = newTimeSeriesCollection(
            wqt.getTimeranges(),
            wqt.getQs(),
            theme,
            desc);

        addAxisDataset(tsc, 0, visible);
    }


    protected void doHistoricalDischargeDifferenceOut(
        FLYSArtifact artifact,
        Object       data,
        String       desc,
        Document     theme,
        boolean      visible
    ) {
        logger.debug("doHistoricalDischargeDifferenceOut: desc = " + desc);

        HistoricalWQTimerange wqt = (HistoricalWQTimerange) data;

        TimeSeriesCollection tsc = newTimeSeriesCollection(
            wqt.getTimeranges(),
            wqt.getDiffs(),
            theme,
            desc);

        addAxisDataset(tsc, 0, visible);
    }


    /**
     * Creates a new TimeSeriesCollection with a single TimeSeries. The
     * TimeSeries will consist of two RegularTimePeriods for each W/Q value
     * provided by <i>wqt</i>. This has the effect, that the line in the chart
     * looks like a "step chart".
     */
    protected TimeSeriesCollection newTimeSeriesCollection(
        Timerange[] timeranges,
        double[]    values,
        Document    theme,
        String      desc
    ) {
        logger.debug("Create new TimeSeriesCollection for: " + desc);

        TimeSeriesCollection tsc = new TimeSeriesCollection();
        TimeSeries        series = new StyledTimeSeries(desc, theme);

        for (int i = 0, n = timeranges.length; i < n; i++) {
            RegularTimePeriod[] rtp = newRegularTimePeriod(timeranges[i]);

            try {
                if (Double.isNaN(values[i])) {
                    logger.warn("Skip TimePeriod because value is NaN.");
                    continue;
                }

                series.add(rtp[0], values[i]);
                series.add(rtp[1], values[i]);

                if (logger.isDebugEnabled()) {
                    logger.debug("added Item to TimeSeries:");
                    logger.debug("   TimePeriod: " + rtp[0] + " - " + rtp[1]);
                    logger.debug("   Value:      " + values[i]);
                }
            }
            catch (SeriesException se) {
                logger.warn("Error while adding TimePeriod: " + se);
            }
        }

        tsc.addSeries(series);

        return tsc;
    }


    /**
     * Creates an array that consists of two <i>Minute</i> periods [start, end].
     *
     * @param timerange Supports start and end time.
     *
     * @return an array with two <i>Minute</i> periods [start, end].
     */
    protected RegularTimePeriod[] newRegularTimePeriod(Timerange timerange) {
        Date start = new Date(timerange.getStart());
        Date end   = new Date(timerange.getEnd() - 1000 * 60 * 60 * 24);

        return new RegularTimePeriod[] {
            new Day(start),
            new Day(end)
        };
    }
}
// vim:set ts=4 sw=4 si et sta sts=4 fenc=utf-8 :