using static SpaceGame.Api.Factions.AI.CommanderPlanningService;
using static SpaceGame.Api.Shared.Runtime.SimulationRuntimeSupport;

namespace SpaceGame.Api.Stations.Simulation;

internal sealed class StationSimulationService
{
  internal const int StrategicControlTargetSystems = 5;

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

    var desiredOrders = new List<DesiredMarketOrder>();
    var economy = FactionEconomyAnalyzer.Build(world, station.FactionId);
    var role = DetermineStationRole(station);
    var site = GetConstructionSiteForStation(world, station.Id);
    var waterReserve = MathF.Max(30f, station.Population * 3f);
    var constructionEnergyReserve = GetConstructionDemandForItem(world, site, "energycells");
    var constructionHullpartsReserve = GetConstructionDemandForItem(world, site, "hullparts");
    var constructionClayReserve = GetConstructionDemandForItem(world, site, "claytronics");
    var constructionRefinedReserve = GetConstructionDemandForItem(world, site, "refinedmetals");
    var iceReserve = role == "water" ? 260f : 0f;
    var energyReserve = role switch
    {
      "power" => 120f,
      "refinery" => 160f,
      "hullparts" => 180f,
      "claytronics" => 220f,
      "water" => 140f,
      _ => 60f,
    } + constructionEnergyReserve;
    var refinedReserve = role switch
    {
      "hullparts" => 220f,
      "shipyard" => 260f,
      "refinery" => 80f,
      _ => 0f,
    };
    var oreReserve = role == "refinery" ? 260f : 0f;
    var hullpartsReserve = MathF.Max(constructionHullpartsReserve, HasStationModules(station, "module_gen_build_l_01") ? 120f : 0f);
    var claytronicsReserve = MathF.Max(constructionClayReserve, HasStationModules(station, "module_gen_build_l_01") ? 120f : 0f);
    var shipPartsReserve = HasStationModules(station, "module_gen_build_l_01")
        && FactionCommanderHasDirective(world, station.FactionId, "produce-military-ships")
        ? 90f
        : 0f;

    AddDemandOrder(desiredOrders, station, "water", ScaleReserveByEconomy(economy, "water", waterReserve), valuationBase: ScaleDemandValuation(economy, "water", 1.1f));
    AddDemandOrder(desiredOrders, station, "energycells", ScaleReserveByEconomy(economy, "energycells", energyReserve), valuationBase: ScaleDemandValuation(economy, "energycells", 1.0f));
    AddDemandOrder(desiredOrders, station, "ice", ScaleReserveByEconomy(economy, "ice", iceReserve), valuationBase: ScaleDemandValuation(economy, "ice", 1.0f));
    AddDemandOrder(desiredOrders, station, "ore", ScaleReserveByEconomy(economy, "ore", oreReserve), valuationBase: ScaleDemandValuation(economy, "ore", 1.0f));
    AddDemandOrder(desiredOrders, station, "refinedmetals", ScaleReserveByEconomy(economy, "refinedmetals", MathF.Max(refinedReserve, constructionRefinedReserve)), valuationBase: ScaleDemandValuation(economy, "refinedmetals", 1.15f));
    AddDemandOrder(desiredOrders, station, "hullparts", ScaleReserveByEconomy(economy, "hullparts", hullpartsReserve + shipPartsReserve), valuationBase: ScaleDemandValuation(economy, "hullparts", 1.3f));
    AddDemandOrder(desiredOrders, station, "claytronics", ScaleReserveByEconomy(economy, "claytronics", claytronicsReserve), valuationBase: ScaleDemandValuation(economy, "claytronics", 1.35f));

