#include <cmath>
#include "Maths.h"

struct vec2f
{
  float x, y;
};

vec2f operator*(const vec2f& v, float c)
{
  return (vec2f){ v.x*c, v.y*c };
}

vec2f operator*(float c, const vec2f& v)
{
  return (vec2f){ v.x*c, v.y*c };
}

vec2f operator+(const vec2f& v1, const vec2f& v2)
{
  return (vec2f){ v1.x+v2.x, v1.y+v2.y };
}

// Generalized spline function
// a_tension       -1.0 -> 1.0     Round -> Tight
// a_bias          -1.0 -> 1.0     Pre shoot -> Post shoot
// a_continuity    -1.0 -> 1.0     Box corners -> Inverted corners
vec2f kochanekBartelsSpline(const std::vector<vec2f>& a_points, float t, float a_tension, float a_bias, float a_continuity)
{
  int pnts = a_points.size();
  if (!pnts)
    return (vec2f){ 0.0f, 0.0f };
  t = std::max(0.0f, std::min(1.0f, t)); // clamp t to be between 0->1
  int intervals = pnts - 1; // the intervals are the segments between each point 
  int n = std::max(0, std::min(pnts-1, int(intervals * t))); // figure out which interval t is between
  t = t * intervals - n; // the new t value is the ratio between the points at n and n+1
  float tmp1 = 0.5f * (1.0f - a_tension);
  float A = tmp1 * (1.0f + a_continuity) * (1.0f + a_bias); // A,B,C,D are the parameter factors
  float B = tmp1 * (1.0f - a_continuity) * (1.0f - a_bias);
  float C = tmp1 * (1.0f - a_continuity) * (1.0f + a_bias);
  float D = tmp1 * (1.0f + a_continuity) * (1.0f - a_bias);
  const vec2f& pnt0 = a_points[std::max(n - 1, 0)];
  const vec2f& pnt1 = a_points[n];
  const vec2f& pnt2 = a_points[std::min(pnts - 1, n + 1)];
  const vec2f& pnt3 = a_points[std::min(pnts - 1, n + 2)];
  vec2f vA =  -A*pnt0 +      (2+A-B-C)*pnt1 +  (-2+B+C-D)*pnt2 +  D*pnt3; // vA,vB,vC - polynomial factors
  vec2f vB = 2*A*pnt0 + (-3-2*A+2*B+C)*pnt1 + (3-2*B-C+D)*pnt2 + -D*pnt3;
  vec2f vC =  -A*pnt0 +          (A-B)*pnt1 +           B*pnt2;
  return ((vA*t + vB)*t + vC)*t + pnt1; // blends by the factors between the 4 closest control points
}

#if 0
struct vec4f
{
  union {
    float v[4];
    struct { float x, y, z, w; };
  };
};


struct mat4f
{
  union {
    vec4f m[4];
    struct { vec4f t, b, n, w; };  // tangent, bi-normal, normal
  };
};


vec4f operator +(const vec4f& a, const vec4f& b)
{
  vec4f res = {{{ a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w }}};
  return res;
}


vec4f operator -(const vec4f& a, const vec4f& b)
{
  vec4f res = {{{ a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w }}};
  return res;
}


inline float dot3(const vec4f& a, const vec4f& b)
{
  //return Math::dotProduct(&a.x, &b.x, 1, 1, 3);
  return a.x * b.x + a.y * b.y + a.z * b.z;
}


vec4f operator *(const vec4f& a, const vec4f& b)
{
  vec4f res;
  res.x = a.x * b.x;
  res.y = a.y * b.y;
  res.z = a.z * b.z;
  res.w = a.w * b.w;
  return res;
}


vec4f scaleVector(const vec4f& a, float b)
{
  vec4f res;
  res.x = a.x * b;
  res.y = a.y * b;
  res.z = a.z * b;
  res.w = a.w * b;
  return res;
}
vec4f operator *(const vec4f& a, float b)
{
  return scaleVector(a, b);
}


struct rotation
{
  const vec4f& q()      // get the quaternion
  {
    return quaternion;
  }
  const mat4f& m()      // get as a matrix
  {
    if (dirty)
    {
      convert();
    }
    return cachedMatrix;
  }
  void set(vec4f quat)  // set
  {
    quaternion = quat;
    dirty = true;
  }
  // TODO: perhaps operator overload the get and sets
private:
  void convert()
  {
    Math::quatToMatrix4x4(&cachedMatrix.m[0].x, &quaternion.x);
    dirty = false;
  }
  vec4f quaternion;
  bool dirty = true;
  mat4f cachedMatrix; // only needs to be 3x3
};


