using SpaceGame.Simulation.Api.Data;
using SpaceGame.Simulation.Api.Contracts;

namespace SpaceGame.Simulation.Api.Simulation;

public sealed partial class SimulationEngine
{
    private void UpdateStations(SimulationWorld world, float deltaSeconds, ICollection<SimulationEventRecord> events)
    {
        var factionPopulation = new Dictionary<string, float>(StringComparer.Ordinal);
        foreach (var station in world.Stations)
        {
            UpdateStationPopulation(station, deltaSeconds, events);
            ReviewStationMarketOrders(world, station);
            RunStationProduction(world, station, deltaSeconds, events);
            factionPopulation[station.FactionId] = GetInventoryAmount(factionPopulation, station.FactionId) + station.Population;
        }

        foreach (var faction in world.Factions)
        {
            faction.PopulationTotal = GetInventoryAmount(factionPopulation, faction.Id);
        }
    }

    private void UpdateStationPopulation(StationRuntime station, float deltaSeconds, ICollection<SimulationEventRecord> events)
    {
        station.WorkforceRequired = MathF.Max(12f, station.InstalledModules.Count * 14f);

        var requiredWater = station.Population * WaterConsumptionPerWorkerPerSecond * deltaSeconds;
        var consumedWater = RemoveInventory(station.Inventory, "water", requiredWater);
        var waterSatisfied = requiredWater <= 0.01f || consumedWater + 0.001f >= requiredWater;
        var hasPower = station.EnergyStored > 0.01f;
        var habitatModules = CountModules(station.InstalledModules, "habitat-ring");
        station.PopulationCapacity = 40f + (habitatModules * 220f);

        if (waterSatisfied && hasPower)
        {
            if (habitatModules > 0 && station.Population < station.PopulationCapacity)
            {
                station.Population = MathF.Min(station.PopulationCapacity, station.Population + (PopulationGrowthPerSecond * deltaSeconds));
            }
        }
        else if (station.Population > 0f)
        {
            var previous = station.Population;
            station.Population = MathF.Max(0f, station.Population - (PopulationAttritionPerSecond * deltaSeconds));
            if (MathF.Floor(previous) > MathF.Floor(station.Population))
            {
                events.Add(new SimulationEventRecord("station", station.Id, "population-loss", $"{station.Definition.Label} lost population due to support shortages.", DateTimeOffset.UtcNow));
            }
        }

        station.WorkforceEffectiveRatio = ComputeWorkforceRatio(station.Population, station.WorkforceRequired);
    }

    private void ReviewStationMarketOrders(SimulationWorld world, StationRuntime station)
    {
        if (station.CommanderId is null)
        {
            return;
        }

        var desiredOrders = new List<DesiredMarketOrder>();
        var fuelReserve = MathF.Max(80f, CountModules(station.InstalledModules, "power-core") * 140f);
        var waterReserve = MathF.Max(30f, station.Population * 3f);
        var refinedReserve = HasStationModules(station, "fabricator-array") ? 140f : 40f;
        var oreReserve = HasRefineryCapability(station) ? 180f : 0f;
        var gasReserve = CanProcessFuel(station) ? 120f : 0f;

        AddDemandOrder(desiredOrders, station, "fuel", fuelReserve, valuationBase: 1.2f);
        AddDemandOrder(desiredOrders, station, "water", waterReserve, valuationBase: 1.1f);
        AddDemandOrder(desiredOrders, station, "ore", oreReserve, valuationBase: 1.0f);
        AddDemandOrder(desiredOrders, station, "gas", gasReserve, valuationBase: 0.95f);
        AddDemandOrder(desiredOrders, station, "refined-metals", refinedReserve, valuationBase: 1.15f);

        AddSupplyOrder(desiredOrders, station, "fuel", fuelReserve * 1.5f, reserveFloor: fuelReserve, valuationBase: 0.8f);
        AddSupplyOrder(desiredOrders, station, "water", waterReserve * 1.5f, reserveFloor: waterReserve, valuationBase: 0.65f);
        AddSupplyOrder(desiredOrders, station, "ore", oreReserve * 1.4f, reserveFloor: oreReserve, valuationBase: 0.7f);
        AddSupplyOrder(desiredOrders, station, "gas", gasReserve * 1.4f, reserveFloor: gasReserve, valuationBase: 0.72f);
        AddSupplyOrder(desiredOrders, station, "refined-metals", refinedReserve * 1.4f, reserveFloor: refinedReserve, valuationBase: 0.95f);

        ReconcileStationMarketOrders(world, station, desiredOrders);
    }