    AddSupplyOrder(desiredOrders, station, "water", ScaleSupplyTriggerByEconomy(economy, "water", waterReserve * 1.5f), reserveFloor: waterReserve, valuationBase: ScaleSupplyValuation(economy, "water", 0.65f));
    AddSupplyOrder(desiredOrders, station, "energycells", ScaleSupplyTriggerByEconomy(economy, "energycells", energyReserve * 1.4f), reserveFloor: energyReserve, valuationBase: ScaleSupplyValuation(economy, "energycells", 0.7f));
    AddSupplyOrder(desiredOrders, station, "ice", ScaleSupplyTriggerByEconomy(economy, "ice", iceReserve * 1.4f), reserveFloor: iceReserve, valuationBase: ScaleSupplyValuation(economy, "ice", 0.5f));
    AddSupplyOrder(desiredOrders, station, "ore", ScaleSupplyTriggerByEconomy(economy, "ore", oreReserve * 1.4f), reserveFloor: oreReserve, valuationBase: ScaleSupplyValuation(economy, "ore", 0.7f));
    AddSupplyOrder(desiredOrders, station, "refinedmetals", ScaleSupplyTriggerByEconomy(economy, "refinedmetals", MathF.Max(refinedReserve, constructionRefinedReserve) * 1.4f), reserveFloor: MathF.Max(refinedReserve, constructionRefinedReserve), valuationBase: ScaleSupplyValuation(economy, "refinedmetals", 0.95f));
    AddSupplyOrder(desiredOrders, station, "hullparts", ScaleSupplyTriggerByEconomy(economy, "hullparts", MathF.Max(hullpartsReserve * 1.35f, hullpartsReserve + 40f)), reserveFloor: hullpartsReserve, valuationBase: ScaleSupplyValuation(economy, "hullparts", 1.05f));
    AddSupplyOrder(desiredOrders, station, "claytronics", ScaleSupplyTriggerByEconomy(economy, "claytronics", MathF.Max(claytronicsReserve * 1.35f, claytronicsReserve + 30f)), reserveFloor: claytronicsReserve, valuationBase: ScaleSupplyValuation(economy, "claytronics", 1.1f));

