package com.bbn.openmap.omGraphics.labeled;

import java.awt.Font;
import java.awt.Paint;
import java.awt.Point;

import com.bbn.openmap.omGraphics.OMSpline;
import com.bbn.openmap.omGraphics.OMText;
import com.bbn.openmap.omGraphics.labeled.LabeledOMGraphic;
import com.bbn.openmap.proj.Projection;
import com.bbn.openmap.util.Debug;

/**
 * LabeledOMSpline Copied from LabeledOMPoly, because both OMSpline
 * and LabeledOMPoly inherits from OMPoly
 * 
 * @author Eric LEPICIER
 * @version 15 juil. 2002
 */
public class LabeledOMSpline extends OMSpline implements LabeledOMGraphic {

    protected OMText label;
    protected Point offset;
    protected boolean locateAtCenter = false;
    protected int index = 0;

    /**
     * Default constructor.
     */
    public LabeledOMSpline() {
        super();
    }

    /**
     * Create an LabeledOMSpline from a list of float lat/lon pairs.
     */
    public LabeledOMSpline(float[] llPoints, int units, int lType) {
        super(llPoints, units, lType);
    }

    /**
     * Create an LabeledOMSpline from a list of float lat/lon pairs.
     */
    public LabeledOMSpline(float[] llPoints, int units, int lType, int nsegs) {
        super(llPoints, units, lType, nsegs);
    }

    /**
     * Create an LabeledOMSpline from a list of xy pairs.
     */
    public LabeledOMSpline(int[] xypoints) {
        super(xypoints);
    }

    /**
     * Create an x/y LabeledOMSpline.
     */
    public LabeledOMSpline(int[] xPoints, int[] yPoints) {
        super(xPoints, yPoints);
    }

    /**
     * Create an x/y LabeledOMSpline at an offset from lat/lon.
     */
    public LabeledOMSpline(float latPoint, float lonPoint, int[] xypoints,
            int cMode) {
        super(latPoint, lonPoint, xypoints, cMode);
    }

    /**
     * Create an x/y LabeledOMSpline at an offset from lat/lon.
     */
    public LabeledOMSpline(float latPoint, float lonPoint, int[] xPoints,
            int[] yPoints, int cMode) {
        super(latPoint, lonPoint, xPoints, yPoints, cMode);
    }

    /**
     * Set the String for the label.
     */
    public void setText(String label) {
        getLabel().setData(label);
    }

    /**
     * Get the String for the label.
     */
    public String getText() {
        return getLabel().getData();
    }

    protected OMText getLabel() {
        if (label == null) {
            label = new OMText(-1, -1, "", OMText.JUSTIFY_LEFT);
        }
        return label;
    }

    /**
     * Set the Font for the label.
     */
    public void setFont(Font f) {
        getLabel().setFont(f);
    }

    /**
     * Get the Font for the label.
     */
    public Font getFont() {
        return getLabel().getFont();
    }

    /**
     * Set the justification setting for the label.
     * 
     * @see com.bbn.openmap.omGraphics.OMText#JUSTIFY_LEFT
     * @see com.bbn.openmap.omGraphics.OMText#JUSTIFY_CENTER
     * @see com.bbn.openmap.omGraphics.OMText#JUSTIFY_RIGHT
     */
    public void setJustify(int just) {
        getLabel().setJustify(just);
    }

    /**
     * Get the justification setting for the label.
     * 
     * @see com.bbn.openmap.omGraphics.OMText#JUSTIFY_LEFT
     * @see com.bbn.openmap.omGraphics.OMText#JUSTIFY_CENTER
     * @see com.bbn.openmap.omGraphics.OMText#JUSTIFY_RIGHT
     */
    public int getJustify() {
        return getLabel().getJustify();
    }

    /**
     * Tell the LabeledOMGraphic to calculate the location of the
     * String that would put it in the middle of the OMGraphic.
     */
    public void setLocateAtCenter(boolean set) {
        locateAtCenter = set;
        if (set) {
            setJustify(OMText.JUSTIFY_CENTER);
            getLabel().setFMHeight(OMText.ASCENT);
        }
    }

    /**
     * Get whether the LabeledOMGraphic is placing the label String in
     * the center of the OMGraphic.
     */
    public boolean isLocateAtCenter() {
        return locateAtCenter;
    }

    /**
     * Get the calculated center where the label string is drawn.
     */
    public Point getCenter() {
        return new Point();
    }

