/* Example program that links against the waymini library.
 * No external dependencies beyond waymini itself and the C standard library.
 */

#include "waymini.h"

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "datatypes.cpp"
#include "helpers.cpp"
// #include "triangle.cpp"

// this should be handled elsewhere, eventually, maybe, probably
static void on_key(void *user, uint32_t keycode, uint32_t state) {
  (void)user;
  const char *label = state ? "down" : "up  ";
  printf("key %s: %u\n", label, keycode);
  fflush(stdout);
}

namespace UwU {

  class Draw {
    private:

      uint8_t *pixels;

      void putPixel(uint32_t x, uint32_t y, uint8_t r, uint8_t g, uint8_t b, uint8_t a = 0xff) {
          size_t i = (size_t)y * waymini_get_stride(wm) + (size_t)x * 4;
          uint8_t b0 = pixels[i + 0];
          uint8_t g0 = pixels[i + 1];
          uint8_t r0 = pixels[i + 2];
          b = Helpers::lerp8(b0, b, a);
          g = Helpers::lerp8(g0, g, a);
          r = Helpers::lerp8(r0, r, a);
          pixels[i + 0] = b;    // B
          pixels[i + 1] = g;    // G
          pixels[i + 2] = r;    // R
          pixels[i + 3] = 0xff; // A
      }

      // plot lines if m <= 1
      void lineLow(int32_t x0, int32_t y0, int32_t x1, int32_t y1, Color color) {
        int32_t dx = x1 - x0;
        int32_t dy = y1 - y0;
        int32_t yi = 1;
        if (dy < 0) {
          yi = -1;
          dy = -dy;
        }
        int32_t d = (2 * dy) - dx;
        int32_t y = y0;
        for (int32_t x = x0; x < x1; x++) {
          putPixel(x, y, color.r, color.g, color.b, color.a);
          if (d > 0) {
            y += yi;
            d += (2 * (dy - dx));
          } else {
            d += (2 * dy);
          }
        }
        return;
      }

      // plot lines if m >1
      void lineHigh(int32_t x0, int32_t y0, int32_t x1, int32_t y1, Color color) {
        int32_t dx = x1 - x0;
        int32_t dy = y1 - y0;
        int32_t xi = 1;
        if (dx < 0) {
          xi = -1;
          dx = -dx;
        }
        int32_t d = (2 * dx) - dy;
        int32_t x = x0;
        for (int32_t y = y0; y < y1; y++) {
          putPixel(x, y, color.r, color.g, color.b, color.a);
          if (d > 0) {
            x += xi;
            d += (2 * (dx - dy));
          } else {
            d += (2 * dx);
          }
        }
        return;
      }
    
    public:

      
      Draw(uint32_t width, uint32_t height, waymini_key_cb on_key) {
        this->wm = waymini_create(width, height, on_key, NULL);
        if (!this->wm) exit(1);
        
        // this->width = waymini_get_width(this->wm);
        // this->height = waymini_get_height(this->wm);
        // this->stride = waymini_get_stride(this->wm);
        printf("surface: %ux%u stride=%u\n", waymini_get_width(this->wm), waymini_get_height(this->wm), waymini_get_stride(this->wm));
        
        this->pixels = (uint8_t *)waymini_get_pixels(this->wm);
        if (!this->pixels) {
          waymini_destroy(this->wm);
          exit(1);
        }
      }

      struct waymini* wm;

      uint32_t getWidth() {
        return waymini_get_width(wm);
      }

      uint32_t getHeight() {
        return waymini_get_height(wm);
      }

      uint32_t getStride() {
        return waymini_get_stride(wm);
      }

      void present() {
        waymini_present(wm);
        return;
      }

      void destroy() {
        waymini_destroy(wm);
        return;
      }
      
      // Draw a rectangle (duh)
      void rectangle(Coord2 point0, Coord2 point1, Color color) {
        if (point0.x > getWidth() || point0.y > getHeight() || point1.x > getWidth() || point1.y > getHeight()) {return;};
        for (uint32_t y = point0.y; y < point1.y; y++) {
          for (uint32_t x = point0.x; x < point1.x; x++) {
            putPixel(x, y, color.r, color.g, color.b, color.a);
          }
        }
        return;
      }

