package de.intevation.flys.artifacts;

import java.util.ArrayList;
import java.util.List;

import org.apache.log4j.Logger;

import org.w3c.dom.Document;

import de.intevation.artifactdatabase.data.DefaultStateData;
import de.intevation.artifactdatabase.data.StateData;
import de.intevation.artifactdatabase.state.Facet;
import de.intevation.artifactdatabase.state.DefaultOutput;
import de.intevation.artifactdatabase.state.State;

import de.intevation.artifacts.Artifact;
import de.intevation.artifacts.ArtifactFactory;
import de.intevation.artifacts.CallMeta;

import de.intevation.flys.model.Gauge;
import de.intevation.flys.model.MainValue;
import de.intevation.flys.model.River;

import de.intevation.flys.artifacts.model.Calculation;
import de.intevation.flys.artifacts.model.MainValuesQFacet;
import de.intevation.flys.artifacts.model.MainValuesWFacet;
import de.intevation.flys.artifacts.model.NamedDouble;
import de.intevation.flys.artifacts.model.WstValueTable;
import de.intevation.flys.artifacts.model.WstValueTableFactory;

import de.intevation.flys.artifacts.states.StaticState;
import de.intevation.flys.artifacts.resources.Resources;

import de.intevation.flys.utils.FLYSUtils;


/**
 * Artifact to access names of Points Of Interest along a segment of a river.
 * This artifact neglects (Static)FLYSArtifacts capabilities of interaction
 * with the StateEngine by overriding the getState*-methods.
 */
public class MainValuesArtifact
extends      StaticFLYSArtifact
{
    /** The logger for this class. */
    private static Logger logger = Logger.getLogger(MainValuesArtifact.class);

    /** The name of the artifact. */
    public static final String ARTIFACT_NAME = "mainvalue";

    /** One and only state to be in. */
    protected transient State state = null;


    /**
     * Trivial Constructor.
     */
    public MainValuesArtifact() {
        logger.debug("MainValuesArtifact.MainValuesartifact()");
    }


    /**
     * Gets called from factory, to set things up.
     */
    @Override
    public void setup(
        String          identifier,
        ArtifactFactory factory,
        Object          context,
        CallMeta        callMeta,
        Document        data)
    {
        logger.debug("MainValuesArtifact.setup");
        state = new StaticState("state.mainvalue.static", "state.mainvalue.static");
        List<Facet> fs = new ArrayList<Facet>();
        Facet qfacet = new MainValuesQFacet(Resources.getMsg(callMeta,
                   "facet.discharge_curves.mainvalues.q",
                   "facet.discharge_curves.mainvalues.q"));
        Facet wfacet = new MainValuesWFacet(Resources.getMsg(callMeta,
                   "facet.discharge_curves.mainvalues.w",
                   "facet.discharge_curves.mainvalues.w"));
        fs.add(qfacet);
        fs.add(wfacet);
        facets.put(state.getID(), fs);
        spawnState();
        super.setup(identifier, factory, context, callMeta, data);
    }

    protected State spawnState() {
        state = new StaticState("state.mainvalue.static", "state.mainvalue.static");
        List<Facet> fs = (List<Facet>) facets.get("state.mainvalue.static");
        DefaultOutput mainValuesOutput2 = new DefaultOutput(
                    "computed_discharge_curve",
                    "output.computed_discharge_curve", "image/png",
                    fs,
                    "chart");

        state.getOutputs().add(mainValuesOutput2);
        return state;
    }


    @Override
    protected void initialize(Artifact artifact, Object context, CallMeta meta) {
        logger.debug("MainValuesArtifact.initialize");
        WINFOArtifact winfo = (WINFOArtifact) artifact;
        double location = FLYSUtils.getLocations(winfo)[0];
        addData("location", new DefaultStateData("location", null, null,
                    String.valueOf(location)));
        addData("river", winfo.getData("river"));
    }


    /**
     * Get a list containing the one and only State.
     * @param  context ignored.
     * @return list with one and only state.
     */
    @Override
    protected List<State> getStates(Object context) {
        ArrayList<State> states = new ArrayList<State>();
        states.add(getState());
        return states;
    }


    /**
     * Get the "current" state.
     * @param cc ignored.
     * @return the "current" state.
     */
    @Override
    protected State getCurrentState(Object cc) {
        return getState();
    }


    /**
     * Get the only possible state.
     * @return the state.
     */
    protected State getState() {
        return getState(null, null);
    }


    /**
     * Get the state.
     * @param context ignored.
     * @param stateID ignored.
     * @return the state.
     */
    @Override
    protected State getState(Object context, String stateID) {
        if (state != null)
            return state;
        else
            return spawnState();
    }


    /**
     * Access the Gauge that the mainvalues are taken from.
     * @return Gauge that main values are taken from or null in case of
     *         invalid parameterization.
     */
    protected Gauge getGauge() {
        River river = FLYSUtils.getRiver(this);

        if (river == null) {
            return null;
        }

        double location = Double.parseDouble(
                getDataAsString("location"));

        return river.determineGaugeByPosition(location);
    }


    /**
     * Get current location.
     * @return the location.
     */
    public double getLocation() {
        double location = Double.parseDouble(
                (String)getData("location").getValue());
        return location;
    }


    /**
     * Get a list of "Q" main values.
     * @return list of Q main values.
     */
    public List<NamedDouble> getMainValuesQ() {
        List<NamedDouble> filteredList = new ArrayList<NamedDouble>();
        Gauge gauge = getGauge();
        WstValueTable interpolator = WstValueTableFactory.getTable(FLYSUtils.getRiver(this));
        Calculation c = new Calculation();
        double w_out[] = {0.0f};
        double q_out[] = {0.0f};
        double kms[] = {getLocation()};
        double gaugeStation = gauge.getStation().doubleValue();
        if (gauge != null) {
            List<MainValue> orig = gauge.getMainValues();
            for (MainValue mv : orig) {
                if (mv.getMainValue().getType().getName().equals("Q")) {
                    interpolator.interpolate(mv.getValue().doubleValue(),
                            gaugeStation, kms, w_out, q_out, c);
                    filteredList.add(new NamedDouble(
                                mv.getMainValue().getName(),
                                q_out[0]
                                ));
                }
            }
        }
        return filteredList;
    }


    /**
     * Get a list of "W" main values.
     * @return list of W main values.
     */
    public List<NamedDouble> getMainValuesW() {
        List<NamedDouble> filteredList = new ArrayList<NamedDouble>();
        Gauge gauge = getGauge();
        WstValueTable interpolator = WstValueTableFactory.getTable(FLYSUtils.getRiver(this));
        Calculation c = new Calculation();
        double gaugeStation = gauge.getStation().doubleValue();
        double w_out[] = {0.0f};
        double q_out[] = {0.0f};
        double kms[] = {getLocation()};
        if (gauge != null) {
            List<MainValue> orig = gauge.getMainValues();
            for (MainValue mv : orig) {
                // We cannot interpolate the W values, so derive them
                // from given Q values.
                if (mv.getMainValue().getType().getName().equals("Q")) {
                    interpolator.interpolate(mv.getValue().doubleValue(),
                            gaugeStation, kms, w_out, q_out, c);
                    filteredList.add(new NamedDouble(
                                "W(" + mv.getMainValue().getName() +")",
                                w_out[0]
                                ));
                }
            }
        }
        return filteredList;
    }
}