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

#include "mesh.h"
#include "util/memory.h"
#include "assert/assert.h"
#include "util/math.h"

errorret_t meshInit(
  mesh_t *mesh,
  const meshprimitivetype_t primitiveType,
  const int32_t vertexCount,
  const meshvertex_t *vertices
) {
  assertNotNull(mesh, "Mesh cannot be NULL");
  assertNotNull(vertices, "Vertices cannot be NULL");
  assertTrue(vertexCount > 0, "Vertex count must be greater than 0");

  memoryZero(mesh, sizeof(mesh_t));
  
  errorChain(meshInitPlatform(mesh, primitiveType, vertexCount, vertices));
  errorOk();
}

errorret_t meshFlush(
  mesh_t *mesh,
  const int32_t vertexOffset,
  const int32_t vertexCount
) {
  #ifdef meshFlushPlatform
    assertNotNull(mesh, "Mesh cannot be NULL");
    assertTrue(vertexOffset >= 0, "Vertex offset must be non-negative.");
    assertTrue(
      vertexCount == -1 || vertexCount > 0, "Vertex count incorrect."
    );

    int32_t vertCount = meshGetVertexCount(mesh);
    assertTrue(
      vertexOffset < (vertCount - 1), "Need at least one vert to draw"
    );

    int32_t drawCount = vertexCount;
    if(vertexCount == -1) {
      drawCount = vertCount - vertexOffset;
    }

    errorChain(meshFlushPlatform(mesh, vertexOffset, vertexCount));
  #endif
  errorOk();
}

errorret_t meshDraw(
  const mesh_t *mesh,
  const int32_t vertexOffset,
  const int32_t vertexCount
) {
  assertNotNull(mesh, "Mesh cannot be NULL");
  assertTrue(vertexOffset >= 0, "Vertex offset must be non-negative");
  assertTrue(vertexCount == -1 || vertexCount > 0, "Incorrect vert count");

  int32_t vertDrawCount = vertexCount;
  if(vertexCount == -1) {
    const int32_t totalVertices = meshGetVertexCount(mesh);
    vertDrawCount = totalVertices - vertexOffset;
  }

  if(vertDrawCount == 0) {
    errorOk();
  }
  assertTrue(
    vertexOffset + vertDrawCount <= meshGetVertexCount(mesh),
    "Vertex offset and count must be within vertex count bounds"
  );

  errorChain(meshDrawPlatform(mesh, vertexOffset, vertDrawCount));
  errorOk();
}

void meshGetBounds(
  const mesh_t *mesh,
  vec3 outMin,
  vec3 outMax
) {
  assertNotNull(mesh, "Mesh cannot be NULL");
  assertNotNull(outMin, "Output min cannot be NULL");
  assertNotNull(outMax, "Output max cannot be NULL");
  
  for(int i = 0; i < 3; i++) {
    outMin[i] = FLT_MAX;
    outMax[i] = -FLT_MAX;
  }

  for(uint32_t i = 0; i < mesh->vertexCount; i++) {
    meshvertex_t vert = mesh->vertices[i];
    for(int j = 0; j < 3; j++) {
      outMin[j] = mathMin(outMin[j], vert.pos[j]);
      outMax[j] = mathMax(outMax[j], vert.pos[j]);
    }
  }
}

int32_t meshGetVertexCount(const mesh_t *mesh) {
  assertNotNull(mesh, "Mesh cannot be NULL");
  return meshGetVertexCountPlatform(mesh);
}

errorret_t meshDispose(mesh_t *mesh) {
  assertNotNull(mesh, "Mesh cannot be NULL");
  errorChain(meshDisposePlatform(mesh));
  memoryZero(mesh, sizeof(mesh_t));
  errorOk();
}