      // Draws a rectangle with a 4-point color gradient
      void rectangleGradient(Coord2 point0, Coord2 point1, Color colorUL, Color colorUR, Color colorLL, Color colorLR) {
        // convert to int32_t and ensure x1>x0 && y1>y0
        int32_t x0, y0, x1, y1;
        if (point0.x > point1.x) {
          x0 = (int32_t)point1.x;
          x1 = (int32_t)point0.x;
        } else {
          x0 = (int32_t)point0.x;
          x1 = (int32_t)point1.x;
        }
        if (point0.y > point1.y) {
          y0 = (int32_t)point1.y;
          y1 = (int32_t)point0.y;
        } else {
          y0 = (int32_t)point0.y;
          y1 = (int32_t)point1.y;
        }

        // setup gradient coefficient arrays
        int32_t w = x1 - x0 + 1;
        int32_t h = y1 - y0 + 1;
        int16_t xGrad[w];
        int16_t yGrad[h];

        // calculate gradient coefficients
        Helpers::bresenham(0, 0, w - 1, 255, xGrad);
        Helpers::bresenham(0, 0, h - 1, 255, yGrad);

        // for each point calculate, alpha blend and print color
        Color Lmix = Color();
        Color Rmix = Color();
        Color Xmix = Color();
        for (int32_t y = y0; y <= y1; y++) {
          Lmix = Helpers::lerpColor(colorUL, colorLL, (uint8_t)yGrad[y - y0]);
          Rmix = Helpers::lerpColor(colorUR, colorLR, (uint8_t)yGrad[y - y0]);
          for (int32_t x = x0; x <= x1; x++) {
            Xmix = Helpers::lerpColor(Lmix, Rmix, (uint8_t)xGrad[x - x0]);
            putPixel(x, y, Xmix.r, Xmix.g, Xmix.b, Xmix.a);
          }
        }
        return;
      }
      
      // Fill a simple gradient. Each row is stride bytes.
      void rainbow() {
        for (uint32_t y = 0; y < getHeight(); y++) {
          for (uint32_t x = 0; x < getWidth(); x++) {
            size_t i = (size_t)y * getStride() + (size_t)x * 4;
            pixels[i + 0] = (uint8_t)(y * 255 / getHeight());  // B
            pixels[i + 1] = 0x00;                               // G
            pixels[i + 2] = (uint8_t)(x * 255 / getWidth());   // R
            pixels[i + 3] = 0xFF;                               // A
          }
        }
      }

      // Draw a single point
      void point (Coord2 point, Color color) {
        if (point.x > getWidth() || point.y > getHeight()) {return;};
        putPixel(point.x, point.y, color.r, color.g, color.b, color.a);
      }

      // Uses Bresenham's line algorithm to draw line of any slope
      void line (Coord2 point0, Coord2 point1, Color color) {
        if (point0.x > getWidth() || point0.y > getHeight() || point1.x > getWidth() || point1.y > getHeight()) {return;};
        int32_t x0 = (int32_t)point0.x;
        int32_t y0 = (int32_t)point0.y;
        int32_t x1 = (int32_t)point1.x;
        int32_t y1 = (int32_t)point1.y;
        if (abs(y1 - y0) < abs(x1 - x0)) {
          if (x0 > x1) {
            lineLow(x1, y1, x0, y0, color);
          } else {
            lineLow(x0, y0, x1, y1, color);
          }
        } else {
          if (y0 > y1) {
            lineHigh(x1, y1, x0, y0, color);
          } else {
            lineHigh(x0, y0, x1, y1, color);
          }
        }
      }

