/*
Copyright 2003 by Ralph Hartley
This software is licenced under the terms of the
Gnu Public Licence
*/

import java.awt.*;
import javax.swing.*;
import java.awt.geom.*;
import java.io.*;
import java.util.*;

/**
 * A style of arrow head.
 */
public class Arrow extends FileDefaultable implements Serializable {

  private static final long serialVersionUID = Version.getSUID();

  /** Draw left half of arrow
   */
  public boolean left = true;

  /** Draw Right half of arrow
   */
  public boolean right = true;

  /** Draw Back of arrow
   */
  public boolean back = true;

  /** Draw solid arrow
   */
  public boolean solid = false;

  /** length/width of arrow */
  public float aspect = (float)2.0;

  /** Curvature of side of arrow */
  public float concavity = (float)0.3;

  /** Curvature of back of arrow */
  public float backconcavity = (float)0.3;

  /** Where back of arrow arrow meets axis */
  public float backjunction = (float)0.3;
  
  /**
   * The size of the arrow to draw.<br>
   * If none, the size will be based on the
   * thickness of the line.
   */
  public Size size = Size.none;

  public String name;
  public String getName() {return(name);}

  public Arrow(String name) {
    this.name = name;
  }

  public static TreeSet defaults;
  public static TreeSet mindefaults = new TreeSet();
  public static TreeSet file = new TreeSet();
  public static TreeSet fixed = new TreeSet();

  public static Arrow none;

  static {
    fixed.add(none = new Arrow("None"));

    mindefaults.add(new Arrow("plain",true,true,false,false,Size.arrow,1.4, 0.5,1,1));
    mindefaults.add(new Arrow("closed",true,true,false,true,Size.arrow,1.4, 0.5,1,1));
    mindefaults.add(new Arrow("solid",true,true,true,true,Size.arrow,1.4, 0.5,1,1));
    mindefaults.add(new Arrow("thin",true,true,false,true,Size.arrow,0.8, 0.3,0.9,0.85));
    mindefaults.add(new Arrow("thinsolid",true,true,true,true,Size.arrow,0.8, 0.3,0.9,0.85));
    mindefaults.add(new Arrow("left",true,false,true,true,Size.arrow,0.8, 0.3,0.9,0.85));
    mindefaults.add(new Arrow("right",false,true,true,true,Size.arrow,0.8, 0.3,0.9,0.85));

    defaults = (TreeSet)mindefaults.clone();

    fixedmap.put(Arrow.class,fixed);
    defmap.put(Arrow.class,defaults);
    minmap.put(Arrow.class,mindefaults);
    filemap.put(Arrow.class,file);
  }

  public Arrow(String name,
               boolean left, boolean right, boolean solid, boolean back,
               Size size,double aspect, double concavity,
               double backjunction, double backconcavity) {
    this.name = name;
    this.left=left;
    this.right=right;
    this.back = back;
    this.solid = solid;
    this.size= size;
    this.aspect = (float)aspect;
    this.concavity = (float)concavity;
    this.backjunction = (float)backjunction;
    this.backconcavity = (float)backconcavity;
  }

  public boolean edit(JFrame owner) {
    JPanel panel = new JPanel();
    panel.setLayout(new BoxLayout(panel,BoxLayout.Y_AXIS));

    javax.swing.Box row = new javax.swing.Box(BoxLayout.X_AXIS);
    JComboBox sizefield = new JComboBox(Size.getAll(Size.class));
    sizefield.setSelectedItem(size);
    row.add(sizefield);
    JTextField aspectfield = PrefEditor.addDouble(row,aspect,"Aspect Ratio");
    JCheckBox solidbox = new JCheckBox("Solid",solid);
    row.add(solidbox);
    panel.add(row);

    row = new javax.swing.Box(BoxLayout.X_AXIS);
    JCheckBox leftbox = new JCheckBox("Left",left);
    row.add(leftbox);
    JCheckBox rightbox = new JCheckBox("Right",right);
    row.add(rightbox);
    JTextField concavityfield = PrefEditor.addDouble(row,concavity,"Concavity");
    panel.add(row);

    row = new javax.swing.Box(BoxLayout.X_AXIS);

    JCheckBox backbox = new JCheckBox("Back",back);
    row.add(backbox);

    JTextField backfield = PrefEditor.addDouble(row,backjunction,"Back Junction point");
    JTextField backconcavityfield = PrefEditor.addDouble(row,backconcavity,"Back Concavity");
    panel.add(row);

    if (JOptionPane.showConfirmDialog(owner,panel,"Edit size"+name,JOptionPane.OK_CANCEL_OPTION) ==
        JOptionPane.OK_OPTION) {
      left = leftbox.isSelected();
      right = rightbox.isSelected();
      back = backbox.isSelected();
      solid = solidbox.isSelected();
      aspect = (float)PrefEditor.readDouble(aspectfield);
      concavity = (float)PrefEditor.readDouble(concavityfield);
      backjunction = (float)PrefEditor.readDouble(backfield);
      backconcavity = (float)PrefEditor.readDouble(backconcavityfield);
      size = (Size)sizefield.getSelectedItem();
      if (size==Size.none) size = null;

//      clearEdit();
      return(true);
    }

//    clearEdit();
    return(false);

  }
  