vec4f rotateVector(const vec4f& vec, const mat4f& mat)
{
  vec4f res;
  Math::transformVector(&res.x, &mat.t.x, &vec.x);
  return res;
}
vec4f operator *(const vec4f& a, const mat4f& mat)
{
  return rotateVector(a, mat);
}


float vectorLength(vec4f& vec)
{
  return sqrt(Math::dotProduct(&vec.x, &vec.x, 1, 1, 3));
}


#include <OpenGL/gl.h> // suggest not include directly but make the framework provide an include which includes the system one
#endif

#include "Widget.h"
#include "CommonWidgets.h"
#include "Painter.h"
#include "Application.h"
USING_NAMESPACE


class NamedSlider : public HBox
{
public:
  NamedSlider(Widget* parent, Property<int>& value, const char* name) : HBox(parent)
  {
    label = name;
    new Label(this, label);
    new Slider(this, value);
  }
  Property<String> label;
};


class FontEditWindow : public Widget
{
  VBox vbox;
  Button quitButton;
  Property<bool> useRoundPen;
  Property<bool> useSquarePen;
  Property<bool> useFlatPen;
  Property<int> bias;
  Property<int> continuity;
  Property<int> tension;
  Property<int> ascent;
  Property<int> descent;
  Property<int> angle;
  Property<int> width;
  Property<int> penAngle;
  Property<int> penWidth;
  Property<int> character;
public:
  FontEditWindow(Widget* a_parent, const char* a_name)
    : Widget(a_parent, a_name)
    , vbox(this)
    , quitButton(&vbox, "Quit")
  {
    new CheckBox(&vbox, useRoundPen, "Use Round Pen");
    new CheckBox(&vbox, useSquarePen, "Use Square Pen");
    new CheckBox(&vbox, useFlatPen, "Use Flat Pen");
    Grid *g = new Grid(&vbox, 2);
    new GridSlider(g, bias, "Bias");
    new GridSlider(g, continuity, "Continuity");
    new GridSlider(g, tension, "Tension");
    new GridSlider(g, ascent, "Ascender Height");
    new GridSlider(g, descent, "Descender Height");
    new GridSlider(g, angle, "Angle");
    new GridSlider(g, width, "Width");
    new GridSlider(g, penAngle, "Pen Angle");
    new GridSlider(g, penWidth, "Pen Width");
    new GridSlider(g, character, "Character");
    connect(quitButton.activated, this, &FontEditWindow::onQuit); 
    bias = (1<<15);
    tension = (1<<15);
    continuity = (1<<16);
  }

  void onQuit(int)
  {
    exit(0);
  }

  void mouseEvent(MouseEvent& a_event) override
  {
    /*
    int x = a_event.m_position.m_x;
    int y = a_event.m_position.m_y;
    if (lastX == -1) { lastX = x; lastY = y; }
    if (a_event.m_buttons == MB_Right)
    {
      tx += x - lastX; ty += y - lastY;
    }
    else if (a_event.m_buttons == MB_Left)
    {
      trackingMouse = !trackingMouse;
      x = -1;
    }
    else if (trackingMouse)
    {
      rx += x - lastX; ry += y - lastY;
    }
    else
    {
      x = -1;
    }
    lastX = x; lastY = y;
    */
    
    //printf("got mouse event\n");
    repaint();
  }
    
