/*
    This software may only be used by you under license from AT&T Corp.
    ("AT&T").  A copy of AT&T's Source Code Agreement is available at
    AT&T's Internet website having the URL:
    <http://www.research.att.com/sw/tools/graphviz/license/source.html>
    If you received this software without first entering into a license
    with AT&T, you have an infringing copy of this software and cannot use
    it without violating AT&T's intellectual property rights.
*/
#pragma prototyped

#include	"render.h"


#define sqr(a) ((long) (a) * (a))
#define dstsq(a, b) (sqr (a.x - b.x) + sqr (a.y - b.y))
#define ldstsq(a, b) (sqr ((long) a.x - b.x) + sqr ((long) a.y - b.y))
#define dst(a, b) sqrt ((double) dstsq (a, b))
#define P2PF(p, pf) (pf.x = p.x, pf.y = p.y)
#define PF2P(pf, p) (p.x = ROUND (pf.x), p.y = ROUND (pf.y))

typedef struct arrowdir_s {
	char *dir;
	int sflag;
	int eflag;
} arrowdir_t;

static arrowdir_t Arrowdirs[] = {
	{"forward", ARR_NONE, ARR_NORM},
	{"back",    ARR_NORM, ARR_NONE},
	{"both",    ARR_NORM, ARR_NORM},
	{"none",    ARR_NONE, ARR_NONE},
	{(char *)0, 0,        0       }
};

typedef struct arrowname_s {
	char *name;
	int type;
	int len;
} arrowname_t;

static arrowname_t Arrownames[] = {
	{"none",     ARR_NONE,     0                                   },
	{"normal",   ARR_NORM,     ARROW_LENGTH                        },
	{"inv",      ARR_INV,      ARROW_INV_LENGTH                    },
	{"dot",      ARR_DOT,      ARROW_DOT_RADIUS*2                  },
	{"odot",     ARR_ODOT,     ARROW_DOT_RADIUS*2                  },
	{"invdot",   ARR_INVDOT,   ARROW_INV_LENGTH+ARROW_DOT_RADIUS*2 },
	{"invodot",  ARR_INVODOT,  ARROW_INV_LENGTH+ARROW_DOT_RADIUS*2 },
	{"tee",      ARR_TEE,      ARROW_LENGTH/2                      },
	{"empty",    ARR_EMPTY,    ARROW_LENGTH+1                      },
	{"invempty", ARR_INVEMPTY, ARROW_LENGTH                        },
	{"open",     ARR_OPEN,     0                                   },
	{"halfopen", ARR_HALFOPEN, 0                                   },
	{"diamond",  ARR_DIAMOND,  ARROW_LENGTH                        },
	{"odiamond", ARR_ODIAMOND, ARROW_LENGTH+1                      },
/* ediamond is for backwards compatibility. maps to ARR_ODIAMOND */
	{"ediamond", ARR_ODIAMOND, ARROW_LENGTH+1                      },
	{"box",      ARR_BOX,      ARROW_WIDTH                         },
	{"obox",     ARR_OBOX,     ARROW_WIDTH                         },
	{"crow",     ARR_CROW,     ARROW_LENGTH                        },
	{(char*)0,   0,            0                                   }
};

