package de.intevation.flys.artifacts.states.minfo;

import java.text.DateFormat;
import java.util.ArrayList;
import java.util.List;

import org.apache.log4j.Logger;

import de.intevation.artifactdatabase.state.Facet;
import de.intevation.artifacts.CallContext;
import de.intevation.artifacts.CallMeta;
import de.intevation.flys.artifacts.FLYSArtifact;
import de.intevation.flys.artifacts.access.BedDifferencesAccess;
import de.intevation.flys.artifacts.model.CalculationResult;
import de.intevation.flys.artifacts.model.FacetTypes;
import de.intevation.flys.artifacts.model.minfo.BedDiffCalculation;
import de.intevation.flys.artifacts.model.minfo.BedDiffEpochFacet;
import de.intevation.flys.artifacts.model.minfo.BedDiffEpochResult;
import de.intevation.flys.artifacts.model.minfo.BedDiffYearFacet;
import de.intevation.flys.artifacts.model.minfo.BedDiffYearResult;
import de.intevation.flys.artifacts.model.minfo.BedDifferencesResult;
import de.intevation.flys.artifacts.resources.Resources;
import de.intevation.flys.artifacts.states.DefaultState;
import de.intevation.flys.utils.Formatter;

/**
 * @author <a href="mailto:raimund.renkert@intevation.de">Raimund Renkert</a>
 */
