// hmap/hmap.h - Hammer++ map library. One include gives you everything:
//   * the editable map model (brushes = BSP/CSG solids, mesh objects, entities, props)
//   * geometry helpers and primitives
//   * compile(): CSG + BSP collision tree + render batches (+ optional baked vertex lighting)
//   * the .hmap binary format (load/save, source and/or compiled data)
//   * FBX (binary 7.4) and OBJ export
//
// Conventions: right-handed, +Y up, forward = -Z. Triangles are CCW seen from the front.
// UVs use image space (v grows downwards). Euler angles are (pitch, yaw, roll) in degrees.
#pragma once
#include "hmath.h"

#include <cstdint>
#include <string>
#include <vector>

namespace hmap {

constexpr uint32_t kFormatVersion = 1;

struct Status {
    bool ok = true;
    std::string message;
    explicit operator bool() const { return ok; }
    static Status Ok() { return Status{}; }
    static Status Fail(std::string m) { Status s; s.ok = false; s.message = std::move(m); return s; }
};

// ------------------------------------------------------------------ flags
enum Contents : uint32_t {
    CONTENTS_SOLID = 1,    // blocks movement + light, clips other brushes' hidden faces
    CONTENTS_WATER = 2,    // volume, rendered, does not block
    CONTENTS_CLIP = 4,     // invisible collision
    CONTENTS_TRIGGER = 8,  // invisible, non-blocking volume
    CONTENTS_SKY = 16
};
enum ObjectFlags : uint32_t {
    OBJ_HIDDEN = 1,      // editor visibility only (still compiled)
    OBJ_NOCOLLIDE = 2    // meshes: do not collide / cast baked shadows
};
enum FaceFlags : uint32_t { FACE_NODRAW = 1 };

// ------------------------------------------------------------------ model
struct UVInfo {  // planar projection along the dominant normal axis
    Vec2 offset{0, 0};  // world units
    Vec2 scale{1, 1};   // 1 = one texture repeat per Material::tileSize
    float rotation = 0; // degrees
};

struct Material {
    std::string name;           // unique key, e.g. "dev/orange"
    std::string texture;        // path relative to the asset root, may be empty
    Vec2 tileSize{64, 64};      // world units per texture repeat
    Vec3 color{1, 1, 1};        // tint
    uint32_t flags = 0;
};

struct Face {  // one side of a brush
    Plane plane;
    int32_t material = 0;
    UVInfo uv;
    uint32_t flags = 0;
};

// A convex solid defined as the intersection of half-spaces (Hammer/Quake style).
struct Brush {
    uint32_t id = 0;
    uint32_t owner = 0;  // 0 = world, otherwise id of the brush entity that owns it
    uint32_t contents = CONTENTS_SOLID;
    uint32_t flags = 0;
    std::vector<Face> faces;
};

struct MeshPoly {  // convex polygon of a mesh object
    std::vector<uint32_t> idx;  // CCW from the front
    std::vector<Vec2> uv;       // empty = auto-project with `proj`
    int32_t material = 0;
    uint32_t smooth = 0;        // 0 = flat shaded; same non-zero id = smooth together
    UVInfo proj;
};

// Free-form polygon mesh ("detail" geometry): arbitrary topology, not part of the BSP tree.
struct MeshObject {
    uint32_t id = 0;
    uint32_t owner = 0;
    uint32_t flags = 0;
    std::string name;
    std::vector<Vec3> verts;
    std::vector<MeshPoly> polys;
};

struct KeyValue { std::string key, value; };

struct Entity {  // point entities and props; brush entities own brushes via Brush::owner
    uint32_t id = 0;
    uint32_t flags = 0;
    std::string classname;
    Vec3 origin;
    Vec3 angles;          // pitch, yaw, roll (deg)
    Vec3 scale{1, 1, 1};
    std::vector<KeyValue> props;