void arrow_flags (edge_t *e, int *sflag, int *eflag)
{
  char *attr;
  arrowdir_t *arrowdir;
  arrowname_t *arrowname;

  *sflag = ARR_NONE;
  *eflag = AG_IS_DIRECTED(e->tail->graph) ? ARR_NORM : ARR_NONE;
  if (E_dir && ((attr = agxget (e, E_dir->index)))[0]) {
    for (arrowdir = Arrowdirs; arrowdir->dir; arrowdir++) {
      if (streq(attr,arrowdir->dir)) {
        *sflag = arrowdir->sflag;
        *eflag = arrowdir->eflag;
        break;
      }
    }
  }
  if (E_arrowhead && ((attr = agxget (e, E_arrowhead->index)))[0]) {
    for (arrowname = Arrownames; arrowname->name; arrowname++) {
      if (strcmp(attr,arrowname->name) == 0) {
        *eflag = arrowname->type;
        break;
      }
    }
  }
  if (E_arrowtail && ((attr = agxget (e, E_arrowtail->index)))[0]) {
    for (arrowname = Arrownames; arrowname->name; arrowname++) {
      if (strcmp(attr,arrowname->name) == 0) {
        *sflag = arrowname->type;
        break;
      }
    }
  }
  if (ED_conc_opp_flag(e)) {
  	edge_t	*f;
	int		s0, e0;
	/* pick up arrowhead of opposing edge */
  	f = agfindedge(e->tail->graph,e->head,e->tail);
	arrow_flags (f, &s0, &e0);
	*eflag = *eflag | s0;
	*sflag = *sflag | e0;
  }
}

double arrow_length (edge_t* e, int flag)
{
  arrowname_t *arrowname;

  /* we don't simply index with flag because arr_type's are not consecutive */
  for (arrowname = Arrownames; arrowname->name; arrowname++) {
    if (flag==arrowname->type) {
      return arrowname->len * late_double(e,E_arrowsz,1.0,0.0);
      /* The original was missing the factor E_arrowsz, but I believe it
         should be here for correct arrow clipping */
    }
  }
  return 0;
}
/* end vladimir */


int arrowEndClip (Agedge_t* e, point* ps, int startp, int endp, bezier* spl, int eflag)
{
	pointf sp[4], sp2[4], pf;
	double d, t, elen, elen2;

	elen = arrow_length(e,eflag);
	elen2 = sqr(elen);
	spl->eflag = eflag, spl->ep = ps[endp + 3];
	if (endp > startp && ldstsq (ps[endp], ps[endp + 3]) < elen2) {
		endp -= 3;
	}
	P2PF (ps[endp], sp[3]);
	P2PF (ps[endp + 1], sp[2]);
	P2PF (ps[endp + 2], sp[1]);
	P2PF (ps[endp + 3], sp[0]);
	d = dst (sp[0], sp[1]) + dst (sp[1], sp[2]) + dst (sp[2], sp[3]);
    if (d > 0) {
    	if ((t = elen / d) > 1.0)
    		t = 1.0;
    	else if (t < 0.1)
    		t = 0.1;
    	for (;;) {
    		pf = Bezier (sp, 3, t, NULL, sp2);
    		if (ldstsq (pf, spl->ep) <= elen2)
    			break;
    		/*t *= (2.0/3.0);*/
    		t *= (9.0/10.0);
    	}
    	PF2P (sp2[3], ps[endp]);
    	PF2P (sp2[2], ps[endp + 1]);
    	PF2P (sp2[1], ps[endp + 2]);
    	PF2P (sp2[0], ps[endp + 3]);
    }

	return endp;
}

int arrowStartClip (Agedge_t* e, point* ps, int startp, int endp, bezier* spl, int sflag)
{
	pointf sp[4], sp2[4], pf;
	double d, t, slen, slen2;

	slen = arrow_length(e,sflag);
	slen2 = sqr(slen);
	spl->sflag = sflag, spl->sp = ps[startp];
 	if (endp > startp && ldstsq (ps[startp], ps[startp + 3]) < slen2) {
		startp += 3;
	}
	P2PF (ps[startp], sp[0]);
	P2PF (ps[startp + 1], sp[1]);
	P2PF (ps[startp + 2], sp[2]);
	P2PF (ps[startp + 3], sp[3]);
	d = dst (sp[0], sp[1]) + dst (sp[1], sp[2]) + dst (sp[2], sp[3]);
    if (d > 0) {
    	if ((t = slen / d) > 1.0)
    		t = 1.0;
    	else if (t < 0.1)
    		t = 0.1;
    	for (;;) {
    		pf = Bezier (sp, 3, t, NULL, sp2);
    		if (ldstsq (pf, spl->sp) <= slen2)
    			break;
    		/*t *= (2.0/3.0);*/
    		t *= (9.0/10.0);
    	}
    	PF2P (sp2[0], ps[startp]);
    	PF2P (sp2[1], ps[startp + 1]);
    	PF2P (sp2[2], ps[startp + 2]);
    	PF2P (sp2[3], ps[startp + 3]);
    }

	return startp;
}


