package de.intevation.flys.jfree;

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Stroke;

import org.apache.log4j.Logger;
import org.jfree.data.xy.XYSeriesCollection;
import org.w3c.dom.Document;

import de.intevation.flys.themes.ThemeAccess;
import de.intevation.flys.utils.ThemeUtil;


/**
 * One or more dataseries to draw a polygon (either "open up/downwards", or
 * the area between two curves), a theme-document and further display options.
 * The theme-document will later "style" the graphical representation.
 * The display options can be used to control the z-order and the axis of the
 * dataset.
 */
public class StyledAreaSeriesCollection extends XYSeriesCollection {
    /** Mode, how to draw/which areas to fill. */
    public enum FILL_MODE {UNDER, ABOVE, BETWEEN};

    /** MODE in use. */
    protected FILL_MODE mode;

    /** The theme-document with attributes about actual visual representation. */
    protected Document theme;

    /** Own logger. */
    private static final Logger logger =
        Logger.getLogger(StyledAreaSeriesCollection.class);


    /**
     * @param theme the theme-document.
     */
    public StyledAreaSeriesCollection(Document theme) {
        this.theme = theme;
        this.mode = FILL_MODE.BETWEEN;
   }


    /** Gets the Fill mode. */
    public FILL_MODE getMode() {
        return this.mode;
    }


    /** Sets the Fill mode. */
    public void setMode(FILL_MODE fMode) {
        this.mode = fMode;
    }


    /**
     * Applies line color, size and type attributes to renderer, also
     * whether to draw lines and/or points.
     * @param renderer Renderer to apply theme to.
     * @return \param renderer
     */
    public StableXYDifferenceRenderer applyTheme(
        StableXYDifferenceRenderer renderer
    ) {
        applyFillColor(renderer);
        applyShowShape(renderer);
        applyOutlineColor(renderer);
        applyOutlineStyle(renderer);
        applyShowArea(renderer);
        if (mode == FILL_MODE.UNDER) {
            renderer.setAreaCalculationMode(StableXYDifferenceRenderer.CALCULATE_NEGATIVE_AREA);
        }
        else if (mode == FILL_MODE.ABOVE) {
            renderer.setAreaCalculationMode(StableXYDifferenceRenderer.CALCULATE_POSITIVE_AREA);
        }
        else {
            renderer.setAreaCalculationMode(StableXYDifferenceRenderer.CALCULATE_ALL_AREA);
        }

        // Apply text style.
        new ThemeAccess(theme).parseTextStyle().apply(renderer);
        return renderer;
    }


    /**
     * Blindly (for now) apply the positivepaint of renderer.
     */
    protected void applyFillColor(StableXYDifferenceRenderer renderer) {
        // Get color.
        Color paint = ThemeUtil.parseFillColorField(theme);
        // Get half-transparency flag.
        if (ThemeUtil.parseTransparency(theme)) {
            paint = new Color(paint.getRed(), paint.getGreen(), paint.getBlue(),
                128);
        }
        if (paint != null && this.getMode() == FILL_MODE.ABOVE) {
            renderer.setPositivePaint(paint);
            renderer.setNegativePaint(new Color(0,0,0,0));
        }
        else if (paint != null && this.getMode() == FILL_MODE.UNDER) {
            renderer.setNegativePaint(paint);
            renderer.setPositivePaint(new Color(0,0,0,0));
        }
        else {
            if (paint == null) paint = new Color(177, 117, 102);
            renderer.setPositivePaint(paint);
            renderer.setNegativePaint(paint);
        }
    }

    /**
     * Blindly (for now) apply the postiviepaint of renderer.
     */
    protected void applyShowShape(StableXYDifferenceRenderer renderer) {
        boolean show = ThemeUtil.parseShowBorder(theme);
        renderer.setDrawOutline(show);
    }


    protected void applyShowLine(StableXYDifferenceRenderer renderer) {
        boolean show = ThemeUtil.parseShowLine(theme);
        renderer.setShapesVisible(show);
    }


    protected void applyOutlineColor(StableXYDifferenceRenderer renderer) {
        Color c = ThemeUtil.parseLineColorField(theme);
        renderer.setOutlinePaint(c);
    }

    protected void applyOutlineWidth(StableXYDifferenceRenderer renderer) {
        int size = ThemeUtil.parseLineWidth(theme);
    }

    /** Inform renderer whether it should draw a label. */
    protected void applyShowArea(StableXYDifferenceRenderer renderer) {
        renderer.setLabelArea(ThemeUtil.parseShowArea(theme));
    }

    protected void applyOutlineStyle(StableXYDifferenceRenderer renderer) {
        float[] dashes = ThemeUtil.parseLineStyle(theme);
        int size       = ThemeUtil.parseLineWidth(theme);

        Stroke stroke = null;

        if (dashes.length <= 1) {
            stroke = new BasicStroke(Integer.valueOf(size));
        }
        else {
            stroke = new BasicStroke(Integer.valueOf(size),
                BasicStroke.CAP_BUTT,
                BasicStroke.JOIN_ROUND,
                1.0f,
                dashes,
                0.0f);
        }

        renderer.setOutlineStroke(stroke);
    }
}
// vim:set ts=4 sw=4 si et sta sts=4 fenc=utf8 :