      // Draw a horizontally bounded trapezoid
      // coords.y1 >= coords.y0
      // todo move to private and add public checks
      void trapezoid (Trapezoid coords, Color color) {
        printf("(%u, %u, %u, %u, %u, %u)", coords.y0, coords.y1, coords.xl0, coords.xl1, coords.xr0, coords.xr1);
        uint16_t height = 1 + coords.y1 - coords.y0;
        int16_t LeftBound[height];
        int16_t RightBound[height];
  
        Helpers::bresenham(0, coords.xl0, coords.y1 - coords.y0, coords.xl1, LeftBound);
        Helpers::bresenham(0, coords.xr0, coords.y1 - coords.y0, coords.xr1, RightBound);
  
        printf("leftbound\n");
        for (uint16_t i = 0; i < height; i++) {
          printf("(%u, %u)\n", i, LeftBound[i]);
        }
        printf("rightbound\n");
        for (uint16_t i = 0; i < height; i++) {
          printf("(%u, %u)\n", i, RightBound[i]);
        }

        for (uint16_t i = 0; i < height; i++) {
          for (uint16_t x = LeftBound[i]; x <= RightBound[i]; x++) {
            // printf("(%u, %u)", x, i + coords.y0);
            putPixel((uint32_t)x, (uint32_t)i + coords.y0, color.r, color.g, color.b, color.a);
          }
        }
        return;
      }

      // Draw a triangle
      void triangle (Triangle coords, Color color) {
        Coord2 top = Coord2();
        Coord2 mid = Coord2();
        Coord2 btm = Coord2();
        // cases: flat top, flat bottom, left point, right point
        if (coords.y0 < coords.y1 && coords.y0 < coords.y2) {
          top.x = coords.x0;
          top.y = coords.y0;
          if (coords.y1 < coords.y2) {
            mid.x = coords.x1;
            mid.y = coords.y1;
            btm.x = coords.x2;
            btm.y = coords.y2;
          } else {
            mid.x = coords.x2;
            mid.y = coords.y2;
            btm.x = coords.x1;
            btm.y = coords.y1;
          }
        } else if (coords.y1 < coords.y0 && coords.y1 < coords.y2) {
          top.x = coords.x1;
          top.y = coords.y1;
          if (coords.y0 < coords.y2) {
            mid.x = coords.x0;
            mid.y = coords.y0;
            btm.x = coords.x2;
            btm.y = coords.y2;
          } else {
            mid.x = coords.x2;
            mid.y = coords.y2;
            btm.x = coords.x0;
            btm.y = coords.y0;
          }
        } else {
          top.x = coords.x2;
          top.y = coords.y2;
          if (coords.y0 < coords.y1) {
            mid.x = coords.x0;
            mid.y = coords.y0;
            btm.x = coords.x1;
            btm.y = coords.y1;
          } else {
            mid.x = coords.x1;
            mid.y = coords.y1;
            btm.x = coords.x0;
            btm.y = coords.y0;
          }
        }

        uint16_t height = 1 + btm.y - top.y;
        int16_t longBound[height];
        int16_t splitBound[height];
        // int16_t rightBound[height];
        Helpers::bresenham(0, top.x, height - 1, btm.x, longBound);
        if ((int16_t)mid.x < longBound[mid.y - top.y]) {
          // left-handed triangle
          // rightBound = longBound;
          Helpers::bresenham(0, top.x, mid.y - top.y, mid.x, splitBound);
          Helpers::bresenham(mid.y - top.y, mid.x, height - 1, btm.x, splitBound);
          for (uint32_t i = 0; i < height; i++) {
            for (uint32_t x = (uint32_t)splitBound[i]; x <= (uint32_t)longBound[i]; x++) {
              putPixel(x, i + (uint32_t)top.y, color.r, color.g, color.b, color.a);
            }
          }
        } else {
          // right-handed triangle
          // leftBound = longBound;
          Helpers::bresenham(0, top.x, mid.y - top.y, mid.x, splitBound);
          Helpers::bresenham(mid.y - top.y, mid.x, height - 1, btm.x, splitBound);
          for (uint32_t i = 0; i < height; i++) {
            for (uint32_t x = (uint32_t)longBound[i]; x <= (uint32_t)splitBound[i]; x++) {
              putPixel(x, i + (uint32_t)top.y, color.r, color.g, color.b, color.a);
            }
          }
        }



        // // handle case where top or bottom is flat
        // if (mid.y == top.y) {
        //   // flat top
        //   if (mid.x < top.x) {
        //     trapezoid(Trapezoid(top.y, btm.y, mid.x, btm.x, top.x, btm.x), color);
        //     return;
        //   } else {
        //     trapezoid(Trapezoid(top.y, btm.y, top.x, btm.x, mid.x, btm.x), color);
        //     return;
        //   }
        // } else if (mid.y == btm.y) {
        //   // flat bottom
        //   if (mid.x < btm.x) {
        //     trapezoid(Trapezoid(top.y, btm.y, top.x, mid.x, top.x, btm.x), color);
        //     return;
        //   } else {
        //     trapezoid(Trapezoid(top.y, btm.y, top.x, btm.x, top.x, mid.x), color);
        //     return;
        //   }
        // }

        // // calculate midpoint of straight line
        // int32_t dy = (int32_t)btm.y - (int32_t)top.y;
        // if (dy == 0) {
        //   return; // shouldn't be possible, should be detected earlier
        // }
        // int32_t dx = (int32_t)btm.x - (int32_t)top.x;
        // dx *= (mid.y - top.y);
        // dx /= dy;
        // dx += top.x;
        // uint16_t oppx = (uint16_t)dx;

        // // split triangle into two trapezoids
        // if (mid.x < oppx) {
        //   trapezoid(Trapezoid(top.y, mid.y, top.x, mid.x, top.x, oppx), color);
        //   trapezoid(Trapezoid(mid.y, btm.y, mid.x, btm.x, oppx, btm.x), color);
        //   return;
        // } else {
        //   trapezoid(Trapezoid(top.y, mid.y, top.x, oppx, top.x, mid.x), color);
        //   trapezoid(Trapezoid(mid.y, btm.y, oppx, btm.x, mid.x, btm.x), color);
        //   return;
        // }
        return;
      }
    };
  }