void arrow_gen (point p, double theta, double scale, int flag)
/* 
 * Diomidis Spinellis, May 2002; added UML arrow types
 * Allowable are NORM | DOT | INV + DOT| TEE | OPEN | HALFOPEN | DIAMOND 
 * NORM, INV, DOT, DIAMOND can be or'ed with NOFILL giving 
 * EMPTY, INVEMPTY, ODOT, ODIAMOND, BOX, OBOX, CROW
 */
{
  point a[4];
  pointf u,v;
  int r;
  static char *arrowstyle_solid[2] = {"solid\0"};
  static char *arrowstyle_width[3] = {"setlinewidth\0""1\0"};
  theta = RADIANS(theta);

  /* Dotted and dashed styles on the arrowhead are ugly (dds) */
  /* linewidth needs to be reset */
  CodeGen->begin_context();
  CodeGen->set_style(arrowstyle_solid);
  CodeGen->set_style(arrowstyle_width);
  /* FIXME: does this have enough precision for ps? */
  if ((flag & ARR_NORM) || (flag & ARR_OPEN) || (flag & ARR_HALFOPEN)) {
    if (flag & ARR_HALFOPEN) {
      u.x = ARROW_INV_LENGTH*scale*cos(theta);
      u.y = ARROW_INV_LENGTH*scale*sin(theta);
      v.x = ARROW_INV_WIDTH/2.*scale*cos(theta+PI/2);
      v.y = ARROW_INV_WIDTH/2.*scale*sin(theta+PI/2);
    }
    else {
      u.x = ARROW_LENGTH*scale*cos(theta);
      u.y = ARROW_LENGTH*scale*sin(theta);
      v.x = ARROW_WIDTH/2.*scale*cos(theta+PI/2);
      v.y = ARROW_WIDTH/2.*scale*sin(theta+PI/2);
    }
    a[0].x = ROUND(p.x + u.x - v.x); a[0].y = ROUND(p.y + u.y - v.y);
    a[1] = p;
    a[2].x = ROUND(p.x + u.x + v.x); a[2].y = ROUND(p.y + u.y + v.y);
    if (flag & ARR_NORM) CodeGen->polygon(a,3,!(flag & ARR_NOFILL));
    else if (flag & ARR_OPEN) CodeGen->polyline(a,3);
    else if (flag & ARR_HALFOPEN) CodeGen->polyline(a,2);
    else assert(0);
    p.x = ROUND(u.x + p.x); p.y = ROUND(u.y + p.y);
  } else if (flag & ARR_TEE) {
    u.x = ARROW_LENGTH/2.*scale*cos(theta);
    u.y = ARROW_LENGTH/2.*scale*sin(theta);
    v.x = ARROW_WIDTH/2.*scale*cos(theta+PI/2);
    v.y = ARROW_WIDTH/2.*scale*sin(theta+PI/2);
    a[0].x = ROUND(p.x + u.x + v.x); a[0].y = ROUND(p.y + u.y + v.y);
    a[1].x = ROUND(p.x + u.x - v.x); a[1].y = ROUND(p.y + u.y - v.y);
    CodeGen->polyline(a,2);
    p.x = ROUND(u.x + p.x); p.y = ROUND(u.y + p.y);
  } else if (flag & ARR_DIAMOND) {
    u.x = ARROW_LENGTH/2.*scale*cos(theta);
    u.y = ARROW_LENGTH/2.*scale*sin(theta);
    v.x = ARROW_LENGTH/3.*scale*cos(theta+PI/2);
    v.y = ARROW_LENGTH/3.*scale*sin(theta+PI/2);
    a[0].x = ROUND(p.x+u.x+v.x); a[0].y = ROUND(p.y+u.y+v.y);
    a[1] = p;
    a[2].x = ROUND(p.x+u.x-v.x); a[2].y = ROUND(p.y+u.y-v.y);
    a[3].x = ROUND(p.x+2.*u.x); a[3].y = ROUND(p.y+2.*u.y);
    CodeGen->polygon(a,4,!(flag & ARR_NOFILL));
    p.x = ROUND(u.x + p.x); p.y = ROUND(u.y + p.y);
  } else if (flag & ARR_BOX) {
    u.x = ARROW_WIDTH*scale*cos(theta);
    u.y = ARROW_WIDTH*scale*sin(theta);
    v.x = ARROW_WIDTH/2.*scale*cos(theta+PI/2);
    v.y = ARROW_WIDTH/2.*scale*sin(theta+PI/2);
    a[0].x = ROUND(p.x+v.x);     a[0].y = ROUND(p.y+v.y);
    a[1].x = ROUND(p.x-v.x);     a[1].y = ROUND(p.y-v.y);
    a[2].x = a[1].x + ROUND(u.x); a[2].y = a[1].y + ROUND(u.y);
    a[3].x = a[0].x + ROUND(u.x); a[3].y = a[0].y + ROUND(u.y);
    CodeGen->polygon(a,4,!(flag & ARR_NOFILL));
    p.x = ROUND(u.x + p.x); p.y = ROUND(u.y + p.y);
  } else if (flag & ARR_INV) {
    u.x = ARROW_INV_LENGTH*scale*cos(theta);
    u.y = ARROW_INV_LENGTH*scale*sin(theta);
    v.x = ARROW_INV_WIDTH/2.*scale*cos(theta+PI/2);
    v.y = ARROW_INV_WIDTH/2.*scale*sin(theta+PI/2);
    a[0].x = ROUND(p.x + v.x); a[0].y = ROUND(p.y + v.y);
    a[1].x = ROUND(p.x + u.x); a[1].y = ROUND(p.y + u.y);
    a[2].x = ROUND(p.x - v.x); a[2].y = ROUND(p.y - v.y);
    /* dds: backwards compatibility: INV with DOT is always filled */
    CodeGen->polygon(a,3,!(flag&ARR_NOFILL)|(flag&ARR_DOT));
    p.x = ROUND(p.x + u.x); p.y = ROUND(p.y + u.y);
  } else if (flag & ARR_CROW) {
    u.x = ARROW_LENGTH*scale*cos(theta);
    u.y = ARROW_LENGTH*scale*sin(theta);
    v.x = ARROW_WIDTH*scale*cos(theta+PI/2);
    v.y = ARROW_WIDTH*scale*sin(theta+PI/2);
    a[0].x = ROUND(p.x + v.x);  a[0].y = ROUND(p.y + v.y);
    a[1].x = ROUND(p.x + u.x);  a[1].y = ROUND(p.y + u.y);
    a[2].x = ROUND(p.x - v.x);  a[2].y = ROUND(p.y - v.y);
    CodeGen->polyline(a,3);
    a[0] = p;
    CodeGen->polyline(a,2);
    p.x = ROUND(p.x + u.x); p.y = ROUND(p.y + u.y);
  }
  if (flag & ARR_DOT) {
    r = ROUND(ARROW_DOT_RADIUS*scale);
    p.x = p.x + ROUND(ARROW_DOT_RADIUS*scale*cos(theta));
    p.y = p.y + ROUND(ARROW_DOT_RADIUS*scale*sin(theta));
    CodeGen->ellipse(p,r,r, !(flag & ARR_NOFILL));
  }
  CodeGen->end_context();
}