    /**
     * Set the index of the OMGraphic coordinates where the drawing
     * point of the label should be attached. The meaning of the point
     * differs between OMGraphic types.
     */
    public void setIndex(int index) {
        this.index = index;
    }

    /**
     * Get the index of the OMGraphic where the String will be
     * rendered. The meaning of the index differs from OMGraphic type
     * to OMGraphic type.
     */
    public int getIndex() {
        return index;
    }

    /**
     * Set the x, y pixel offsets where the String should be rendered,
     * from the location determined from the index point, or from the
     * calculated center point. Point.x is the horizontal offset,
     * Point.y is the vertical offset.
     */
    public void setOffset(Point p) {
        offset = p;
    }

    /**
     * Get the x, y pixel offsets set for the rendering of the point.
     */
    public Point getOffset() {
        if (offset == null) {
            offset = new Point();
        }
        return offset;
    }

    /**
     * Set the angle by which the text is to rotated.
     * 
     * @param angle the number of radians the text is to be rotated.
     *        Measured clockwise from horizontal. Positive numbers
     *        move the positive x axis toward the positive y axis.
     */
    public void setRotationAngle(double angle) {
        getLabel().setRotationAngle(angle);
    }

    /**
     * Get the current rotation of the text.
     * 
     * @return the text rotation.
     */
    public double getRotationAngle() {
        return getLabel().getRotationAngle();
    }

    boolean matchPolyPaint = true;

    /**
     * Set the line paint for the polygon. If the text paint hasn't
     * been explicitly set, then the text paint will be set to this
     * paint, too.
     */
    public void setLinePaint(Paint paint) {
        super.setLinePaint(paint);
        if (matchPolyPaint) {
            getLabel().setLinePaint(paint);
        }
    }

    /**
     * If not set to null, the text will be painted in a different
     * color. If set to null, the text paint will match the poly edge
     * paint.
     * 
     * @param paint the Paint object for the text
     */
    public void setTextPaint(Paint paint) {
        if (paint != null) {
            matchPolyPaint = false;
            getLabel().setLinePaint(paint);
        }
    }

    Point handyPoint = new Point();

    protected Point getTextPoint(Projection proj) {
        int i;
        int avgx = 0;
        int avgy = 0;

        // Assuming that the rendertype is not unknown...
        if (renderType == RENDERTYPE_LATLON) {
            int numPoints = rawllpts.length / 2;
            if (rawllpts.length < 2) {
                // off screen...
                handyPoint.setLocation(-10, -10);
                return handyPoint;
            }
            if (locateAtCenter) {
                for (i = 0; i < rawllpts.length; i += 2) {
                    proj.forward(rawllpts[i], rawllpts[i + 1], handyPoint, true);

                    avgy += handyPoint.getY();
                    avgx += handyPoint.getX();
                }
                avgy = avgy / numPoints;
                avgx = avgx / numPoints;
                handyPoint.setLocation(avgx, avgy);
            } else {
                if (index < 0)
                    index = 0;
                if (index > numPoints)
                    index = numPoints - 1;
                proj.forward(rawllpts[2 * index],
                        rawllpts[2 * index + 1],
                        handyPoint,
                        true);
            }
        } else {
            int[][] x = xpoints;
            int[][] y = ypoints;

            if (x[0].length < 2) {
                // off screen...
                handyPoint.setLocation(-10, -10);
                return handyPoint;
            }

            if (locateAtCenter) {
                for (i = 0; i < x[0].length; i++) {
                    avgx += x[0][i];
                    avgy += y[0][i];
                }
                handyPoint.setLocation(avgx / x[0].length, avgy / x[0].length);
            } else {
                if (index < 0)
                    index = 0;
                if (index >= x[0].length)
                    index = x[0].length - 1;
                handyPoint.setLocation(x[0][index], y[0][index]);
            }
        }
        return handyPoint;
    }

    public boolean generate(Projection proj) {
        boolean ret = super.generate(proj);

        Point p = getTextPoint(proj);
        label.setX((int) (p.getX() + getOffset().getX()));
        label.setY((int) (p.getY() + getOffset().getY()));

        if (Debug.debugging("labeled")) {
            Debug.output("Setting label(" + label.getData() + ") to " + p);
        }

        label.generate(proj);
        return ret;
    }

    public void render(java.awt.Graphics g) {
        super.render(g);
        label.render(g);
    }

}