/**
 * 生产计算纯函数
 * 所有函数都是纯函数：无副作用，相同输入总是产生相同输出
 * 便于单元测试和服务端复用
 */

import type { Planet, Resources } from '@/types/game'
import { BuildingType } from '@/types/game'

/**
 * 生产加成配置
 */
export interface ProductionBonuses {
  /** 能量生产加成百分比 */
  energyProductionBonus: number
  /** 存储容量加成百分比 */
  storageCapacityBonus: number
  /** 资源速度倍率 */
  resourceSpeed: number
}

/**
 * 科技加成配置
 */
export interface TechBonuses {
  /** 金属采矿研究等级 */
  mineralResearchLevel: number
  /** 晶体采矿研究等级 */
  crystalResearchLevel: number
  /** 燃料研究等级 */
  fuelResearchLevel: number
}

/**
 * 生产计算结果
 */
export interface ProductionResult {
  /** 资源生产量（每秒） */
  production: Resources
  /** 能量生产量 */
  energyProduction: number
  /** 能量消耗量 */
  energyConsumption: number
  /** 能量比率（0-1） */
  energyRatio: number
  /** 存储容量 */
  capacity: Resources
}

// 基础配置常量
const BASE_ENERGY_PRODUCTION = 0
const BASE_METAL_PRODUCTION = 10
const BASE_CRYSTAL_PRODUCTION = 5
const BASE_DEUTERIUM_PRODUCTION = 0
const BASE_STORAGE_CAPACITY = 10000
const STORAGE_CAPACITY_FACTOR = 2
const RESEARCH_PRODUCTION_BONUS_PER_LEVEL = 0.02

// 能量生产配置
const SOLAR_PLANT_BASE = 50
const SOLAR_PLANT_FACTOR = 1.1
const FUSION_REACTOR_BASE = 150
const FUSION_REACTOR_FACTOR = 1.15

// 能量消耗配置
const METAL_MINE_ENERGY_BASE = 10
const METAL_MINE_ENERGY_FACTOR = 1.1
const CRYSTAL_MINE_ENERGY_BASE = 10
const CRYSTAL_MINE_ENERGY_FACTOR = 1.1
const DEUTERIUM_SYNTH_ENERGY_BASE = 15
const DEUTERIUM_SYNTH_ENERGY_FACTOR = 1.1

// 资源生产配置（每小时）
const METAL_MINE_PRODUCTION_BASE = 30
const METAL_MINE_PRODUCTION_FACTOR = 1.1
const CRYSTAL_MINE_PRODUCTION_BASE = 20
const CRYSTAL_MINE_PRODUCTION_FACTOR = 1.1
const DEUTERIUM_SYNTH_PRODUCTION_BASE = 10
const DEUTERIUM_SYNTH_PRODUCTION_FACTOR = 1.1

// 核聚变反应堆重氢消耗
const FUSION_DEUTERIUM_BASE = 10
const FUSION_DEUTERIUM_FACTOR = 1.1

/**
 * 计算科技生产加成
 * @pure
 */
export const calcTechProductionBonus = (
  mineralResearchLevel: number = 0,
  crystalResearchLevel: number = 0,
  fuelResearchLevel: number = 0
): { metalBonus: number; crystalBonus: number; deuteriumBonus: number } => {
  return {
    metalBonus: mineralResearchLevel * RESEARCH_PRODUCTION_BONUS_PER_LEVEL,
    crystalBonus: crystalResearchLevel * RESEARCH_PRODUCTION_BONUS_PER_LEVEL,
    deuteriumBonus: fuelResearchLevel * RESEARCH_PRODUCTION_BONUS_PER_LEVEL
  }
}

/**
 * 计算能量生产（纯函数）
 * @pure
 */
export const calcEnergyProduction = (planet: Planet, energyProductionBonus: number = 0): number => {
  let totalEnergy = BASE_ENERGY_PRODUCTION

  // 太阳能电站
  const solarPlantLevel = planet.buildings[BuildingType.SolarPlant] || 0
  if (solarPlantLevel > 0) {
    totalEnergy += Math.floor(SOLAR_PLANT_BASE * solarPlantLevel * Math.pow(SOLAR_PLANT_FACTOR, solarPlantLevel))
  }

  // 核聚变反应堆
  const fusionReactorLevel = planet.buildings[BuildingType.FusionReactor] || 0
  if (fusionReactorLevel > 0) {
    totalEnergy += Math.floor(FUSION_REACTOR_BASE * fusionReactorLevel * Math.pow(FUSION_REACTOR_FACTOR, fusionReactorLevel))
  }

  // 应用加成
  return Math.floor(totalEnergy * (1 + energyProductionBonus))
}