    private void RunStationProduction(SimulationWorld world, StationRuntime station, float deltaSeconds, ICollection<SimulationEventRecord> events)
    {
        var recipe = SelectProductionRecipe(world, station);
        if (recipe is null || station.EnergyStored <= 0.01f)
        {
            station.ProcessTimer = 0f;
            return;
        }

        if (!TryConsumeStationEnergy(station, world.Balance.Energy.MoveDrain * deltaSeconds))
        {
            station.ProcessTimer = 0f;
            return;
        }

        station.ProcessTimer += deltaSeconds * station.WorkforceEffectiveRatio;
        if (station.ProcessTimer < recipe.Duration)
        {
            return;
        }

        station.ProcessTimer = 0f;
        foreach (var input in recipe.Inputs)
        {
            RemoveInventory(station.Inventory, input.ItemId, input.Amount);
        }

        var produced = 0f;
        foreach (var output in recipe.Outputs)
        {
            produced += TryAddStationInventory(world, station, output.ItemId, output.Amount);
        }

        if (produced <= 0.01f)
        {
            return;
        }

        events.Add(new SimulationEventRecord("station", station.Id, "production-complete", $"{station.Definition.Label} completed {recipe.Label}.", DateTimeOffset.UtcNow));
        var faction = world.Factions.FirstOrDefault(candidate => candidate.Id == station.FactionId);
        if (faction is not null)
        {
            faction.GoodsProduced += produced;
        }
    }

    private static RecipeDefinition? SelectProductionRecipe(SimulationWorld world, StationRuntime station) =>
        world.Recipes.Values
            .Where(recipe => RecipeAppliesToStation(station, recipe))
            .OrderByDescending(recipe => recipe.Priority)
            .FirstOrDefault(recipe => CanRunRecipe(world, station, recipe));

    private static bool RecipeAppliesToStation(StationRuntime station, RecipeDefinition recipe)
    {
        var categoryMatch = string.Equals(station.Definition.Category, recipe.FacilityCategory, StringComparison.Ordinal)
            || (string.Equals(recipe.FacilityCategory, "station", StringComparison.Ordinal)
                && station.Definition.Category is "station" or "shipyard" or "defense" or "gate");
        return categoryMatch && recipe.RequiredModules.All(moduleId => station.InstalledModules.Contains(moduleId, StringComparer.Ordinal));
    }

    private static bool CanRunRecipe(SimulationWorld world, StationRuntime station, RecipeDefinition recipe)
    {
        if (recipe.Inputs.Any(input => GetInventoryAmount(station.Inventory, input.ItemId) + 0.001f < input.Amount))
        {
            return false;
        }

        return recipe.Outputs.All(output => CanAcceptStationInventory(world, station, output.ItemId, output.Amount));
    }

    private static bool CanAcceptStationInventory(SimulationWorld world, StationRuntime station, string itemId, float amount)
    {
        if (amount <= 0f || !world.ItemDefinitions.TryGetValue(itemId, out var itemDefinition))
        {
            return false;
        }

        var requiredModule = GetStorageRequirement(itemDefinition.Storage);
        if (requiredModule is not null && !station.InstalledModules.Contains(requiredModule, StringComparer.Ordinal))
        {
            return false;
        }

        if (!station.Definition.Storage.TryGetValue(itemDefinition.Storage, out var capacity))
        {
            return false;
        }

        var used = station.Inventory
            .Where(entry => world.ItemDefinitions.TryGetValue(entry.Key, out var definition) && definition.Storage == itemDefinition.Storage)
            .Sum(entry => entry.Value);
        return used + amount <= capacity + 0.001f;
    }

