#pragma once

#include <stdint.h>
#include <algorithm>

#include "../datatypes.cpp"
#include "../helpers.cpp"
#include "../buffer.cpp"
#include "../shader.cpp"

namespace UwU {
  // trapezoid (horizontally constrained)
  class Trapezoid {
    public:
      Trapezoid(uint16_t y0, uint16_t y1, uint16_t xl0, uint16_t xl1, uint16_t xr0, uint16_t xr1) {
        this->y0 = y0;
        this->y1 = y1;
        this->xl0 = xl0;
        this->xl1 = xl1;
        this->xr0 = xr0;
        this->xr1 = xr1;
      }
      Trapezoid() {}
      uint16_t y0;
      uint16_t y1;
      uint16_t xl0;
      uint16_t xl1;
      uint16_t xr0;
      uint16_t xr1;
      
      // Draw a horizontally bounded trapezoid
      // y1 >= y0
      void draw (Buffer buffer, Shader shader) {
        uint16_t height = 1 + y1 - y0;
        int16_t LeftBound[height];
        int16_t RightBound[height];
        
        Helpers::bresenham(0, xl0, y1 - y0, xl1, LeftBound);
        Helpers::bresenham(0, xr0, y1 - y0, xr1, RightBound);
        
        if (shader.shaderType == COLOR) {
          for (uint16_t i = 0; i < height; i++) {
            for (uint16_t x = LeftBound[i]; x <= RightBound[i]; x++) {
              buffer.drawPixel(x, i + y0, shader.c0);
            }
          }
          return;

        } else if (shader.shaderType == HGRADIENT) {
          // find left-right boundaries
          uint16_t leftmost = std::min(xl0, xl1);
          uint16_t rightmost = std::max(xr0, xr1);

          // precompute gradient LUT
          Color cols[rightmost - leftmost];
          for (uint16_t x = leftmost; x < rightmost; x++) {
            cols[x - leftmost] = ShaderMethods::gradient(shader.u0, shader.scale, shader.c0, shader.c1, x);
          }

          for (uint16_t i = 0; i < height; i++) {
            for (uint16_t x = LeftBound[i]; x <= RightBound[i]; x++) {
              buffer.drawPixel(x, i + y0, cols[x - leftmost]);
            }
          }
          return;

        } else if (shader.shaderType == VGRADIENT) {
          Color c;
          for (uint16_t i = 0; i < height; i++) {
            c = ShaderMethods::gradient(shader.v0, shader.scale, shader.c0, shader.c1, i + y0);
            for (uint16_t x = LeftBound[i]; x <= RightBound[i]; x++) {
              buffer.drawPixel(x, i + y0, c);
            }
          }
          return;

        } else if (shader.shaderType == BUFFER) {
          for (uint16_t i = 0; i < height; i++) {
            for (uint16_t x = LeftBound[i]; x <= RightBound[i]; x++) {
              buffer.drawPixel(x, i + y0, ShaderMethods::buffer(shader.u0, shader.v0, shader.buffer, x, i + y0));
            }
          }
          return;
        }
        return;
      }
  };
}