/**
 * 计算能量消耗（纯函数）
 * @pure
 */
export const calcEnergyConsumption = (planet: Planet): number => {
  let totalConsumption = 0

  // 金属矿
  const metalMineLevel = planet.buildings[BuildingType.MetalMine] || 0
  if (metalMineLevel > 0) {
    totalConsumption += Math.floor(METAL_MINE_ENERGY_BASE * metalMineLevel * Math.pow(METAL_MINE_ENERGY_FACTOR, metalMineLevel))
  }

  // 晶体矿
  const crystalMineLevel = planet.buildings[BuildingType.CrystalMine] || 0
  if (crystalMineLevel > 0) {
    totalConsumption += Math.floor(CRYSTAL_MINE_ENERGY_BASE * crystalMineLevel * Math.pow(CRYSTAL_MINE_ENERGY_FACTOR, crystalMineLevel))
  }

  // 重氢合成器
  const deuteriumSynthesizerLevel = planet.buildings[BuildingType.DeuteriumSynthesizer] || 0
  if (deuteriumSynthesizerLevel > 0) {
    totalConsumption += Math.floor(
      DEUTERIUM_SYNTH_ENERGY_BASE * deuteriumSynthesizerLevel * Math.pow(DEUTERIUM_SYNTH_ENERGY_FACTOR, deuteriumSynthesizerLevel)
    )
  }

  return totalConsumption
}

/**
 * 计算资源生产量（纯函数）
 * @pure
 * @param planet 星球状态
 * @param energyRatio 能量比率（0-1）
 * @param techBonuses 科技加成
 * @returns 每秒资源生产量
 */
export const calcResourceProduction = (planet: Planet, energyRatio: number, techBonuses?: TechBonuses): Resources => {
  const effectiveRatio = Math.min(1, Math.max(0, energyRatio))
  const bonuses = techBonuses
    ? calcTechProductionBonus(techBonuses.mineralResearchLevel, techBonuses.crystalResearchLevel, techBonuses.fuelResearchLevel)
    : { metalBonus: 0, crystalBonus: 0, deuteriumBonus: 0 }

  // 金属生产
  let metalProduction = BASE_METAL_PRODUCTION
  const metalMineLevel = planet.buildings[BuildingType.MetalMine] || 0
  if (metalMineLevel > 0) {
    metalProduction += Math.floor(
      METAL_MINE_PRODUCTION_BASE * metalMineLevel * Math.pow(METAL_MINE_PRODUCTION_FACTOR, metalMineLevel) * effectiveRatio
    )
  }
  metalProduction = Math.floor(metalProduction * (1 + bonuses.metalBonus))

  // 晶体生产
  let crystalProduction = BASE_CRYSTAL_PRODUCTION
  const crystalMineLevel = planet.buildings[BuildingType.CrystalMine] || 0
  if (crystalMineLevel > 0) {
    crystalProduction += Math.floor(
      CRYSTAL_MINE_PRODUCTION_BASE * crystalMineLevel * Math.pow(CRYSTAL_MINE_PRODUCTION_FACTOR, crystalMineLevel) * effectiveRatio
    )
  }
  crystalProduction = Math.floor(crystalProduction * (1 + bonuses.crystalBonus))

  // 重氢生产
  let deuteriumProduction = BASE_DEUTERIUM_PRODUCTION
  const deuteriumSynthesizerLevel = planet.buildings[BuildingType.DeuteriumSynthesizer] || 0
  if (deuteriumSynthesizerLevel > 0) {
    // 重氢生产受温度影响
    const tempModifier = planet.temperature ? 1.28 - 0.002 * planet.temperature.max : 1
    deuteriumProduction += Math.floor(
      DEUTERIUM_SYNTH_PRODUCTION_BASE *
        deuteriumSynthesizerLevel *
        Math.pow(DEUTERIUM_SYNTH_PRODUCTION_FACTOR, deuteriumSynthesizerLevel) *
        effectiveRatio *
        tempModifier
    )
  }

  // 核聚变反应堆消耗重氢
  const fusionReactorLevel = planet.buildings[BuildingType.FusionReactor] || 0
  if (fusionReactorLevel > 0) {
    deuteriumProduction -= Math.floor(FUSION_DEUTERIUM_BASE * fusionReactorLevel * Math.pow(FUSION_DEUTERIUM_FACTOR, fusionReactorLevel))
  }

  deuteriumProduction = Math.floor(deuteriumProduction * (1 + bonuses.deuteriumBonus))

  return {
    metal: metalProduction,
    crystal: crystalProduction,
    deuterium: deuteriumProduction,
    darkMatter: 0,
    energy: 0
  }
}

/**
 * 计算存储容量（纯函数）
 * @pure
 */