  void paintEvent(PaintEvent& a_event) override
  {
    Painter p(this);
    p.setPen(0x000000);
    int w = width() / 2;
    int h = height() / 2;
    p.drawLine(5, 5, w-5, 5);
    p.drawLine(5, 5, 5, h-5);
    p.drawLine(w-5, 5, w-5, h-5);
    p.drawLine(5, h-5, w-5, h-5);
    //repaint();

    int scale = 50;
    int x1 = 350;
    int y1 = 100;
    int penWidth = 7;
    
    int xstep = scale;
    int ystep = scale;
    int w2 = ystep*3;
    int h2 = xstep*3;
    for (int i = 0; i < 4; i++)
      p.drawLine(x1, y1+ystep*i, x1+w2, y1+ystep*i);
    for (int i = 0; i < 4; i++)
      p.drawLine(x1+xstep*i, y1, x1+xstep*i, y1+h2);

    float cx = x1 + xstep + (xstep - penWidth) / 2;
    float cy = y1 + ystep * 1.5f;
 
    // For each stroke, quantize the points to a 16x16 grid - a position can be encoded in 8-bits
    // Then the composition of the strokes can place these stoke pieces relative to each other with
    // some positioning flags - v-flip, h-flip, left/top offset of 4bits each
    // ---- ---- ---- ----
    // ---- ---- ---- ----
    // ---- ---- ---- ----
    // ---- ---- ---- ----
    // ---- ---- ---- ----


    // Editor of the strokes with snapping to grid and with a box pen position so snapping can be aligned according to the pen and
    // the grid points

    std::vector<vec2f> pnts[16];
    // C-top
    pnts[0].push_back((vec2f){ float(x1 + xstep), cy });
    pnts[0].push_back((vec2f){ float(x1 + xstep) + 5, cy - 10 });
    pnts[0].push_back((vec2f){ cx - 10, float(y1 + ystep + 5) });
    pnts[0].push_back((vec2f){ cx, float(y1 + ystep) });
    pnts[0].push_back((vec2f){ cx + 10, float(y1 + ystep + 5) });
    pnts[0].push_back((vec2f){ float(x1 + 2*xstep - penWidth) - 5, cy - 15 });
    pnts[0].push_back((vec2f){ float(x1 + 2*xstep - penWidth), cy - 5 });
    
    // a-line
    pnts[1].push_back((vec2f){ float(x1 + 2*xstep - penWidth), float(y1 + ystep + 2) });
    pnts[1].push_back((vec2f){ float(x1 + 2*xstep - penWidth), float(y1 + 2*ystep + 2) });

    // b-line
    pnts[2].push_back((vec2f){ float(x1 + 2*xstep - penWidth), float(y1 + 2) });
    pnts[2].push_back((vec2f){ float(x1 + 2*xstep - penWidth), float(y1 + 2*ystep + 2) });
    
    // e-line
    pnts[3].push_back((vec2f){ float(x1 + xstep + penWidth), float(cy) });
    pnts[3].push_back((vec2f){ float(x1 + 2*xstep - penWidth), float(cy) });
    
    // n-line
    pnts[4].push_back((vec2f){ float(x1 + 2*xstep - penWidth), float(cy) });
    pnts[4].push_back((vec2f){ float(x1 + 2*xstep - penWidth), float(y1 + 2*ystep + 2) });
    
    // n-line
    pnts[4].push_back((vec2f){ float(x1 + 2*xstep - penWidth), float(cy) });
    pnts[4].push_back((vec2f){ float(x1 + 2*xstep - penWidth), float(y1 + 2*ystep + 2) });

   /* 
    int pw = 2;
    std::vector<unsigned char> pnts2[16];
    // C-top
    pnts2[0].push_back((vec2f){ 0,             8 });
    pnts2[0].push_back((vec2f){ 0 + 1,         8 - 1 });
    pnts2[0].push_back((vec2f){ 8 - 1,         0 + 1 });
    pnts2[0].push_back((vec2f){ 8,             0 });
    pnts2[0].push_back((vec2f){ 8 + 1,         0 + 1 });
    pnts2[0].push_back((vec2f){ (16 - pw) - 1, 8 - 2 });
    pnts2[0].push_back((vec2f){ 16 - pw,       8 - 1 });
    
    // a-line
    pnts2[1].push_back((vec2f){ 16 - pw, 5 });
    pnts2[1].push_back((vec2f){ 16 - pw, 10 });

    // b-line
    pnts2[2].push_back((vec2f){ 16 - pw, 0 });
    pnts2[2].push_back((vec2f){ 16 - pw, 16 });
    
    // e-line
    pnts2[3].push_back((vec2f){ 8 + pw, 4 });
    pnts2[3].push_back((vec2f){ 16 - pw, 4 });
    
    // n-line
    pnts2[4].push_back((vec2f){ 16 - pw, float(cy) });
    pnts2[4].push_back((vec2f){ 16 - pw, float(y1 + 2*ystep + 2) });
    
    // n-line
    pnts2[4].push_back((vec2f){ 16 - pw, float(cy) });
    pnts2[4].push_back((vec2f){ 16 - pw, float(y1 + 2*ystep + 2) });

    // pnts[0] is c-top
    // pnts[0] flipped vertically is c-bottom
    // pnts[1] is a-line
    // pnts[2] is b-line
    */

    // a ->  0,c-top  1,c-top  0,a-line

    struct { int flags; int index; } characters[][5] = {
      { { 0|0, 0 }, { 0|1, 0 }, { 0|0, 1 }, { -1, -1 } },  // 'a'
      { { 2|0, 0 }, { 2|1, 0 }, { 2|0, 2 }, { -1, -1 } },  // 'b'
      { { 0|0, 0 }, { 0|1, 0 }, { -1, -1 } },              // 'c'
      { { 0|0, 0 }, { 0|1, 0 }, { 0|0, 2 }, { -1, -1 } },  // 'd'
      { { 0|0, 0 }, { 0|1, 0 }, { 0|0, 3 }, { -1, -1 } },  // 'e'
      { { 0|0, 3 }, { 4|0, 2 }, { -1, -1 } },              // 'c'  'f'
      { { 0|0, 0 }, { 0|1, 0 }, { 4|2|0, 2 }, { -1, -1 } },// 'c'  'g'
      { { 2|0, 0 }, { 0|0, 4 }, { 2|0, 2 }, { -1, -1 } },  // 'b'  'h'
      { { 0|0, 0 }, { 0|1, 0 }, { -1, -1 } },              // 'c'  'i'
      { { 0|0, 0 }, { 0|1, 0 }, { -1, -1 } },              // 'c'  'j'
      { { 0|0, 0 }, { 0|1, 0 }, { -1, -1 } },              // 'c'  'k'
      { { 0|0, 0 }, { 0|1, 0 }, { -1, -1 } },              // 'c'  'l'
      { { 0|0, 0 }, { 0|1, 0 }, { -1, -1 } },              // 'c'  'm'
      { { 0|0, 0 }, { 0|1, 0 }, { -1, -1 } },              // 'c'  'n'
      { { 0|0, 0 }, { 0|1, 0 }, { -1, -1 } },              // 'c'  'o'
      { { 0|0, 0 }, { 0|1, 0 }, { -1, -1 } },              // 'c'  'p'
      { { 0|0, 0 }, { 0|1, 0 }, { -1, -1 } },              // 'c'  'q'
      { { 0|0, 0 }, { 0|1, 0 }, { -1, -1 } },              // 'c'  'r'
      { { 0|0, 0 }, { 0|1, 0 }, { -1, -1 } },              // 'c'  's'
      { { 0|0, 0 }, { 0|1, 0 }, { -1, -1 } },              // 'c'  't'
      { { 0|0, 0 }, { 0|1, 0 }, { -1, -1 } },              // 'c'  'u'
      { { 0|0, 0 }, { 0|1, 0 }, { -1, -1 } },              // 'c'  'v'
      { { 0|0, 0 }, { 0|1, 0 }, { -1, -1 } },              // 'c'  'w'
      { { 0|0, 0 }, { 0|1, 0 }, { -1, -1 } },              // 'c'  'x'
      { { 0|0, 0 }, { 0|1, 0 }, { -1, -1 } },              // 'c'  'y'
      { { 0|0, 0 }, { 0|1, 0 }, { -1, -1 } },              // 'c'  'z'
    };

    int ch = 'a' + ((character.value() * 26) >> 16);
    int idx = ch - 'a';
    for (int i = 0; i < 5; i++)
    {
      int flags = characters[idx][i].flags;
      int index = characters[idx][i].index;
      if (flags == -1)
        break;
      drawCurve(p, applyFlags(flags, pnts[index], cx, cy), penWidth);
    }
  }