    const std::string* find(const std::string& key) const;
    std::string get(const std::string& key, const std::string& def = "") const;
    float getFloat(const std::string& key, float def) const;
    int getInt(const std::string& key, int def) const;
    bool getBool(const std::string& key, bool def) const;
    Vec3 getVec3(const std::string& key, const Vec3& def) const;
    Vec3 getColor(const std::string& key, const Vec3& def) const;  // "255 128 0" -> 0..1
    void set(const std::string& key, const std::string& value);
    void erase(const std::string& key);
    Mat34 transform() const;  // translate * rotate * scale
    Vec3 forward() const;
};

struct Settings {
    Vec3 ambient{0.16f, 0.18f, 0.22f};
    float gridSize = 16;
    float unitsPerMeter = 64;
};

struct Map {
    std::string name = "untitled";
    Settings settings;
    std::vector<Material> materials;
    std::vector<Brush> brushes;
    std::vector<MeshObject> meshes;
    std::vector<Entity> entities;
    uint32_t nextId = 1;

    uint32_t newId() { return nextId++; }
    int findMaterial(const std::string& name) const;
    int addMaterial(const std::string& name, const std::string& texture = "");  // dedupes by name
    Brush* findBrush(uint32_t id);
    MeshObject* findMesh(uint32_t id);
    Entity* findEntity(uint32_t id);
    const Brush* findBrush(uint32_t id) const;
    const MeshObject* findMesh(uint32_t id) const;
    const Entity* findEntity(uint32_t id) const;
};

// ------------------------------------------------------------------ geometry
using Polygon = std::vector<Vec3>;

struct BrushGeometry {
    std::vector<Polygon> polys;  // parallel to Brush::faces; empty polygon = redundant face
    AABB bounds;
    std::vector<Vec3> points;    // all polygon vertices
    bool valid = false;
};

BrushGeometry buildBrushGeometry(const Brush& b);
AABB brushBounds(const Brush& b);
AABB meshBounds(const MeshObject& m);
Vec3 polyNormal(const Polygon& p);

// Raycasts (direction need not be normalised; t is in units of d). Return nearest hit.
bool rayBrush(const Brush& b, const Vec3& o, const Vec3& d, float& t, int& face);
bool rayMesh(const MeshObject& m, const Vec3& o, const Vec3& d, float& t, int& poly);

// Texture mapping shared by the editor and the compiler.
void uvAxes(const Vec3& normal, const UVInfo& uv, Vec3& u, Vec3& v);
Vec2 computeUV(const Vec3& p, const Vec3& normal, const UVInfo& uv, const Vec2& tileSize);

// Brush edits
void translateBrush(Brush& b, const Vec3& t, bool lockTexture = true);
void transformBrush(Brush& b, const Mat34& m);
void transformMesh(MeshObject& m, const Mat34& xf);
std::vector<Brush> hollowBrush(const Brush& b, float thickness);
bool clipBrush(const Brush& b, const Plane& p, Brush* front, Brush* back);  // false if nothing valid
MeshObject brushToMesh(const Brush& b);

// Mesh edits
void flipMesh(MeshObject& m);
void noiseMesh(MeshObject& m, float amplitude, float frequency, uint32_t seed);
bool extrudePoly(MeshObject& m, int poly, float dist);
Status importOBJ(const std::string& path, Map& map, MeshObject& out);

// Brush primitives (axis-aligned bounds; cylinders/cones are vertical)
Brush makeBox(const Vec3& mn, const Vec3& mx, int material = 0);
Brush makeWedge(const Vec3& mn, const Vec3& mx, int material = 0);  // ramp rising towards +X
Brush makeCylinder(const Vec3& mn, const Vec3& mx, int segments, int material = 0);
Brush makeCone(const Vec3& mn, const Vec3& mx, int segments, int material = 0);
std::vector<Brush> makeStairs(const Vec3& mn, const Vec3& mx, int steps, int material = 0);  // rises towards +X

// Mesh primitives
MeshObject meshBox(const Vec3& mn, const Vec3& mx, int material = 0);
MeshObject meshCylinder(const Vec3& mn, const Vec3& mx, int segments, int material = 0);
MeshObject meshCone(const Vec3& mn, const Vec3& mx, int segments, int material = 0);
MeshObject meshSphere(const Vec3& mn, const Vec3& mx, int rings, int segments, int material = 0);
MeshObject meshTorus(const Vec3& mn, const Vec3& mx, int segments, int sides, int material = 0);
MeshObject meshGrid(const Vec3& mn, const Vec3& mx, int segX, int segZ, int material = 0);  // terrain patch

// Starter content (used by the editor's "New map" and by the sample tools)
void addDefaultMaterials(Map& map);  // dev/* materials; texture-less, tinted
Map makeDemoMap();                   // lit room with brushes, meshes, entities, a door and a trigger

// ------------------------------------------------------------------ lights
enum class LightType : uint8_t { Point = 0, Spot = 1, Sun = 2 };
struct Light {
    LightType type = LightType::Point;
    Vec3 pos;
    Vec3 dir{0, -1, 0};  // direction the light travels (spot + sun)
    Vec3 color{1, 1, 1};
    float intensity = 1;
    float radius = 512;
    float innerDeg = 25, outerDeg = 40;
    uint32_t entityId = 0;
};
// light / light_spot / light_environment entities -> Light list
std::vector<Light> collectLights(const Map& map);

// ------------------------------------------------------------------ compiled data
struct Vertex {
    Vec3 pos;
    Vec3 normal;
    Vec2 uv;
    uint32_t color = 0xFFFFFFFFu;  // 0xAABBGGRR (little-endian RGBA bytes); baked lighting goes here
};
enum class GeomSource : uint8_t { Bsp = 0, Mesh = 1 };
struct Batch {  // one draw call: a model + material + source combination
    int32_t material = 0;
    GeomSource source = GeomSource::Bsp;
    int32_t model = 0;  // 0 = world, >0 = brush entity sub-model
    std::vector<Vertex> vertices;
    std::vector<uint32_t> indices;  // triangle list
    AABB bounds;
};

struct CollisionBrush {
    uint32_t contents = 0;
    uint32_t sourceId = 0;  // Brush::id
    std::vector<Plane> planes;
    AABB bounds;
};
struct TraceResult {
    bool hit = false;
    float fraction = 1;
    Vec3 point, normal;
    uint32_t contents = 0;
    uint32_t objectId = 0;  // Brush::id or MeshObject::id
    bool startSolid = false;
};

// Brush-based BSP tree (Quake 3 style): nodes split on brush-face planes, leaves hold brush lists.
struct BspNode { int32_t plane = 0; int32_t child[2] = {0, 0}; };  // [0]=front [1]=back, <0 => ~leaf
struct BspLeaf { uint32_t firstBrush = 0, brushCount = 0; };
struct Bsp {
    std::vector<Plane> planes;
    std::vector<BspNode> nodes;
    std::vector<BspLeaf> leaves;
    std::vector<uint32_t> leafBrushes;
    std::vector<CollisionBrush> brushes;
    int32_t root = -1;  // node index, or ~leaf
    AABB bounds;
    uint32_t depth = 0;

