import type { Resources, BuildQueueItem } from '@/types/game'
import { TechnologyType, BuildingType } from '@/types/game'
import { TECHNOLOGIES } from '@/config/gameConfig'
import * as pointsLogic from './pointsLogic'

/**
 * 计算科技研究成本
 */
export const calculateTechnologyCost = (techType: TechnologyType, targetLevel: number): Resources => {
  const config = TECHNOLOGIES[techType]
  const multiplier = Math.pow(config.costMultiplier, targetLevel - 1)
  return {
    metal: Math.floor(config.baseCost.metal * multiplier),
    crystal: Math.floor(config.baseCost.crystal * multiplier),
    deuterium: Math.floor(config.baseCost.deuterium * multiplier),
    darkMatter: Math.floor(config.baseCost.darkMatter * multiplier),
    energy: 0
  }
}

/**
 * 计算科技研究时间
 */
export const calculateTechnologyTime = (techType: TechnologyType, currentLevel: number, researchSpeedBonus: number = 0): number => {
  const config = TECHNOLOGIES[techType]
  const baseTime = config.baseTime * Math.pow(config.costMultiplier, currentLevel)
  const speedMultiplier = 1 - researchSpeedBonus / 100
  return Math.floor(baseTime * speedMultiplier)
}

/**
 * 检查科技研究条件
 */
export const checkTechnologyRequirements = (
  techType: TechnologyType,
  buildings: Partial<Record<BuildingType, number>>,
  technologies: Partial<Record<TechnologyType, number>>
): boolean => {
  const config = TECHNOLOGIES[techType]
  if (!config.requirements) return true

  for (const [key, level] of Object.entries(config.requirements)) {
    if (Object.values(BuildingType).includes(key as BuildingType)) {
      if ((buildings[key as BuildingType] || 0) < level) {
        return false
      }
    } else if (Object.values(TechnologyType).includes(key as TechnologyType)) {
      if ((technologies[key as TechnologyType] || 0) < level) {
        return false
      }
    }
  }
  return true
}

/**
 * 创建研究队列项
 */
export const createResearchQueueItem = (techType: TechnologyType, targetLevel: number, researchTime: number): BuildQueueItem => {
  const now = Date.now()
  return {
    id: `research_${now}`,
    type: 'technology',
    itemType: techType,
    targetLevel,
    startTime: now,
    endTime: now + researchTime * 1000
  }
}

/**
 * 处理研究完成
 */
export const completeResearchQueue = (
  researchQueue: BuildQueueItem[],
  technologies: Partial<Record<TechnologyType, number>>,
  now: number,
  onPointsEarned?: (points: number, type: 'technology', itemType: string, level: number) => void
): BuildQueueItem[] => {
  return researchQueue.filter(item => {
    if (now >= item.endTime) {
      // 研究完成
      const oldLevel = technologies[item.itemType as TechnologyType] || 0
      const newLevel = item.targetLevel || 0
      technologies[item.itemType as TechnologyType] = newLevel

      // 计算并累积积分
      if (onPointsEarned && newLevel > oldLevel) {
        const points = pointsLogic.calculateTechnologyPoints(item.itemType as TechnologyType, oldLevel, newLevel)
        onPointsEarned(points, 'technology', item.itemType, newLevel)
      }
      return false
    }
    return true
  })
}