export const calcStorageCapacity = (planet: Planet, storageCapacityBonus: number = 0): Resources => {
  const baseCapacity = BASE_STORAGE_CAPACITY
  const bonusMultiplier = 1 + storageCapacityBonus

  // 金属仓库
  const metalStorageLevel = planet.buildings[BuildingType.MetalStorage] || 0
  const metalCapacity = Math.floor(baseCapacity * Math.pow(STORAGE_CAPACITY_FACTOR, metalStorageLevel) * bonusMultiplier)

  // 晶体仓库
  const crystalStorageLevel = planet.buildings[BuildingType.CrystalStorage] || 0
  const crystalCapacity = Math.floor(baseCapacity * Math.pow(STORAGE_CAPACITY_FACTOR, crystalStorageLevel) * bonusMultiplier)

  // 重氢储罐
  const deuteriumTankLevel = planet.buildings[BuildingType.DeuteriumTank] || 0
  const deuteriumCapacity = Math.floor(baseCapacity * Math.pow(STORAGE_CAPACITY_FACTOR, deuteriumTankLevel) * bonusMultiplier)

  return {
    metal: metalCapacity,
    crystal: crystalCapacity,
    deuterium: deuteriumCapacity,
    darkMatter: Number.MAX_SAFE_INTEGER,
    energy: 0
  }
}

/**
 * 计算完整的生产数据（纯函数）
 * 这是主要的入口函数，聚合所有生产计算
 * @pure
 */
export const calcProduction = (planet: Planet, bonuses: ProductionBonuses, techBonuses?: TechBonuses): ProductionResult => {
  const energyProduction = calcEnergyProduction(planet, bonuses.energyProductionBonus)
  const energyConsumption = calcEnergyConsumption(planet)
  const energyRatio = energyConsumption > 0 ? Math.min(1, energyProduction / energyConsumption) : 1
  const capacity = calcStorageCapacity(planet, bonuses.storageCapacityBonus)

  // 计算每秒生产量
  const productionPerSecond = calcResourceProduction(planet, energyRatio, techBonuses)

  // 应用资源速度倍率
  const production: Resources = {
    metal: Math.floor(productionPerSecond.metal * bonuses.resourceSpeed),
    crystal: Math.floor(productionPerSecond.crystal * bonuses.resourceSpeed),
    deuterium: Math.floor(productionPerSecond.deuterium * bonuses.resourceSpeed),
    darkMatter: 0,
    energy: 0
  }

  return {
    production,
    energyProduction,
    energyConsumption,
    energyRatio,
    capacity
  }
}

/**
 * 计算时间段内的资源生产（纯函数）
 * @pure
 * @param planet 星球
 * @param deltaMs 时间间隔（毫秒）
 * @param bonuses 加成配置
 * @param techBonuses 科技加成
 * @returns 时间段内生产的资源量
 */
export const calcProductionForPeriod = (
  planet: Planet,
  deltaMs: number,
  bonuses: ProductionBonuses,
  techBonuses?: TechBonuses
): Resources => {
  const productionData = calcProduction(planet, bonuses, techBonuses)
  const seconds = deltaMs / 1000

  return {
    metal: Math.floor(productionData.production.metal * seconds),
    crystal: Math.floor(productionData.production.crystal * seconds),
    deuterium: Math.floor(productionData.production.deuterium * seconds),
    darkMatter: 0,
    energy: 0
  }
}

/**
 * 应用资源生产到星球（纯函数，返回新的资源状态）
 * @pure
 * @param currentResources 当前资源
 * @param produced 生产的资源
 * @param capacity 存储容量
 * @returns 新的资源状态和溢出量
 */
export const applyProduction = (
  currentResources: Resources,
  produced: Resources,
  capacity: Resources
): { newResources: Resources; overflow: Resources } => {
  const newMetal = currentResources.metal + produced.metal
  const newCrystal = currentResources.crystal + produced.crystal
  const newDeuterium = currentResources.deuterium + produced.deuterium

  const clampedMetal = Math.min(newMetal, capacity.metal)
  const clampedCrystal = Math.min(newCrystal, capacity.crystal)
  const clampedDeuterium = Math.min(newDeuterium, capacity.deuterium)

  return {
    newResources: {
      metal: clampedMetal,
      crystal: clampedCrystal,
      deuterium: clampedDeuterium,
      darkMatter: currentResources.darkMatter + produced.darkMatter,
      energy: currentResources.energy
    },
    overflow: {
      metal: Math.max(0, newMetal - capacity.metal),
      crystal: Math.max(0, newCrystal - capacity.crystal),
      deuterium: Math.max(0, newDeuterium - capacity.deuterium),
      darkMatter: 0,
      energy: 0
    }
  }
}