  public Object clone() {
    Arrow res = new Arrow(name);
    res.copy(this);
    return((Object)res);
  }

  public void copy(FileDefaultable thatitem) {
    Arrow that = (Arrow)thatitem;
    name = that.name;
    left = that.left;
    right = that.right;
    back = that.back;
    solid = that.solid;
    size = that.size;
    aspect = that.aspect;
    concavity = that.concavity;
    backjunction = that.backjunction;
    backconcavity = that.backconcavity;
  }
  
  public Object readResolve() throws ObjectStreamException {
    return((Object)getGlobal(Arrow.class));
  }

  public void draw(View view, Anchor point, int direction, CurveAtt props) {
    point.guideUpdate();

    Color color = view.draw.getColor();
    view.draw.setColor(props.color);

    double thickness = props.thickness.getSize(view.mapscale);
    double scale = (size==null?thickness*10:size.getSize(view.mapscale))/view.scale; 

    float scalethick = (float)(thickness/(view.scale*scale*aspect));
    float len = (float)(point.position.distance(point.guide[direction])/scale);

//    System.out.println("Arrow thick = "+thickness+" scale = "+scale+" len = "+len+" scalethick = "+scalethick+
//        	       " View.scale = "+view.scale+"\n");

    AffineTransform trans = (AffineTransform)view.trans.clone();
    trans.concatenate(point.position);
    trans.rotate(-Math.atan2(point.guidelocal[direction].getX(),point.guidelocal[direction].getY()));
    trans.scale(scale*aspect/2,scale);

    GeneralPath path = new GeneralPath(GeneralPath.WIND_NON_ZERO);

    if (!solid) {
      Stroke st = view.draw.getStroke();
      view.draw.setStroke(new BasicStroke((float)thickness,
        				  BasicStroke.CAP_BUTT,
        				  BasicStroke.JOIN_MITER,(float)30.0));
      path.moveTo(0,0);
      path.lineTo(0,len-backjunction);

      if (left) {
        if (back) path.quadTo((float)-0.5,len-backconcavity,-1,len-1);
        else path.moveTo(-1,len-1);
        path.quadTo(-concavity,(float)(len-0.5),0,len);
      }
      else
        path.lineTo(0,len);

      if (right) {
        path.quadTo(concavity,(float)(len-0.5),1,len-1);
        if (back) path.quadTo((float)0.5,len-backconcavity,0,len-backjunction);
        else path.moveTo(0,len-backjunction);
      }
      else
        path.lineTo(0,len-backjunction);

      if (!back && left && right) path.lineTo(0,len);

      Shape shape = trans.createTransformedShape(path);
      view.draw.draw(shape);

      view.draw.setStroke(st);
    }
    else { //Solid
      float ppos = 0;
      if (left) ppos += scalethick;
      if (right) ppos -= scalethick;

      path.moveTo(0,0);
      path.lineTo(-scalethick,0);
      path.lineTo(-scalethick,len-backjunction);

      if (left) {
        path.quadTo((float)-0.5,len-backconcavity,-1,len-1);
        path.quadTo(-concavity,(float)(len-0.5),ppos,len);
      }
      else
        path.lineTo(ppos,len);

      if (right) {
        path.quadTo(concavity,(float)(len-0.5),1,len-1);
        path.quadTo((float)0.5,len-backconcavity,scalethick,len-backjunction);
      }
      else
        path.lineTo(scalethick,len-backjunction);

      path.lineTo(scalethick,0);
      path.closePath();

      Shape shape = trans.createTransformedShape(path);
      view.draw.fill(shape);
    }

    view.draw.setColor(color);
  }

}