#include "vde/foundation/io_gltf.h"
#include "vde/core/aabb.h"
#include "vde/curves/tessellation.h"
#include <fstream>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <sstream>
#include <iomanip>

namespace vde::foundation {

// ── Helpers ──────────────────────────────────────────────────────────

static std::string vec3_json(double x, double y, double z) {
    std::ostringstream ss;
    ss << std::fixed << "[" << x << "," << y << "," << z << "]";
    return ss.str();
}

static void compute_normals(const mesh::HalfedgeMesh& mesh,
                            std::vector<float>& normals) {
    normals.resize(mesh.num_vertices() * 3, 0.0f);
    // For each face, compute face normal and accumulate to vertices
    for (size_t fi = 0; fi < mesh.num_faces(); ++fi) {
        auto vis = mesh.face_vertices(static_cast<int>(fi));
        if (vis.size() < 3) continue;
        const auto& v0 = mesh.vertex(vis[0]);
        const auto& v1 = mesh.vertex(vis[1]);
        const auto& v2 = mesh.vertex(vis[2]);
        // Cross product for face normal
        float nx = static_cast<float>((v1.y() - v0.y()) * (v2.z() - v0.z()) -
                                      (v1.z() - v0.z()) * (v2.y() - v0.y()));
        float ny = static_cast<float>((v1.z() - v0.z()) * (v2.x() - v0.x()) -
                                      (v1.x() - v0.x()) * (v2.z() - v0.z()));
        float nz = static_cast<float>((v1.x() - v0.x()) * (v2.y() - v0.y()) -
                                      (v1.y() - v0.y()) * (v2.x() - v0.x()));
        for (size_t j = 0; j < 3 && j < vis.size(); ++j) {
            normals[vis[j] * 3 + 0] += nx;
            normals[vis[j] * 3 + 1] += ny;
            normals[vis[j] * 3 + 2] += nz;
        }
    }
    // Normalize
    for (size_t i = 0; i < mesh.num_vertices(); ++i) {
        float len = std::sqrt(normals[i * 3] * normals[i * 3] +
                              normals[i * 3 + 1] * normals[i * 3 + 1] +
                              normals[i * 3 + 2] * normals[i * 3 + 2]);
        if (len > 1e-10f) {
            normals[i * 3] /= len;
            normals[i * 3 + 1] /= len;
            normals[i * 3 + 2] /= len;
        }
    }
}

static void write_glb_header(std::ostream& out, uint32_t total_length) {
    uint32_t magic = 0x46546C67;  // "glTF"
    uint32_t version = 2;
    out.write(reinterpret_cast<const char*>(&magic), 4);
    out.write(reinterpret_cast<const char*>(&version), 4);
    out.write(reinterpret_cast<const char*>(&total_length), 4);
}

static void write_glb_chunk(std::ostream& out, uint32_t chunk_type,
                            const std::string& data, uint32_t unpadded_len) {
    out.write(reinterpret_cast<const char*>(&unpadded_len), 4);
    out.write(reinterpret_cast<const char*>(&chunk_type), 4);
    out.write(data.data(), static_cast<std::streamsize>(data.size()));
}

// ── GLB binary buffer layout ─────────────────────────────────────────

struct GlbBufferLayout {
    size_t positions_offset = 0;
    size_t positions_byte_len = 0;
    size_t normals_offset = 0;
    size_t normals_byte_len = 0;
    size_t indices_offset = 0;
    size_t indices_byte_len = 0;
    size_t total_bin_len = 0;
};

static GlbBufferLayout compute_layout(const mesh::HalfedgeMesh& mesh,
                                       const GltfOptions& options) {
    GlbBufferLayout layout;
    size_t nv = mesh.num_vertices();
    size_t nf = mesh.num_faces();
    size_t index_count = nf * 3;

    layout.positions_offset = 0;
    layout.positions_byte_len = nv * 12;  // 3 floats * 4 bytes

    layout.normals_offset = layout.positions_byte_len;
    layout.normals_byte_len = options.include_normals ? nv * 12 : 0;

    layout.indices_offset = layout.normals_offset + layout.normals_byte_len;
    layout.indices_byte_len = index_count * 4;  // uint32 per index

    layout.total_bin_len = layout.indices_offset + layout.indices_byte_len;
    return layout;
}

static std::string generate_json(const mesh::HalfedgeMesh& mesh,
                                  const GltfOptions& options,
                                  const GlbBufferLayout& layout,
                                  const std::string& bin_uri = "") {
    size_t nv = mesh.num_vertices();
    size_t nf = mesh.num_faces();
    size_t index_count = nf * 3;
    core::AABB3D bounds = mesh.bounds();

    std::ostringstream ss;
    ss << std::fixed << std::setprecision(6);
    ss << "{\n";
    ss << "  \"asset\":{\"version\":\"2.0\",\"generator\":\"ViewDesignEngine\"},\n";
    ss << "  \"scene\":0,\n";
    ss << "  \"scenes\":[{\"nodes\":[0]}],\n";
    ss << "  \"nodes\":[{\"mesh\":0}],\n";

    // Mesh primitive
    ss << "  \"meshes\":[{\"primitives\":[{\"attributes\":{";
    ss << "\"POSITION\":0";
    if (options.include_normals) ss << ",\"NORMAL\":1";
    ss << "},\"indices\":" << (options.include_normals ? 2 : 1) << "}]}],\n";

    // Buffer
    ss << "  \"buffers\":[{";
    if (!bin_uri.empty()) ss << "\"uri\":\"" << bin_uri << "\",";
    ss << "\"byteLength\":" << layout.total_bin_len << "}],\n";

    // Buffer views
    ss << "  \"bufferViews\":[\n";
    ss << "    {\"buffer\":0,\"byteOffset\":" << layout.positions_offset
       << ",\"byteLength\":" << layout.positions_byte_len
       << ",\"target\":34962},\n";
    if (options.include_normals) {
        ss << "    {\"buffer\":0,\"byteOffset\":" << layout.normals_offset
           << ",\"byteLength\":" << layout.normals_byte_len
           << ",\"target\":34962},\n";
    }
    ss << "    {\"buffer\":0,\"byteOffset\":" << layout.indices_offset
       << ",\"byteLength\":" << layout.indices_byte_len
       << ",\"target\":34963}\n";
    ss << "  ],\n";

    // Accessors
    ss << "  \"accessors\":[\n";
    ss << "    {\"bufferView\":0,\"componentType\":5126,\"count\":" << nv
       << ",\"type\":\"VEC3\",\"max\":"
       << vec3_json(bounds.max().x(), bounds.max().y(), bounds.max().z())
       << ",\"min\":"
       << vec3_json(bounds.min().x(), bounds.min().y(), bounds.min().z())
       << "},\n";
    int acc_index = 1;
    if (options.include_normals) {
        ss << "    {\"bufferView\":1,\"componentType\":5126,\"count\":" << nv
           << ",\"type\":\"VEC3\"},\n";
        acc_index = 2;
    }
    ss << "    {\"bufferView\":" << (options.include_normals ? 2 : 1)
       << ",\"componentType\":5125,\"count\":" << index_count
       << ",\"type\":\"SCALAR\"}\n";
    ss << "  ]\n";
    ss << "}";

    return ss.str();
}

// ── Write binary data ─────────────────────────────────────────────────

static void write_binary_data(std::ostream& bin,
                               const mesh::HalfedgeMesh& mesh,
                               const GltfOptions& options,
                               const GlbBufferLayout& layout) {
    size_t nv = mesh.num_vertices();
    size_t nf = mesh.num_faces();

    // Positions
    for (size_t i = 0; i < nv; ++i) {
        const auto& v = mesh.vertex(i);
        float fx = static_cast<float>(v.x());
        float fy = static_cast<float>(v.y());
        float fz = static_cast<float>(v.z());
        bin.write(reinterpret_cast<const char*>(&fx), 4);
        bin.write(reinterpret_cast<const char*>(&fy), 4);
        bin.write(reinterpret_cast<const char*>(&fz), 4);
    }

    // Normals
    if (options.include_normals) {
        std::vector<float> normals;
        compute_normals(mesh, normals);
        bin.write(reinterpret_cast<const char*>(normals.data()),
                  static_cast<std::streamsize>(normals.size() * sizeof(float)));
    }

    // Indices
    for (size_t i = 0; i < nf; ++i) {
        auto vis = mesh.face_vertices(static_cast<int>(i));
        for (size_t j = 0; j < std::min(vis.size(), size_t(3)); ++j) {
            uint32_t idx = static_cast<uint32_t>(vis[j]);
            bin.write(reinterpret_cast<const char*>(&idx), 4);
        }
    }
}

// ── Public API ────────────────────────────────────────────────────────

bool write_gltf(const std::string& filepath, const mesh::HalfedgeMesh& mesh,
                const GltfOptions& options) {
    if (mesh.num_vertices() == 0 || mesh.num_faces() == 0) return false;

    auto layout = compute_layout(mesh, options);

    if (options.binary) {
        std::string json = generate_json(mesh, options, layout);
        // ── GLB format ──
        uint32_t json_unpadded_len = static_cast<uint32_t>(json.size());

        // Pad JSON chunk to 4-byte alignment with spaces
        std::string json_padded = json;
        while (json_padded.size() % 4 != 0) json_padded += ' ';
        uint32_t json_padded_len = static_cast<uint32_t>(json_padded.size());

        // Serialize binary data
        std::string bin_data;
        uint32_t bin_unpadded_len = static_cast<uint32_t>(layout.total_bin_len);
        if (layout.total_bin_len > 0) {
            std::ostringstream bin_stream(std::ios::binary);
            write_binary_data(bin_stream, mesh, options, layout);
            bin_data = bin_stream.str();
            while (bin_data.size() % 4 != 0) bin_data.push_back('\0');
        }

        // Total = header(12) + json_chunk_header(8) + json_padded + [bin_chunk_header(8) + bin_padded]
        uint32_t total = 12 + 8 + json_padded_len;
        if (!bin_data.empty()) total += 8 + static_cast<uint32_t>(bin_data.size());

        std::ofstream file(filepath, std::ios::binary);
        if (!file) return false;

        write_glb_header(file, total);
        write_glb_chunk(file, 0x4E4F534A, json_padded, json_unpadded_len);  // "JSON"
        if (!bin_data.empty()) {
            write_glb_chunk(file, 0x004E4942, bin_data, bin_unpadded_len);  // "BIN\0"
        }
        return true;
    } else {
        // ── glTF JSON + separate .bin ──
        // Determine bin filename from output path
        std::string dot = ".";
        size_t dot_pos = filepath.rfind(dot);
        std::string binpath;
        std::string bin_basename;
        if (dot_pos != std::string::npos) {
            binpath = filepath.substr(0, dot_pos) + ".bin";
            // Extract just the filename
            size_t slash_pos = binpath.rfind('/');
            bin_basename = (slash_pos != std::string::npos)
                ? binpath.substr(slash_pos + 1) : binpath;
        } else {
            binpath = filepath + ".bin";
            bin_basename = binpath;
        }

        std::string json = generate_json(mesh, options, layout, bin_basename);

        std::ofstream file(filepath);
        if (!file) return false;
        file << json;

        std::ofstream bin(binpath, std::ios::binary);
        if (!bin) return false;
        write_binary_data(bin, mesh, options, layout);
        return true;
    }
}

bool write_brep_gltf(const std::string& filepath, const brep::BrepModel& model,
                     int tessellation_res) {
    if (model.num_faces() == 0) return false;

    // Collect all vertices and triangles from tessellated faces
    std::vector<core::Point3D> all_verts;
    std::vector<std::array<int, 3>> all_tris;

    for (size_t fi = 0; fi < model.num_faces(); ++fi) {
        const auto& face = model.face(static_cast<int>(fi));
        if (face.loops.empty()) continue;

        // Get the surface for this face
        int surf_id = face.surface_id;
        if (surf_id < 0 || surf_id >= static_cast<int>(model.num_surfaces()))
            continue;

        const auto& surf = model.surface(surf_id);

        // Inline tessellation: sample surface uniformly, create quad mesh
        int res = std::max(4, tessellation_res);
        std::vector<core::Point3D> verts;
        std::vector<std::array<int, 3>> tris;

        auto [u_min, u_max] = surf.domain_u();
        auto [v_min, v_max] = surf.domain_v();

        for (int j = 0; j <= res; ++j) {
            double v = v_min + (v_max - v_min) * static_cast<double>(j) / res;
            for (int i = 0; i <= res; ++i) {
                double u = u_min + (u_max - u_min) * static_cast<double>(i) / res;
                verts.push_back(surf.evaluate(u, v));
            }
        }

        for (int j = 0; j < res; ++j) {
            for (int i = 0; i < res; ++i) {
                int a = j * (res + 1) + i;
                int b = a + 1;
                int c = a + (res + 1);
                int d = c + 1;
                tris.push_back({a, b, d});
                tris.push_back({a, d, c});
            }
        }

        // Offset indices
        int base = static_cast<int>(all_verts.size());
        for (const auto& v : verts) all_verts.push_back(v);
        for (const auto& t : tris) {
            all_tris.push_back({t[0] + base, t[1] + base, t[2] + base});
        }
    }

    if (all_verts.empty() || all_tris.empty()) return false;

    // Build HalfedgeMesh from tessellated data
    mesh::HalfedgeMesh mesh;
    mesh.build_from_triangles(all_verts, all_tris);

    // Export as GLB
    GltfOptions opt;
    opt.binary = true;
    opt.include_normals = true;
    return write_gltf(filepath, mesh, opt);
}

}  // namespace vde::foundation