    ReconcileStationMarketOrders(world, station, desiredOrders);
  }

  internal void RunStationProduction(SimulationWorld world, StationRuntime station, float deltaSeconds, ICollection<SimulationEventRecord> events)
  {
    var faction = world.Factions.FirstOrDefault(candidate => candidate.Id == station.FactionId);
    foreach (var laneKey in GetStationProductionLanes(world, station))
    {
      var recipe = SelectProductionRecipe(world, station, laneKey);
      if (recipe is null)
      {
        station.ProductionLaneTimers[laneKey] = 0f;
        continue;
      }

      var throughput = GetStationProductionThroughput(world, station, recipe);

      var produced = 0f;
      station.ProductionLaneTimers[laneKey] = GetStationProductionTimer(station, laneKey) + (deltaSeconds * station.WorkforceEffectiveRatio * throughput);
      while (station.ProductionLaneTimers[laneKey] >= recipe.Duration && CanRunRecipe(world, station, recipe))
      {
        station.ProductionLaneTimers[laneKey] -= recipe.Duration;
        foreach (var input in recipe.Inputs)
        {
          RemoveInventory(station.Inventory, input.ItemId, input.Amount);
        }

        if (recipe.ShipOutputId is not null)
        {
          produced += StationLifecycleService.CompleteShipRecipe(world, station, recipe, events);
          continue;
        }

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

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

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

  internal static IEnumerable<string> GetStationProductionLanes(SimulationWorld world, StationRuntime station)
  {
    foreach (var moduleId in station.InstalledModules.Distinct(StringComparer.Ordinal))
    {
      if (!world.ModuleDefinitions.TryGetValue(moduleId, out var def) || string.IsNullOrEmpty(def.ProductionMode))
      {
        continue;
      }

      if (string.Equals(def.ProductionMode, "commanded", StringComparison.Ordinal) && station.CommanderId is null)
      {
        continue;
      }

      yield return moduleId;
    }
  }

  internal static float GetStationProductionTimer(StationRuntime station, string laneKey) =>
      station.ProductionLaneTimers.TryGetValue(laneKey, out var timer) ? timer : 0f;

  internal static RecipeDefinition? SelectProductionRecipe(SimulationWorld world, StationRuntime station, string laneKey) =>
      world.Recipes.Values
          .Where(recipe => RecipeAppliesToStation(station, recipe) && string.Equals(GetStationProductionLaneKey(world, recipe), laneKey, StringComparison.Ordinal))
          .OrderByDescending(recipe => GetStationRecipePriority(world, station, recipe))
          .FirstOrDefault(recipe => CanRunRecipe(world, station, recipe));

  internal static string? GetStationProductionLaneKey(SimulationWorld world, RecipeDefinition recipe) =>
      recipe.RequiredModules.FirstOrDefault(moduleId =>
          world.ModuleDefinitions.TryGetValue(moduleId, out var def) && !string.IsNullOrEmpty(def.ProductionMode));

  internal static float GetStationProductionThroughput(SimulationWorld world, StationRuntime station, RecipeDefinition recipe)
  {
    var laneModuleId = GetStationProductionLaneKey(world, recipe);
    if (laneModuleId is null)
    {
      return 1f;
    }

    return Math.Max(1, CountModules(station.InstalledModules, laneModuleId));
  }

  private static float GetStationRecipePriority(SimulationWorld world, StationRuntime station, RecipeDefinition recipe)
  {
    var priority = (float)recipe.Priority;

    var expansionPressure = GetFactionExpansionPressure(world, station.FactionId);
    var fleetPressure = FactionCommanderHasDirective(world, station.FactionId, "produce-military-ships") ? 1f : 0f;
    priority += GetStationRecipePriorityAdjustment(station, recipe, expansionPressure, fleetPressure);

    return priority;
  }

  private static float GetStationRecipePriorityAdjustment(StationRuntime station, RecipeDefinition recipe, float expansionPressure, float fleetPressure)
  {
    var outputItemIds = recipe.Outputs
        .Select(output => output.ItemId)
        .ToHashSet(StringComparer.Ordinal);

    if (outputItemIds.Contains("hullparts"))
    {
      return HasStationModules(station, "module_gen_prod_advancedelectronics_01", "module_gen_build_l_01")
          ? -140f * MathF.Max(expansionPressure, fleetPressure)
          : 280f * MathF.Max(expansionPressure, fleetPressure);
    }

    if (outputItemIds.Contains("refinedmetals"))
    {
      return 180f * expansionPressure;
    }

    if (outputItemIds.Overlaps(["advancedelectronics", "dronecomponents", "engineparts", "fieldcoils", "missilecomponents", "shieldcomponents", "smartchips"]))
    {
      return 170f * expansionPressure;
    }

    if (outputItemIds.Overlaps(["turretcomponents", "weaponcomponents"]))
    {
      return 160f * expansionPressure;
    }

    return recipe.Id switch
    {
      "command-bridge-module-assembly" or "reactor-core-module-assembly" or "capacitor-bank-module-assembly" or "ion-drive-module-assembly" or "ftl-core-module-assembly" or "gun-turret-module-assembly"
          => 220f * MathF.Max(expansionPressure, fleetPressure),
      "frigate-construction" => 320f * MathF.Max(expansionPressure, fleetPressure),
      "destroyer-construction" => 200f * MathF.Max(expansionPressure, fleetPressure),
      "cruiser-construction" => 120f * MathF.Max(expansionPressure, fleetPressure),
      "ammo-fabrication" => -80f * expansionPressure,
      "trade-hub-assembly" or "refinery-assembly" or "farm-ring-assembly" or "manufactory-assembly" or "shipyard-assembly" or "defense-grid-assembly" or "stargate-assembly"
          => -120f * expansionPressure,
      _ => 0f,
    };
  }

  internal static bool RecipeAppliesToStation(StationRuntime station, RecipeDefinition recipe)
  {
    var categoryMatch = string.Equals(recipe.FacilityCategory, "station", StringComparison.Ordinal)
        || string.Equals(recipe.FacilityCategory, "farm", StringComparison.Ordinal)
        || string.Equals(recipe.FacilityCategory, station.Category, StringComparison.Ordinal);
    return categoryMatch && recipe.RequiredModules.All(moduleId => station.InstalledModules.Contains(moduleId, StringComparer.Ordinal));
  }

  private static bool CanRunRecipe(SimulationWorld world, StationRuntime station, RecipeDefinition recipe)
  {
    if (recipe.ShipOutputId is not null)
    {
      if (!world.ShipDefinitions.TryGetValue(recipe.ShipOutputId, out var shipDefinition))
      {
        return false;
      }

      if (!string.Equals(shipDefinition.Kind, "military", StringComparison.Ordinal)
          || !FactionCommanderHasDirective(world, station.FactionId, "produce-military-ships"))
      {
        return false;
      }
    }

    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.CargoKind);
    if (requiredModule is not null && !station.InstalledModules.Contains(requiredModule, StringComparer.Ordinal))
    {
      return false;
    }

    var capacity = GetStationStorageCapacity(station, itemDefinition.CargoKind);
    if (capacity <= 0.01f)
    {
      return false;
    }

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

  private static bool HasRefineryCapability(StationRuntime station) =>
      HasStationModules(station, "module_gen_prod_refinedmetals_01", "module_gen_prod_energycells_01", "module_arg_stor_solid_m_01");

  internal static string NormalizeStationObjective(string? objective)
  {
    return objective?.Trim().ToLowerInvariant() switch
    {
      "power" or "energy" or "energycells" => "power",
      "water" or "ice-refinery" => "water",
      "refinery" or "refinedmetals" => "refinery",
      "hullparts" or "hull" => "hullparts",
      "claytronics" or "clay" => "claytronics",
      "shipyard" or "ship-production" => "shipyard",
      _ => "general",
    };
  }

  internal static string DetermineStationRole(StationRuntime station)
  {
    var objective = NormalizeStationObjective(station.Objective);
    if (!string.Equals(objective, "general", StringComparison.Ordinal))
    {
      return objective;
    }

    if (HasStationModules(station, "module_gen_build_l_01"))
    {
      return "shipyard";
    }

    if (HasStationModules(station, "module_gen_prod_water_01"))
    {
      return "water";
    }

    if (HasStationModules(station, "module_gen_prod_claytronics_01"))
    {
      return "claytronics";
    }

    if (HasStationModules(station, "module_gen_prod_hullparts_01"))
    {
      return "hullparts";
    }

    if (HasStationModules(station, "module_gen_prod_refinedmetals_01"))
    {
      return "refinery";
    }

    if (HasStationModules(station, "module_gen_prod_energycells_01"))
    {
      return "power";
    }

    return "general";
  }

  private static float GetConstructionDemandForItem(SimulationWorld world, ConstructionSiteRuntime? site, string itemId)
  {
    if (site is null || !site.RequiredItems.TryGetValue(itemId, out var required))
    {
      return 0f;
    }

    return MathF.Max(0f, required - GetConstructionDeliveredAmount(world, site, itemId));
  }

  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;
    }

    var surplusRatio = triggerAmount <= 0.01f ? 1f : MathF.Min(1f, surplus / triggerAmount);
    var liquidationValuation = MathF.Max(0.05f, valuationBase * (1f - (0.85f * surplusRatio)));
    desiredOrders.Add(new DesiredMarketOrder(MarketOrderKinds.Sell, itemId, surplus, liquidationValuation, 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;
    }
  }

  internal static float GetFactionExpansionPressure(SimulationWorld world, string factionId)
  {
    var targetSystems = Math.Max(1, Math.Min(StrategicControlTargetSystems, world.Systems.Count));
    var controlledSystems = GetFactionControlledSystemsCount(world, factionId);
    var deficit = Math.Max(0, targetSystems - controlledSystems);
    return Math.Clamp(deficit / (float)targetSystems, 0f, 1f);
  }

  internal static int GetFactionControlledSystemsCount(SimulationWorld world, string factionId)
  {
    return world.Systems.Count(system => FactionControlsSystem(world, factionId, system.Definition.Id));
  }

  private static float ScaleReserveByEconomy(FactionEconomySnapshot economy, string itemId, float baseReserve)
  {
    var commodity = economy.GetCommodity(itemId);
    if (float.IsPositiveInfinity(commodity.ShortageHorizonSeconds))
    {
      return MathF.Max(0f, baseReserve);
    }

    return commodity.ShortageHorizonSeconds < 180f
      ? baseReserve * 1.5f
      : commodity.ShortageHorizonSeconds < 360f
          ? baseReserve * 1.2f
          : baseReserve;
  }

  private static float ScaleSupplyTriggerByEconomy(FactionEconomySnapshot economy, string itemId, float baseTrigger)
  {
    var commodity = economy.GetCommodity(itemId);
    return commodity.NetRatePerSecond < -0.01f ? baseTrigger * 1.2f : baseTrigger;
  }

  private static float ScaleDemandValuation(FactionEconomySnapshot economy, string itemId, float baseValuation)
  {
    var commodity = economy.GetCommodity(itemId);
    if (float.IsPositiveInfinity(commodity.ShortageHorizonSeconds))
    {
      return commodity.ProductionRatePerSecond > 0.01f ? baseValuation : baseValuation * 1.3f;
    }

    return commodity.ShortageHorizonSeconds < 180f
      ? baseValuation * 1.5f
      : commodity.ShortageHorizonSeconds < 360f
          ? baseValuation * 1.25f
          : baseValuation;
  }

  private static float ScaleSupplyValuation(FactionEconomySnapshot economy, string itemId, float baseValuation)
  {
    var commodity = economy.GetCommodity(itemId);
    return commodity.NetRatePerSecond > 0.01f && commodity.ShortageHorizonSeconds > 600f
      ? baseValuation * 0.75f
      : baseValuation;
  }

  private static bool FactionControlsSystem(SimulationWorld world, string factionId, string systemId)
  {
    var totalLagrangePoints = world.Celestials.Count(node =>
        node.SystemId == systemId &&
        node.Kind == SpatialNodeKind.LagrangePoint);
    if (totalLagrangePoints == 0)
    {
      return false;
    }

    var ownedLocations = world.Claims.Count(claim =>
        claim.SystemId == systemId &&
        claim.FactionId == factionId &&
        claim.State is ClaimStateKinds.Activating or ClaimStateKinds.Active);
    return ownedLocations > (totalLagrangePoints / 2f);
  }

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