    private static void AddDemandOrder(ICollection<DesiredMarketOrder> desiredOrders, StationRuntime station, string itemId, float targetAmount, float valuationBase)
    {
        var current = GetInventoryAmount(station.Inventory, itemId);
        if (current >= targetAmount - 0.01f)
        {
            return;
        }

        var deficit = targetAmount - current;
        var scarcity = targetAmount <= 0.01f ? 1f : MathF.Min(1f, deficit / targetAmount);
        desiredOrders.Add(new DesiredMarketOrder(MarketOrderKinds.Buy, itemId, deficit, valuationBase + scarcity, null));
    }

    private static void AddSupplyOrder(ICollection<DesiredMarketOrder> desiredOrders, StationRuntime station, string itemId, float triggerAmount, float reserveFloor, float valuationBase)
    {
        var current = GetInventoryAmount(station.Inventory, itemId);
        if (current <= triggerAmount + 0.01f)
        {
            return;
        }

        var surplus = current - reserveFloor;
        if (surplus <= 0.01f)
        {
            return;
        }

        desiredOrders.Add(new DesiredMarketOrder(MarketOrderKinds.Sell, itemId, surplus, valuationBase, reserveFloor));
    }

    private static void ReconcileStationMarketOrders(SimulationWorld world, StationRuntime station, IReadOnlyCollection<DesiredMarketOrder> desiredOrders)
    {
        var existingOrders = world.MarketOrders
            .Where(order => order.StationId == station.Id && order.ConstructionSiteId is null)
            .ToList();

        foreach (var desired in desiredOrders)
        {
            var order = existingOrders.FirstOrDefault(candidate =>
                candidate.Kind == desired.Kind &&
                candidate.ItemId == desired.ItemId &&
                candidate.ConstructionSiteId is null);

            if (order is null)
            {
                order = new MarketOrderRuntime
                {
                    Id = $"market-order-{station.Id}-{desired.Kind}-{desired.ItemId}",
                    FactionId = station.FactionId,
                    StationId = station.Id,
                    Kind = desired.Kind,
                    ItemId = desired.ItemId,
                    Amount = desired.Amount,
                    RemainingAmount = desired.Amount,
                    Valuation = desired.Valuation,
                    ReserveThreshold = desired.ReserveThreshold,
                    State = MarketOrderStateKinds.Open,
                };
                world.MarketOrders.Add(order);
                station.MarketOrderIds.Add(order.Id);
                existingOrders.Add(order);
                continue;
            }

            order.RemainingAmount = desired.Amount;
            order.Valuation = desired.Valuation;
            order.ReserveThreshold = desired.ReserveThreshold;
            order.State = desired.Amount <= 0.01f ? MarketOrderStateKinds.Cancelled : MarketOrderStateKinds.Open;
        }

        foreach (var order in existingOrders.Where(order => desiredOrders.All(desired => desired.Kind != order.Kind || desired.ItemId != order.ItemId)))
        {
            order.RemainingAmount = 0f;
            order.State = MarketOrderStateKinds.Cancelled;
        }
    }

    private static bool HasRefineryCapability(StationRuntime station) =>
        HasStationModules(station, "refinery-stack", "power-core", "bulk-bay");

    private static bool CanProcessFuel(StationRuntime station) =>
        HasStationModules(station, "fuel-processor", "power-core", "gas-tank", "liquid-tank");

    private sealed record DesiredMarketOrder(string Kind, string ItemId, float Amount, float Valuation, float? ReserveThreshold);
}