/**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */

#include "plane.h"
#include "assert/assert.h"

mesh_t PLANE_MESH_SIMPLE;
meshvertex_t PLANE_MESH_SIMPLE_VERTICES[PLANE_VERTEX_COUNT];

errorret_t planeInit() {
  vec3 min = { 0.0f, 0.0f, 0.0f };
  vec3 max = { 1.0f, 0.0f, 1.0f };
  vec2 uvMin = { 0.0f, 0.0f };
  vec2 uvMax = { 1.0f, 1.0f };
  planeBuffer(
    PLANE_MESH_SIMPLE_VERTICES,
    PLANE_AXIS_XZ,
    min,
    max
    #if MESH_ENABLE_COLOR
      , COLOR_WHITE_4B
    #endif
    , uvMin,
    uvMax
  );
  errorChain(meshInit(
    &PLANE_MESH_SIMPLE,
    PLANE_PRIMITIVE_TYPE,
    PLANE_VERTEX_COUNT,
    PLANE_MESH_SIMPLE_VERTICES
  ));
  errorOk();
}

/* Helper macro to write one vertex. */
#if MESH_ENABLE_COLOR
  #define PLANE_VERT(i, px, py, pz, u, v) \
    vertices[i].color    = color; \
    vertices[i].pos[0]   = (px); \
    vertices[i].pos[1]   = (py); \
    vertices[i].pos[2]   = (pz); \
    vertices[i].uv[0]    = (u);  \
    vertices[i].uv[1]    = (v);
#else
  #define PLANE_VERT(i, px, py, pz, u, v) \
    vertices[i].pos[0]   = (px); \
    vertices[i].pos[1]   = (py); \
    vertices[i].pos[2]   = (pz); \
    vertices[i].uv[0]    = (u);  \
    vertices[i].uv[1]    = (v);
#endif

void planeBuffer(
  meshvertex_t *vertices,
  const planeaxis_t axis,
  const vec3 min,
  const vec3 max
  #if MESH_ENABLE_COLOR
    , const color_t color
  #endif
  , const vec2 uvMin,
  const vec2 uvMax
) {
  assertNotNull(vertices, "Vertices cannot be NULL");
  assertNotNull(min, "Min vector cannot be NULL");
  assertNotNull(max, "Max vector cannot be NULL");
  assertNotNull(uvMin, "uvMin cannot be NULL");
  assertNotNull(uvMax, "uvMax cannot be NULL");

  const float_t u0 = uvMin[0], u1 = uvMax[0];
  const float_t v0 = uvMin[1], v1 = uvMax[1];

  switch(axis) {
    case PLANE_AXIS_XY: {
      /* Flat in XY at z = min[2]; spans X and Y. */
      const float_t z = min[2];
      PLANE_VERT(0, min[0], min[1], z, u0, v0)
      PLANE_VERT(1, max[0], min[1], z, u1, v0)
      PLANE_VERT(2, max[0], max[1], z, u1, v1)
      PLANE_VERT(3, min[0], min[1], z, u0, v0)
      PLANE_VERT(4, max[0], max[1], z, u1, v1)
      PLANE_VERT(5, min[0], max[1], z, u0, v1)
      break;
    }

    case PLANE_AXIS_XZ: {
      /* Flat in XZ at y = min[1]; spans X and Z. */
      const float_t y = min[1];
      PLANE_VERT(0, min[0], y, min[2], u0, v0)
      PLANE_VERT(1, max[0], y, min[2], u1, v0)
      PLANE_VERT(2, max[0], y, max[2], u1, v1)
      PLANE_VERT(3, min[0], y, min[2], u0, v0)
      PLANE_VERT(4, max[0], y, max[2], u1, v1)
      PLANE_VERT(5, min[0], y, max[2], u0, v1)
      break;
    }

    case PLANE_AXIS_YZ: {
      /* Flat in YZ at x = min[0]; spans Y and Z. */
      const float_t x = min[0];
      PLANE_VERT(0, x, min[1], min[2], u0, v0)
      PLANE_VERT(1, x, max[1], min[2], u1, v0)
      PLANE_VERT(2, x, max[1], max[2], u1, v1)
      PLANE_VERT(3, x, min[1], min[2], u0, v0)
      PLANE_VERT(4, x, max[1], max[2], u1, v1)
      PLANE_VERT(5, x, min[1], max[2], u0, v1)
      break;
    }
  }

  #undef PLANE_VERT
}