#include <math.h></math.h>

#include <helianthus.h></helianthus.h>

#define COUNT     10

#define TL        20

#define RADIUS    5

#define PRECISION 1e-5

typedef struct { double x, y, tx, ty; } Point;

typedef struct { double A, B, C, D; } Spline;

Point points[COUNT];

Point *curPoint;

double curPointOffset[2];

int curTangent;

void splineInit(Spline *s, double a, double b, double ta, double tb) {

  double d = b - a;

  if (!(fabs(d) > 1e-6))

    { s->A = a; s->B = s->C = s->D = 0; return; }

  double B = ta;

  double C = ((ta*ta - tb*tb)/d - d)*0.5;

  double A = a - C;

  double x = ta*tb + C*(d + C);

  double y = ta*d + C*(ta - tb);

  double D = atan2(fabs(y), x);

  //if (D < 0) D += PI;

  if (d < 0) D = -D;

  s->A = A;

  s->B = B;

  s->C = C;

  s->D = D;

}

double splineValue(const Spline *s, double l) {

  l *= s->D;

  return s->A + s->B*sin(l) + s->C*cos(l);

}

double splineTangent(const Spline *s, double l) {

  l *= s->D;

  return s->B*cos(l) + s->C*sin(l);

}

void drawSplineSegment(const Point *a, const Point *b) {

  Spline sx, sy;

  splineInit(&sx, a->x, b->x, a->tx, b->tx);

  splineInit(&sy, a->y, b->y, a->ty, b->ty);

  int count = 10;

  for(int i = 1; i < count; ++i) {

    double l = i/(double)count;

    double x = splineValue(&sx, l);

    double y = splineValue(&sy, l);

    lineTo(x, y);

  }

  lineTo(b->x, b->y);

}

void drawSpline(const Point *p, int count) {

  if (count < 2) return;

  moveTo(p->x, p->y);

  for(int i = 1; i < count; ++i)

    drawSplineSegment(p+i-1, p+i);

  strokePath();

}

void init() {

  for(int i = 0; i < COUNT; ++i) {

    points[i].x = (i/(COUNT - 1.0) - 0.5)*256;

    points[i].tx = 100.0;

  }

}

void draw() {

  double w = windowGetWidth();

  double h = windowGetHeight();

  saveState();

  translate(w/2, h/2);

  int m = mouseWentDown("left");

  double mx = mouseTransformedX();

  double my = mouseTransformedY();

  if (!mouseDown("left"))

    { m = FALSE; curPoint = 0; }

  if (curPoint) {

    curPoint->x = mx + curPointOffset[0];

    curPoint->y = my + curPointOffset[1];

  }

  strokeWidth(2);

  stroke(COLOR_BLUE);

  fill(COLOR_WHITE);

  drawSpline(points, COUNT);

  for(int i = 0; i < COUNT; ++i) {

    Point *p = points + i;

    circle(p->x, p->y, RADIUS);

    double dx = p->x-mx, dy = p->y-my;

    if (m && dx*dx + dy*dy <= RADIUS*RADIUS) {

      curPoint = p;

      curPointOffset[0] = dx;

      curPointOffset[1] = dy;

    }

  }

  restoreState();

}

int main() {

  windowSetVariableFrameRate();

  windowSetResizable(TRUE);

  windowSetInit(&init);

  windowSetDraw(&draw);

  windowRun();

  return 0;

}