int main(void) {
  uint32_t w = 800, h = 480;
  UwU::Color fuchsia = UwU::Color(0xb00b6940);
  UwU::Color red = UwU::Color(0xff0000ff);
  UwU::Color green = UwU::Color(0x00ff00ff);
  UwU::Color blue = UwU::Color(0x0000ffff);
  UwU::Color alpha = UwU::Color(0x00000000);
  printf("r: %u, g:%u, b:%u, a:%u\n", fuchsia.r, fuchsia.g, fuchsia.b, fuchsia.a);

  // struct waymini *wm = waymini_create(w, h, on_key, NULL);
  UwU::Draw draw = UwU::Draw(w, h, on_key);

  draw.rainbow();

  
  draw.rectangle(UwU::Coord2(69, 69), UwU::Coord2(420, 420), fuchsia);
  draw.rectangleGradient(UwU::Coord2(200, 200), UwU::Coord2(600, 400), red, blue, alpha, red);

  draw.trapezoid(UwU::Trapezoid(300, 400, 360, 380, 600, 400), green);
  draw.triangle(UwU::Triangle(200, 100, 240, 100, 320, 300), green);


  draw.point(UwU::Coord2(387, 43), green);
  draw.line(UwU::Coord2(300, 100), UwU::Coord2(250, 469), green);
  draw.line(UwU::Coord2(250, 100), UwU::Coord2(300, 469), green);
  draw.line(UwU::Coord2(300, 100), UwU::Coord2(469, 250), green);
  draw.line(UwU::Coord2(469, 100), UwU::Coord2(300, 250), green);
  draw.line(UwU::Coord2(100, 300), UwU::Coord2(250, 469), green);
  draw.line(UwU::Coord2(250, 300), UwU::Coord2(100, 469), green);
  draw.line(UwU::Coord2(100, 300), UwU::Coord2(469, 250), green);
  draw.line(UwU::Coord2(469, 300), UwU::Coord2(100, 250), green);
  draw.present();

  while (!waymini_should_close(draw.wm)) {
    if (waymini_dispatch(draw.wm) < 0) break;
  }

  draw.destroy();
  return 0;
}