#pragma once

#include "game/build_graph.hpp"   // MaterialDef
#include <vector>
#include <string>

class ScriptEngine;

// A weapon definition, loaded from Lua (data/weapons.lua). Values are in our
// world units (scaled from the Forts data).
struct WeaponDef {
    std::string name;
    float muzzle_speed;        // launch speed (units/s)
    float reload;              // seconds between shots
    float splash_damage;       // damage at blast centre
    float splash_radius;       // blast radius (units)
    float knockback;           // impulse applied to nearby nodes
    float projectile_radius;   // collision radius of the shell
    float fire_chance;         // 0..1 chance to ignite on impact (M4 fire)
    float min_fire_angle;      // firing-arc lower bound, radians rel. to mount
    float max_fire_angle;      // firing-arc upper bound, radians rel. to mount
    bool  is_beam;             // laser (hitscan beam) vs ballistic shell
    float beam_range;          // max beam length (units)
    float beam_dps;            // HP damage per second to the struck strut
    float beam_duration;       // seconds the beam stays on
    float energy_cost;         // energy spent per shot (Forts EnergyFireCost)
    float recoil;              // velocity kick shoved back into the FIRING
                               // structure on each shot (Forts Recoil); 0 = none
    std::string texture;             // turret/base sprite (CC0 placeholder)
    std::string projectile_texture;  // shell sprite (CC0 placeholder)
    std::string texture_forts;            // preferred BYO Forts turret art
    std::string projectile_texture_forts; // preferred BYO Forts shell art
};

// Loads the material table from <data_dir>/materials.lua, then applies every
// mod under <data_dir>/mods/<name>/ (each may define mod.lua with a Priority and
// a materials.lua that mutates the base table) in (priority, name) order.
// Returns the final material list. Empty on failure.
std::vector<MaterialDef> load_materials(ScriptEngine& script,
                                        const std::string& data_dir);

// Loads weapons from <data_dir>/weapons.lua (+ mod overrides), same layering.
std::vector<WeaponDef> load_weapons(ScriptEngine& script,
                                    const std::string& data_dir);

// A prebuilt strut of a scenario fort, kept in map data so a map can be rebuilt
// on demand (the dev UI switches maps at runtime).
struct MapBeam { float x1, y1, x2, y2; std::string material; };

// A device type (reactor / mine / turbine / battery / ...), from data/devices.lua.
struct DeviceDef {
    std::string name;
    float hp;
    float energy_rate, metal_rate;      // resources produced per second (mine e<0)
    float energy_storage, metal_storage;// added to the resource caps
    bool  needs_deposit;                // mine: only produces on a metal deposit
    bool  wind;                         // turbine: energy scales with height
    float wind_max_rate, wind_max_height;
    bool  is_core;                      // reactor: destroying it decides the game
    float half_w, half_h;
    float cost_metal, cost_energy;      // build cost
    std::string texture;                // CC0 placeholder ("" = flat colour)
    std::string texture_forts;          // preferred BYO Forts art, else texture
    float r, g, b;                      // fallback colour when no texture
};

struct PlacedDevice { std::string type; float x, y; int team; };
struct PlacedWeapon { std::string type; float x, y; };

// One selectable scenario from data/maps.lua (+ mod layers): the ground height,
// metal deposits, pre-placed devices (reactors, generators), the player's
// starting weapons, and every prebuilt strut. Self-contained on purpose, so the
// dev UI can tear the world down and rebuild it from another map at runtime.
//
// NOTE: terrain is still a flat half-plane, so `ground_level` moves the ground
// up and down but cannot change its SHAPE. Real terrain is M6.
struct MapDef {
    std::string name;
    std::string description;
    float ground_level = 1.0f;
    std::vector<std::pair<float,float>> deposits;
    std::vector<PlacedDevice>  devices;
    std::vector<PlacedWeapon>  weapons;
    std::vector<MapBeam>       beams;
};

std::vector<DeviceDef> load_devices(ScriptEngine& script, const std::string& data_dir);

// Loads every map from <data_dir>/maps.lua (+ mods), same layering as the rest.
std::vector<MapDef> load_maps(ScriptEngine& script, const std::string& data_dir);

// Clears `graph` and rebuilds it from `m`: sets ground_level, then welds every
// prebuilt beam (creating/merging endpoint nodes, ground-level ones becoming
// foundations). Requires graph.materials to be loaded.
void build_map(const MapDef& m, BuildGraph& graph);