public class DifferencesState
extends DefaultState
implements FacetTypes
{
    /** The logger used in this class. */
    private static Logger logger = Logger.getLogger(DifferencesState.class);
    public static final String I18N_DIFF_YEAR = "beddifference.year";
    public static final String I18N_DIFF_EPOCH = "beddifference.epoch";

    public static final String I18N_FACET_BED_DIFF_YEAR = "facet.bedheight.diff.year";
    public static final String I18N_FACET_BED_DIFF_ABSOLUTE = "facet.bedheight.diff.absolute";
    public static final String I18N_FACET_BED_DIFF_MORPH = "facet.bedheight.diff.morph";
    public static final String I18N_FACET_BED_DIFF_EPOCH = "facet.bedheight.diff.epoch";
    public static final String I18N_FACET_BED_DIFF_HEIGHT1 = "facet.bedheight.diff.height1";
    public static final String I18N_FACET_BED_DIFF_HEIGHT2 = "facet.bedheight.diff.height2";

    public DifferencesState() {
    }

    @Override
    public Object computeAdvance(FLYSArtifact artifact, String hash,
        CallContext context, List<Facet> facets, Object old) {
        logger.debug("BedQualityState.computeAdvance");

        List<Facet> newFacets = new ArrayList<Facet>();

        BedDifferencesAccess access =
            new BedDifferencesAccess(artifact, context);

        CalculationResult res = old instanceof CalculationResult ? (CalculationResult) old
            : new BedDiffCalculation().calculate(access);

        if (facets == null || res == null) {
            return res;
        }

        BedDifferencesResult[] results = (BedDifferencesResult[]) res.getData();

        if (results == null || results.length == 0) {
            logger.warn("Calculation computed no results!");
            return res;
        }

        generateFacets(context, newFacets, results, getID(), hash);
        logger.debug("Created " + newFacets.size() + " new Facets.");

        facets.addAll(newFacets);

        return res;
    }

    protected void generateFacets(CallContext context, List<Facet> newFacets,
        BedDifferencesResult[] results, String stateId, String hash) {
        logger.debug("BedQualityState.generateFacets");

        CallMeta meta = context.getMeta();

        for (int idx = 0; idx < results.length; idx++) {
            if (results[idx] instanceof BedDiffYearResult) {
                newFacets.add(new BedDiffYearFacet(
                    idx,
                    BED_DIFFERENCE_YEAR,
                    createBedDiffYearDescription(
                        meta,
                        (BedDiffYearResult)results[idx]),
                    ComputeType.ADVANCE,
                    stateId,
                    hash));
                newFacets.add(new BedDiffYearFacet(
                    idx,
                    BED_DIFFERENCE_MORPH_WIDTH,
                    createBedDiffMorphDescription(
                        meta,
                        (BedDiffYearResult)results[idx]),
                    ComputeType.ADVANCE,
                    stateId,
                    hash));
                newFacets.add(new BedDiffYearFacet(
                    idx,
                    BED_DIFFERENCE_YEAR_HEIGHT1,
                    createBedDiffHeightDescription(
                        meta,
                        (BedDiffYearResult)results[idx],
                        0),
                    ComputeType.ADVANCE,
                    stateId,
                    hash));
                 newFacets.add(new BedDiffYearFacet(
                    idx,
                    BED_DIFFERENCE_YEAR_HEIGHT2,
                    createBedDiffHeightDescription(
                        meta,
                        (BedDiffYearResult)results[idx],
                        1),
                    ComputeType.ADVANCE,
                    stateId,
                    hash));
                newFacets.add(new BedDiffYearFacet(
                    idx,
                    BED_DIFFERENCE_HEIGHT_YEAR,
                    createBedDiffAbsoluteDescription(
                        meta,
                        (BedDiffYearResult)results[idx]),
                    ComputeType.ADVANCE,
                    stateId,
                    hash));
            }
            if (results[idx] instanceof BedDiffEpochResult) {
                newFacets.add(new BedDiffEpochFacet(
                    idx,
                    BED_DIFFERENCE_EPOCH,
                    createBedDiffEpochDescription(
                        meta,
                        (BedDiffEpochResult)results[idx]),
                    ComputeType.ADVANCE,
                    stateId,
                    hash));
                newFacets.add(new BedDiffEpochFacet(
                    idx,
                    BED_DIFFERENCE_EPOCH_HEIGHT1,
                    createBedDiffHeightEpochDescription(
                        meta,
                        (BedDiffEpochResult)results[idx],
                        0),
                    ComputeType.ADVANCE,
                    stateId,
                    hash));
                newFacets.add(new BedDiffEpochFacet(
                    idx,
                    BED_DIFFERENCE_EPOCH_HEIGHT2,
                    createBedDiffHeightEpochDescription(
                        meta,
                        (BedDiffEpochResult)results[idx],
                        1),
                    ComputeType.ADVANCE,
                    stateId,
                    hash));

            }
        }
    }

    private String createBedDiffHeightDescription(
        CallMeta meta,
        BedDiffYearResult result,
        int ndx
    ) {
        String range = result.getStart() + " - " + result.getEnd();

        if (ndx == 0) {
            return Resources.getMsg(meta, I18N_FACET_BED_DIFF_HEIGHT1,
                I18N_FACET_BED_DIFF_HEIGHT1, new Object[] { range });
        }
        else {
            return Resources.getMsg(meta, I18N_FACET_BED_DIFF_HEIGHT2,
                I18N_FACET_BED_DIFF_HEIGHT2, new Object[] {range});
        }
    }

    private String createBedDiffHeightEpochDescription(
        CallMeta meta,
        BedDiffEpochResult result,
        int ndx
    ) {
        DateFormat df = Formatter.getDateFormatter(meta, "yyyy");
        String range =
            df.format(result.getStart())
            + " - " +
            df.format(result.getEnd());

        if (ndx == 0) {
            return Resources.getMsg(meta, I18N_FACET_BED_DIFF_HEIGHT1,
                I18N_FACET_BED_DIFF_HEIGHT1, new Object[] { range });
        }
        else {
            return Resources.getMsg(meta, I18N_FACET_BED_DIFF_HEIGHT2,
                I18N_FACET_BED_DIFF_HEIGHT2, new Object[] {range});
        }
    }

    protected String createBedDiffYearDescription(
        CallMeta meta,
        BedDiffYearResult result) {
        String range = result.getStart() + " - " + result.getEnd();

        return Resources.getMsg(meta, I18N_FACET_BED_DIFF_YEAR,
            I18N_FACET_BED_DIFF_YEAR, new Object[] { range });
    }

    protected String createBedDiffMorphDescription(
        CallMeta meta,
        BedDiffYearResult result) {
        String range = result.getStart() + " - " + result.getEnd();

        return Resources.getMsg(meta, I18N_FACET_BED_DIFF_MORPH,
            I18N_FACET_BED_DIFF_MORPH, new Object[] { range });
    }

    protected String createBedDiffAbsoluteDescription(
        CallMeta meta,
        BedDiffYearResult result) {
        String range = result.getStart() + " - " + result.getEnd();

        return Resources.getMsg(meta, I18N_FACET_BED_DIFF_ABSOLUTE,
            I18N_FACET_BED_DIFF_ABSOLUTE, new Object[] { range });
    }

    protected String createBedDiffEpochDescription(
        CallMeta meta,
        BedDiffEpochResult result) {
        DateFormat df = Formatter.getDateFormatter(meta, "yyyy");
        String range =
            df.format(result.getStart())
            + " - " +
            df.format(result.getEnd());

        return Resources.getMsg(meta, I18N_FACET_BED_DIFF_EPOCH,
            I18N_FACET_BED_DIFF_EPOCH, new Object[] { range });
    }
}