#include <helianthus.h>
#include <math.h>


#define COUNT     16
#define SIZE      17
#define RADIUS    5
#define PRECISION 1e-5


double points[COUNT][2];
double *curPoint;
double curPointOffset[2];

int graphs[10];


double value(int ix)
  { return points[ ((ix + COUNT/2)%COUNT + COUNT)%COUNT ][1]; }

double nearest(double x)
  { return value(floor(x)); }

double linear(double x) {
  x -= 0.5;
  int ix = floor(x);
  x -= ix;
  return value(ix)*(1-x) + value(ix+1)*x;
}

double cubic(double x) {
  x -= 0.5;
  int ix = floor(x);
  x -= ix;

  double a = value(ix-1);
  double b = value(ix+0);
  double c = value(ix+1);
  double d = value(ix+2);

  return a*( -0.5*x*x*x +     x*x - 0.5*x )
			 + b*(  1.5*x*x*x - 2.5*x*x + 1.0   )
			 + c*( -1.5*x*x*x + 2.0*x*x + 0.5*x )
			 + d*(  0.5*x*x*x - 0.5*x*x         );
}

double bspline(double x) {
  x -= 0.5;
  int ix = floor(x);
  x -= ix;

  double a = value(ix-1);
  double b = value(ix+0);
  double c = value(ix+1);
  double d = value(ix+2);

  return a*(  -x*x*x + 3*x*x - 3*x + 1)/6
			 + b*( 3*x*x*x - 6*x*x + 4      )/6
			 + c*(-3*x*x*x + 3*x*x + 3*x + 1)/6
			 + d*(   x*x*x                  )/6;
}


void graph(double kx, double ky, double (*func)(double), unsigned int color) {
  saveState();
  strokeWidth(2);
  stroke(color);
  int hs = (int)ceil(SIZE*kx/2);
  for(int x = -hs; x <= hs; ++x)
    lineTo(x, func(x/kx)*ky);
  strokePath();
  restoreState();
}


void grid(double kx, double ky) {
  saveState();
  strokeWidth(1);
  stroke(colorByRGBA(0, 0, 1, 0.125));
  double hs = 0.5*SIZE;
  for(int step = 16; step; step >>= 1) {
    for(int i = 0; i <= SIZE/2; i += step) {
      line(-hs*kx,  i*ky, hs*kx,  i*ky);
      line(-hs*kx, -i*ky, hs*kx, -i*ky);
      line( i*kx, -hs*ky,  i*kx, hs*ky);
      line(-i*kx, -hs*ky, -i*kx, hs*ky);
    }
  }
  restoreState();
}

void randomize() {
  for(int i = 0; i < COUNT; ++i)
    points[i][1] = randomFloat()*SIZE - SIZE/2.0;
}

void zero() {
  for(int i = 0; i < COUNT; ++i)
    points[i][1] = 0;
}

void init() {
  for(int i = 0; i < COUNT; ++i)
    points[i][0] = i - COUNT/2 + 0.5;
  randomize();
}


void draw() {
  double w = windowGetWidth();
  double h = windowGetHeight();
  double kx = w/SIZE;
  double ky = h/SIZE;

  saveState();
  translate(w/2, h/2);
  scale(1, -1);

  if (keyWentDown("r")) { randomize(); curPoint = 0; }
  if (keyWentDown("z")) { zero(); curPoint = 0; }
  char key[] = "0";
  for(int i = 0; i < 10; ++i, ++*key)
    if (keyWentDown(key)) graphs[i] = !graphs[i];

  int m = mouseWentDown("left");
  double mx = mouseTransformedX();
  double my = mouseTransformedY();
  if (!mouseDown("left"))
    { m = FALSE; curPoint = 0; }
  if (curPoint) {
    //curPoint[0] = (mx + curPointOffset[0])/kx;
    curPoint[1] = (my + curPointOffset[1])/ky;
  }

  grid(kx, ky);
  if (graphs[0]) graph(kx, ky, nearest, colorByRGBA(0, 0, 0, 0.5));
  if (graphs[1]) graph(kx, ky, linear , colorByRGBA(0, 1, 0, 0.5));
  if (graphs[2]) graph(kx, ky, cubic  , colorByRGBA(0, 0, 1, 0.5));
  if (graphs[3]) graph(kx, ky, bspline, colorByRGBA(1, 0, 0, 0.5));

  strokeWidth(2);
  stroke(COLOR_BLUE);
  fill(COLOR_WHITE);
  for(int i = 0; i < COUNT; ++i) {
    double x = points[i][0]*kx, y = points[i][1]*ky;
    line(x, 0, x, y);
    circle(x, y, RADIUS);
    if (i == COUNT/2)
      circle(x, y, RADIUS + 1);
    double dx = x-mx, dy = y-my;
    if (m && dx*dx + dy*dy <= RADIUS*RADIUS) {
      curPoint = points[i];
      curPointOffset[0] = dx;
      curPointOffset[1] = dy;
    }
  }

  restoreState();
}


int main() {
  windowSetVariableFrameRate();
  windowSetResizable(TRUE);
  windowSetInit(&init);
  windowSetDraw(&draw);
  windowRun();
  return 0;
}