    void build(std::vector<CollisionBrush> brushes);
    int findLeaf(const Vec3& p) const;
    uint32_t pointContents(const Vec3& p) const;
    TraceResult trace(const Vec3& a, const Vec3& b, uint32_t mask = CONTENTS_SOLID) const;
};

struct CompiledModel {  // model 0 = world, others = brush entities (doors, triggers...)
    uint32_t entityId = 0;
    AABB bounds;
    std::vector<CollisionBrush> brushes;  // sub-models: linear brush list
};
struct CollisionMesh {
    uint32_t objectId = 0;
    AABB bounds;
    std::vector<Vec3> tris;  // 3 per triangle
};
struct CompileStats {
    uint32_t brushes = 0, meshes = 0, faces = 0, triangles = 0, vertices = 0;
    uint32_t bspNodes = 0, bspLeaves = 0, bspDepth = 0, lights = 0;
    double ms = 0;
};

struct CompiledMap {
    std::vector<Material> materials;
    std::vector<Batch> batches;
    std::vector<CompiledModel> models;
    Bsp bsp;                             // world solids only
    std::vector<CollisionMesh> collMeshes;
    std::vector<Light> lights;
    std::vector<Entity> entities;
    Vec3 ambient{0.2f, 0.2f, 0.2f};
    float unitsPerMeter = 64;
    AABB bounds;
    CompileStats stats;
    bool baked = false;