  std::vector<vec2f> applyFlags(int flags, std::vector<vec2f>& pnts, float cx, float cy)
  {
    std::vector<vec2f> out = pnts;
    if ( flags & 1 )
    {
      // Flip/mirror vertically
      for (vec2f& pt : out)
      {
        pt.y = 2*cy - pt.y;
      }
    }
    if ( flags & 2 )
    {
      // Flip/mirror horizontally
      for (vec2f& pt : out)
      {
        pt.x = 2*cx - pt.x;
      }
    }
    return out;
  }

  void drawCurve(Painter& p, const std::vector<vec2f>& pnts, int penWidth)
  {
    float t = (tension.value() - (1<<15)) / float(1<<15);
    float b = (bias.value() - (1<<15)) / float(1<<15);
    float c = (continuity.value() - (1<<15)) / float(1<<15);
    for (int i = 0; i < 100; i++)
    {
      vec2f kochanekBartelsSpline(const std::vector<vec2f>& a_points, float t, float a_tension, float a_bias, float a_continuity);
      vec2f p1 = kochanekBartelsSpline(pnts, (i-0.5f) * 0.01f, t, b, c);
      vec2f p2 = kochanekBartelsSpline(pnts, (i+0.5f) * 0.01f, t, b, c);
      p.drawLine(int(p1.x), int(p1.y), int(p2.x), int(p2.y));
      p.drawLine(int(p1.x) + penWidth, int(p1.y) - 3, int(p2.x) + penWidth, int(p2.y) - 3);
    }
  }

private:
  //bool trackingMouse = false;
  //int tx = 0, ty = 0, tz = -120;
  //int rx = 0, ry = 0, rz = 0;
  //int lastX = -1, lastY = -1;
};


void fontEditTest()
{
  Application app;
  FontEditWindow testWin(0, "Test Window");
  testWin.setNewSize(800, 600);
  app.exec();
  exit(0);
}