/* 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"
#include "buffer.cpp"
#include "surface.cpp"

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

namespace UwU {

  class Draw {
    private:
      class Surface surface;
      // 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 * surface.getStride() + (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);
          surface.buffer.drawPixel(Coord2((uint16_t)x, (uint16_t)y), color);
          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);
          surface.buffer.drawPixel(Coord2((uint16_t)x, (uint16_t)y), color);
          if (d > 0) {
            x += xi;
            d += (2 * (dx - dy));
          } else {
            d += (2 * dx);
          }
        }
        return;
      }
    
    public:

      
      Draw(uint16_t width, uint16_t height, waymini_key_cb onKey)
        : surface(width, height, onKey) {}

      bool shouldClose() {
        return surface.shouldClose();
      }

      void updateSize() {
        surface.updateSize();
        return;
      }

      uint16_t getWidth() {
        return surface.getWidth();
      }

      uint16_t getHeight() {
        return surface.getHeight();
      }

      uint16_t getStride() {
        return surface.getStride();
      }

      void present() {
        surface.present();
        return;
      }

      void destroy() {
        surface.destroy();
        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);
            surface.buffer.drawPixel(Coord2((uint16_t)x, (uint16_t)y), color);
          }
        }
        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);
            surface.buffer.drawPixel(Coord2((uint16_t)x, (uint16_t)y), Xmix);
          }
        }
        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++) {
            surface.buffer.drawPixel(Coord2((uint16_t)x, (uint16_t)y), Color(
              (uint8_t)(y * 255 / getHeight()),
              0x00,
              (uint8_t)(x * 255 / getWidth()),
              0xff));
            // 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);
        surface.buffer.drawPixel(point, color);
      }

      // 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);
            surface.buffer.drawPixel(Coord2(x, i + coords.y0), color);
          }
        }
        return;
      }

      // Draw a triangle
      void triangle (uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, Color color) {
        Triangle triangle = Triangle(x0, y0, x1, y1, x2, y2);
        triangle.draw(surface.buffer, color);
        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, onKey);

  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(280, 100, 240, 290, 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 (!draw.shouldClose()) {}

  draw.destroy();
  return 0;
}