    // Nearest hit against the BSP (solid brushes) and solid mesh objects.
    TraceResult trace(const Vec3& a, const Vec3& b, uint32_t mask = CONTENTS_SOLID) const;
    uint32_t pointContents(const Vec3& p) const { return bsp.pointContents(p); }
};

struct CompileOptions {
    bool csg = true;              // remove brush faces hidden inside other solids
    bool bsp = true;              // build collision BSP
    bool bakeLighting = false;    // tessellate + bake vertex colours
    float lightEdge = 32;         // max triangle edge while baking (smaller = finer light)
    bool shadows = true;
    int threads = 0;              // 0 = hardware concurrency
};
CompiledMap compile(const Map& map, const CompileOptions& opt = {});
// Raw per-object render batches without CSG (fast; used by the editor viewport).
void buildEditBatches(const Map& map, std::vector<Batch>& out);
// Bakes per-vertex lighting (ambient + point/spot/sun with BSP-traced shadows).
void bakeLighting(CompiledMap& cm, float maxEdge = 32, bool shadows = true, int threads = 0);

// ------------------------------------------------------------------ file format (.hmap)
// Chunked little-endian binary. Chunks: META MATS BRSH MESH ENTS CMPL. Unknown chunks are skipped.
Status saveMap(const std::string& path, const Map& map, const CompiledMap* compiled = nullptr);
Status loadMap(const std::string& path, Map& out, CompiledMap* compiled = nullptr);
// Runtime-oriented: writes only materials + entities + compiled geometry (no editable source).
Status saveCompiled(const std::string& path, const CompiledMap& cm);
// Loads compiled data; if the file only has source chunks it compiles on the fly.
Status loadCompiled(const std::string& path, CompiledMap& out);
std::vector<uint8_t> saveMapToMemory(const Map& map, const CompiledMap* compiled = nullptr);
Status loadMapFromMemory(const uint8_t* data, size_t size, Map& out, CompiledMap* compiled = nullptr);

// ------------------------------------------------------------------ export
struct FbxOptions {
    float scale = 1.0f;         // multiplies positions
    bool entities = true;       // export entities/props as Null nodes with custom properties
    bool vertexColors = true;   // write baked lighting as a colour layer
    bool includeSubModels = true;
};
std::vector<uint8_t> exportFBXToMemory(const CompiledMap& cm, const FbxOptions& opt = {});
Status exportFBX(const std::string& path, const CompiledMap& cm, const FbxOptions& opt = {});
Status exportOBJ(const std::string& path, const CompiledMap& cm, float scale = 1.0f);

// ------------------------------------------------------------------ entity definitions
struct PropDef {
    std::string key, type, label, def, choices;  // type: string int float bool color255 vec3 choice model material target
};
struct EntityClass {
    std::string name, label;
    bool brush = false;           // brush entity (func_*, trigger_*)
    Vec3 color{1, 1, 1};          // editor colour 0..1
    Vec3 half{8, 8, 8};           // editor box half extents
    bool directional = false;     // shows an angles arrow
    bool hasModel = false;        // displays the "model" key
    uint32_t brushContents = CONTENTS_SOLID;
    std::vector<PropDef> props;
};
class EntityRegistry {
public:
    std::vector<EntityClass> classes;
    const EntityClass* find(const std::string& name) const;
    // Mini-FGD text format, see assets/entities.def. Later definitions override earlier ones.
    Status parse(const std::string& text);
    void applyDefaults(Entity& e) const;  // fills missing keys with class defaults
    static EntityRegistry builtin();
};

}  // namespace hmap