--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/artifacts/src/main/java/org/dive4elements/river/artifacts/states/minfo/DifferencesState.java	Thu Apr 25 15:23:37 2013 +0200
@@ -0,0 +1,403 @@
+package org.dive4elements.river.artifacts.states.minfo;
+
+import java.text.DateFormat;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.log4j.Logger;
+
+import org.dive4elements.artifactdatabase.state.Facet;
+import org.dive4elements.artifactdatabase.state.FacetActivity;
+import org.dive4elements.artifacts.Artifact;
+import org.dive4elements.artifacts.CallContext;
+import org.dive4elements.artifacts.CallMeta;
+import org.dive4elements.river.artifacts.FLYSArtifact;
+import org.dive4elements.river.artifacts.access.BedDifferencesAccess;
+import org.dive4elements.river.artifacts.model.CalculationResult;
+import org.dive4elements.river.artifacts.model.FacetTypes;
+import org.dive4elements.river.artifacts.model.minfo.BedDiffCalculation;
+import org.dive4elements.river.artifacts.model.minfo.BedDiffEpochFacet;
+import org.dive4elements.river.artifacts.model.minfo.BedDiffEpochFilterFacet;
+import org.dive4elements.river.artifacts.model.minfo.BedDiffEpochResult;
+import org.dive4elements.river.artifacts.model.minfo.BedDiffYearFacet;
+import org.dive4elements.river.artifacts.model.minfo.BedDiffYearFilterFacet;
+import org.dive4elements.river.artifacts.model.minfo.BedDiffYearResult;
+import org.dive4elements.river.artifacts.model.minfo.BedDifferencesResult;
+import org.dive4elements.river.artifacts.resources.Resources;
+import org.dive4elements.river.artifacts.states.DefaultState;
+import org.dive4elements.river.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_YEAR_RAW = "facet.bedheight.diff.year.raw";
+    public static final String I18N_FACET_BED_DIFF_ABSOLUTE = "facet.bedheight.diff.absolute";
+    public static final String I18N_FACET_BED_DIFF_ABSOLUTE_RAW = "facet.bedheight.diff.absolute.raw";
+    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_EPOCH_RAW = "facet.bedheight.diff.epoch.raw";
+    public static final String I18N_FACET_BED_DIFF_HEIGHT1 = "facet.bedheight.diff.height1";
+    public static final String I18N_FACET_BED_DIFF_HEIGHT1_RAW = "facet.bedheight.diff.height1.raw";
+    public static final String I18N_FACET_BED_DIFF_HEIGHT2 = "facet.bedheight.diff.height2";
+    public static final String I18N_FACET_BED_DIFF_HEIGHT2_RAW = "facet.bedheight.diff.height2.raw";
+
+    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],
+                        true),
+                    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,
+                        true),
+                    ComputeType.ADVANCE,
+                    stateId,
+                    hash));
+                 newFacets.add(new BedDiffYearFacet(
+                    idx,
+                    BED_DIFFERENCE_YEAR_HEIGHT2,
+                    createBedDiffHeightDescription(
+                        meta,
+                        (BedDiffYearResult)results[idx],
+                        1,
+                        true),
+                    ComputeType.ADVANCE,
+                    stateId,
+                    hash));
+                newFacets.add(new BedDiffYearFacet(
+                    idx,
+                    BED_DIFFERENCE_HEIGHT_YEAR,
+                    createBedDiffAbsoluteDescription(
+                        meta,
+                        (BedDiffYearResult)results[idx],
+                        true),
+                    ComputeType.ADVANCE,
+                    stateId,
+                    hash));
+                newFacets.add(new BedDiffYearFilterFacet(
+                    idx,
+                    BED_DIFFERENCE_YEAR_FILTERED,
+                    createBedDiffYearDescription(
+                        meta,
+                        (BedDiffYearResult)results[idx],
+                        false),
+                    ComputeType.ADVANCE,
+                    stateId,
+                    hash));
+                newFacets.add(new BedDiffYearFilterFacet(
+                    idx,
+                    BED_DIFFERENCE_YEAR_HEIGHT1_FILTERED,
+                    createBedDiffHeightDescription(
+                        meta,
+                        (BedDiffYearResult)results[idx],
+                        0,
+                        false),
+                    ComputeType.ADVANCE,
+                    stateId,
+                    hash));
+                 newFacets.add(new BedDiffYearFilterFacet(
+                    idx,
+                    BED_DIFFERENCE_YEAR_HEIGHT2_FILTERED,
+                    createBedDiffHeightDescription(
+                        meta,
+                        (BedDiffYearResult)results[idx],
+                        1,
+                        false),
+                    ComputeType.ADVANCE,
+                    stateId,
+                    hash));
+                newFacets.add(new BedDiffYearFilterFacet(
+                    idx,
+                    BED_DIFFERENCE_HEIGHT_YEAR_FILTERED,
+                    createBedDiffAbsoluteDescription(
+                        meta,
+                        (BedDiffYearResult)results[idx],
+                        false),
+                    ComputeType.ADVANCE,
+                    stateId,
+                    hash));
+            }
+            if (results[idx] instanceof BedDiffEpochResult) {
+                newFacets.add(new BedDiffEpochFacet(
+                    idx,
+                    BED_DIFFERENCE_EPOCH,
+                    createBedDiffEpochDescription(
+                        meta,
+                        (BedDiffEpochResult)results[idx],
+                        true),
+                    ComputeType.ADVANCE,
+                    stateId,
+                    hash));
+                newFacets.add(new BedDiffEpochFacet(
+                    idx,
+                    BED_DIFFERENCE_EPOCH_HEIGHT1,
+                    createBedDiffHeightEpochDescription(
+                        meta,
+                        (BedDiffEpochResult)results[idx],
+                        0,
+                        true),
+                    ComputeType.ADVANCE,
+                    stateId,
+                    hash));
+                newFacets.add(new BedDiffEpochFacet(
+                    idx,
+                    BED_DIFFERENCE_EPOCH_HEIGHT2,
+                    createBedDiffHeightEpochDescription(
+                        meta,
+                        (BedDiffEpochResult)results[idx],
+                        1,
+                        true),
+                    ComputeType.ADVANCE,
+                    stateId,
+                    hash));
+                newFacets.add(new BedDiffEpochFilterFacet(
+                    idx,
+                    BED_DIFFERENCE_EPOCH_FILTERED,
+                    createBedDiffEpochDescription(
+                        meta,
+                        (BedDiffEpochResult)results[idx],
+                        false),
+                    ComputeType.ADVANCE,
+                    stateId,
+                    hash));
+                newFacets.add(new BedDiffEpochFilterFacet(
+                    idx,
+                    BED_DIFFERENCE_EPOCH_HEIGHT1_FILTERED,
+                    createBedDiffHeightEpochDescription(
+                        meta,
+                        (BedDiffEpochResult)results[idx],
+                        0,
+                        false),
+                    ComputeType.ADVANCE,
+                    stateId,
+                    hash));
+                newFacets.add(new BedDiffEpochFilterFacet(
+                    idx,
+                    BED_DIFFERENCE_EPOCH_HEIGHT2_FILTERED,
+                    createBedDiffHeightEpochDescription(
+                        meta,
+                        (BedDiffEpochResult)results[idx],
+                        1,
+                        false),
+                    ComputeType.ADVANCE,
+                    stateId,
+                    hash));
+            }
+        }
+    }
+
+    private String createBedDiffHeightDescription(
+        CallMeta meta,
+        BedDiffYearResult result,
+        int ndx,
+        boolean raw
+    ) {
+        String range = result.getStart() + " - " + result.getEnd();
+
+        String i18nHeight1 = I18N_FACET_BED_DIFF_HEIGHT1;
+        String i18nHeight2 = I18N_FACET_BED_DIFF_HEIGHT2;
+        if (raw) {
+            i18nHeight1 = I18N_FACET_BED_DIFF_HEIGHT1_RAW;
+            i18nHeight2 = I18N_FACET_BED_DIFF_HEIGHT2_RAW;
+        }
+        if (ndx == 0) {
+            return Resources.getMsg(meta, i18nHeight1,
+                i18nHeight2, new Object[] { range });
+        }
+        else {
+            return Resources.getMsg(meta, i18nHeight1,
+                i18nHeight2, new Object[] {range});
+        }
+    }
+
+    private String createBedDiffHeightEpochDescription(
+        CallMeta meta,
+        BedDiffEpochResult result,
+        int ndx,
+        boolean raw
+    ) {
+        DateFormat df = Formatter.getDateFormatter(meta, "yyyy");
+        String range =
+            df.format(result.getStart())
+            + " - " +
+            df.format(result.getEnd());
+
+        String i18nHeight1 = I18N_FACET_BED_DIFF_HEIGHT1;
+        String i18nHeight2 = I18N_FACET_BED_DIFF_HEIGHT2;
+        if (raw) {
+            i18nHeight1 = I18N_FACET_BED_DIFF_HEIGHT1_RAW;
+            i18nHeight2 = I18N_FACET_BED_DIFF_HEIGHT2_RAW;
+        }
+        if (ndx == 0) {
+            return Resources.getMsg(meta, i18nHeight1,
+                i18nHeight1, new Object[] { range });
+        }
+        else {
+            return Resources.getMsg(meta, i18nHeight2,
+                i18nHeight2, new Object[] {range});
+        }
+    }
+
+    protected String createBedDiffYearDescription(
+        CallMeta meta,
+        BedDiffYearResult result,
+        boolean raw
+    ) {
+        String range = result.getStart() + " - " + result.getEnd();
+
+        String i18n = I18N_FACET_BED_DIFF_YEAR;
+        if (raw) {
+            i18n = I18N_FACET_BED_DIFF_YEAR_RAW;
+        }
+        return Resources.getMsg(meta, i18n, i18n, 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,
+        boolean raw
+    ) {
+        String range = result.getStart() + " - " + result.getEnd();
+
+        String i18n = I18N_FACET_BED_DIFF_ABSOLUTE;
+        if (raw) {
+            i18n = I18N_FACET_BED_DIFF_ABSOLUTE_RAW;
+        }
+        return Resources.getMsg(meta, i18n, i18n, new Object[] { range });
+    }
+
+    protected String createBedDiffEpochDescription(
+        CallMeta meta,
+        BedDiffEpochResult result,
+        boolean raw) {
+        DateFormat df = Formatter.getDateFormatter(meta, "yyyy");
+        String range =
+            df.format(result.getStart())
+            + " - " +
+            df.format(result.getEnd());
+
+        String i18n = I18N_FACET_BED_DIFF_EPOCH;
+        if (raw) {
+            i18n = I18N_FACET_BED_DIFF_EPOCH_RAW;
+        }
+        return Resources.getMsg(meta, i18n, i18n, new Object[] { range });
+    }
+
+    static {
+        // Active/deactivate facets.
+        FacetActivity.Registry.getInstance().register(
+            "minfo",
+            new FacetActivity() {
+                @Override
+                public Boolean isInitialActive(
+                    Artifact artifact,
+                    Facet    facet,
+                    String   output
+                ) {
+                    String name = facet.getName();
+                    if (name.equals(BED_DIFFERENCE_EPOCH) ||
+                        name.equals(BED_DIFFERENCE_EPOCH_HEIGHT1) ||
+                        name.equals(BED_DIFFERENCE_EPOCH_HEIGHT2) ||
+                        name.equals(BED_DIFFERENCE_HEIGHT_YEAR) ||
+                        name.equals(BED_DIFFERENCE_YEAR) ||
+                        name.equals(BED_DIFFERENCE_YEAR_HEIGHT1) ||
+                        name.equals(BED_DIFFERENCE_YEAR_HEIGHT2)) {
+                        return Boolean.FALSE;
+                    }
+                    else if (name.equals(BED_DIFFERENCE_MORPH_WIDTH) ||
+                        name.equals(BED_DIFFERENCE_EPOCH_FILTERED) ||
+                        name.equals(BED_DIFFERENCE_EPOCH_HEIGHT1_FILTERED) ||
+                        name.equals(BED_DIFFERENCE_EPOCH_HEIGHT2_FILTERED) ||
+                        name.equals(BED_DIFFERENCE_HEIGHT_YEAR_FILTERED) ||
+                        name.equals(BED_DIFFERENCE_YEAR_FILTERED) ||
+                        name.equals(BED_DIFFERENCE_YEAR_HEIGHT1_FILTERED) ||
+                        name.equals(BED_DIFFERENCE_YEAR_HEIGHT2_FILTERED)){
+                        return Boolean.TRUE;
+                    }
+                    else {
+                        return null;
+                    }
+                }
+            });
+    }
+}