package data.hullmods;

import com.fs.starfarer.api.combat.BaseHullMod;
import com.fs.starfarer.api.combat.MutableShipStatsAPI;
import com.fs.starfarer.api.combat.ShipAPI;
import com.fs.starfarer.api.combat.WeaponAPI;
import com.fs.starfarer.api.Global;
import com.fs.starfarer.api.combat.CombatEngineAPI;
import com.fs.starfarer.api.util.Misc;

import org.lwjgl.util.vector.Vector2f;
import java.awt.Color;
import java.util.List;
import java.util.Map;
import java.util.HashMap;

//modifyMult增加多少倍
//modifyFlat增加多少数值 

//以下为船体增强
public class Super_Plug extends BaseHullMod 
{
	// ===================== 新增：装甲按时间片恢复（写法B，可控系数） =====================
	// 每秒基础恢复比例（相对每格最大装甲值）
	private static final float ARMOR_REGEN_BASE_PER_SEC = 0.035f;   // 例如 0.02 = 每秒按每格最大装甲的 2% 恢复
	// 恢复效率系数（你要的“像 1f 那样”的控制量；1f=保持当前，0.5f=半速，2f=双倍）
	private static final float ARMOR_REGEN_EFFICIENCY   = 1f;
	// 恢复节拍（固定时间片）
	private static final float ARMOR_TICK_SECONDS       = 0.25f;    // 优化：更快全满（原0.5f -> 0.25f）

	// ===================== 新增：方案A（技能系统冷却/回充/次数） =====================
	// 注意：方案A是在创建舰船时生效，作用于“安装了该HullMod的船”，与阵营无关
	// 冷却时间倍率（越小越快；0f=真·无冷却；推荐先用0.25f测试）
	private static final float SYSTEM_COOLDOWN_MULT = 0f; // 可改为 0f -> 0CD
	// 回充速度倍率（仅对“有充能”的系统生效）
	private static final float SYSTEM_REGEN_MULT    = 10f;    // 2f=两倍回充
	// 额外可用次数（仅对“有充能”的系统生效；也可用 modifyMult 视SDK版本）
	private static final float SYSTEM_USES_FLAT     = 0f;    // 额外 +1 次

	// ===================== 新增：船体结构（HP）按时间片恢复（与装甲同节拍，可控系数） =====================
	// 每秒基础恢复比例（相对最大结构值）
	private static final float HULL_REGEN_BASE_PER_SEC  = 0.035f;   // 例如 0.02 = 每秒按最大结构的 2% 恢复
	// 恢复效率系数（1f=正常、0.5f=半速，2f=双倍）
	private static final float HULL_REGEN_EFFICIENCY    = 1f;

	// ===================== 过载触发：EMP圆环扩散（视觉+纯辐能，不伤友军） =====================
	private static final boolean RING_ON_OVERLOAD_ENABLED = true; // 总开关

	// 视觉 & 动画参数（保留：持续3s，最大半径1600）
	private static final float RING_DURATION      = 3f;
	private static final float RING_MAX_RADIUS    = 1600f;
	private static final float RING_THICKNESS_VIS = 30f;    // 电弧稍厚，视觉更“富”
	// 视觉改造：低密度电弧 + 冲击波平滑粒子 + 余烬火花
	private static final int   RING_ARCS_PER_STEP = 8;     // 优化：减少电弧数（省性能）
	private static final int   RING_DOTS_PER_STEP = 36;    // 优化：减少冲击波点数（平滑且省）
	private static final int   SPARKS_PER_STEP    = 20;    // 优化：减少余烬粒子

	private static final Color RING_FRINGE_COLOR  = new Color(140, 220, 255, 210); // 外沿色
	private static final Color RING_CORE_COLOR    = new Color(255, 255, 255, 240); // 核心色
	private static final Color SHOCKWAVE_COLOR    = new Color(90, 200, 255, 120);  // 冲击波淡蓝
	private static final Color SPARK_COLOR        = new Color(255, 230, 160, 220); // 金色余烬

	// 纯辐能堆积参数（不造成装甲/结构伤害）
	private static final float   RING_FLUX_MIN    = 0.5f;
	private static final float   RING_FLUX_MAX    = 2.0f;
	private static final boolean RING_FLUX_HARD   = true;
	private static final float   RING_BAND_WIDTH  = 120f;

	// ===================== 性能开关（仅限本环形特效） =====================
	private static final float RING_MAX_RENDER_DISTANCE = 2000f;
	private static final float RING_VIS_STEP_SECONDS    = 0.1f;  // 步进0.1s（原0.05s）

	// 弹药补满延迟（用完后等待秒数）
	private static final float AMMO_REGEN_DELAY = 10f;  // 用完后10秒补满（可调整）

	// 统一ShipData（轻量缓存 + 计时）
	private static class ShipData {
		float regenT = 0f;
		float ringT = -1f;       // -1f = 未激活
		float visT = 0f;
		boolean prevOver = false;
		boolean spawnedShock = false;
		float fluxMaxCache = -1f;
		float collRadiusCache = -1f;
		WeaponAPI[] weaponsCache = null;
		float[][] armorGridCache = null;
		float cellMaxCache = -1f;
		
		// 新增：每个武器单独计时（使用 Object 值避免 Janino 泛型问题）
		Map<String, Object> weaponAmmoTimer = new HashMap<String, Object>();
	}

	private static final String SHIP_DATA_KEY = "superplug_shipdata_";

	@Override
	public void applyEffectsBeforeShipCreation(ShipAPI.HullSize hullSize, MutableShipStatsAPI stats, String id) 
	{
		stats.getCombatEngineRepairTimeMult().modifyMult(id, 1f);			//战斗修理引擎时间
		stats.getCombatWeaponRepairTimeMult().modifyMult(id, 1f);			//战斗修理武器时间

		stats.getBaseCRRecoveryRatePercentPerDay().modifyMult(id, 1f);	//基础日CR恢复速度			
		stats.getMaxCombatReadiness().modifyMult(id, 2f);				//CR最大值			
		stats.getRepairRatePercentPerDay().modifyMult(id, 1f);			//基础日修理率
			
		stats.getBeamWeaponDamageMult().modifyMult(id, 1f);             //光束类武器伤害
		stats.getEnergyWeaponDamageMult().modifyMult(id, 1f);           //能量类武器伤害
		stats.getBallisticWeaponDamageMult().modifyMult(id, 1f);        //实弹类武器伤害
		stats.getMissileWeaponDamageMult().modifyMult(id, 1f);          //导弹类武器伤害
					
		stats.getEnergyWeaponFluxCostMod().modifyMult(id, 0.1f);		//能量武器幅能消耗
		stats.getBallisticWeaponFluxCostMod().modifyMult(id, 0.1f);		//实弹武器幅能消耗
		stats.getMissileWeaponFluxCostMod().modifyMult(id, 0.1f);		//导弹类武器幅能消耗
		stats.getBeamWeaponFluxCostMult().modifyMult(id, 0.1f);			//光束武器幅能消耗
		
		stats.getMissileRoFMult().modifyMult(id, 10f);					//导弹重装速度
		stats.getBallisticRoFMult().modifyMult(id, 10f);					//实弹重装速度
		stats.getEnergyRoFMult().modifyMult(id, 10f);					//能量重装速度
		
		stats.getProjectileSpeedMult().modifyMult(id, 1.5f);			//武器弹丸类抛射速度

		stats.getBallisticWeaponRangeBonus().modifyMult(id, 1f);		//实弹武器射程
		stats.getBeamWeaponRangeBonus().modifyFlat(id, 1000f);			   //光束武器射程
		stats.getEnergyWeaponRangeBonus().modifyMult(id, 1f);			//能量武器射程
		stats.getMissileWeaponRangeBonus().modifyMult(id, 1f);          //导弹类武器射程

		stats.getBeamPDWeaponRangeBonus().modifyFlat(id, 1000f);			//光束类PD射程
		stats.getNonBeamPDWeaponRangeBonus().modifyFlat(id, 1000f);		//非光束类PD射程
		
		stats.getWeaponTurnRateBonus().modifyMult(id, 1f);				//武器旋转速率		
		stats.getBeamWeaponTurnRateBonus().modifyMult(id, 1f);			//光束武器旋转速率
		stats.getSightRadiusMod().modifyMult(id, 10f);					//视野半径

		stats.getWeaponHealthBonus().modifyMult(id, 1f);				//武器血量
		stats.getEngineHealthBonus().modifyMult(id, 1f);				//引擎血量
		stats.getEngineDamageTakenMult().modifyMult(id, 1f);			//引擎受到伤害

		stats.getBallisticAmmoBonus().modifyMult(id, 10f);				//实弹弹药
		stats.getEnergyAmmoBonus().modifyMult(id, 10f);				//能量弹药
		stats.getMissileAmmoBonus().modifyMult(id, 2f);				//导弹弹药
		
		stats.getMissileHealthBonus().modifyMult(id, 10f);				//导弹生命值
		stats.getMissileMaxSpeedBonus().modifyMult(id, 1f);				//导弹最大速度加成
		stats.getMissileAccelerationBonus().modifyMult(id, 1f);			//导弹加速度
		stats.getMissileMaxTurnRateBonus().modifyMult(id, 1f);			//导弹最大转向速度
		stats.getMissileTurnAccelerationBonus().modifyMult(id, 1f);		//导弹转向加速度
		stats.getMissileGuidance().modifyMult(id, 1f);					//导弹制导
		
		stats.getAutofireAimAccuracy().modifyMult(id, 1f);					//自动开火准确率
		stats.getMaxRecoilMult().modifyMult(id, 1f);						//最大后座力
		stats.getRecoilPerShotMult().modifyMult(id, 1f);					//每击后座力

		stats.getMaxSpeed().modifyMult(id, 1f);							//最大速度
		stats.getFuelMod().modifyMult(id, 10f);							//携带燃油量
		stats.getCargoMod().modifyMult(id, 10f);							//货仓量（倍率）
		stats.getMaxCrewMod().modifyMult(id, 1f);	                    //载员数量
		stats.getMinCrewMod().modifyMult(id, 0.1f); 					//最小船员数量
		stats.getMaxBurnLevel().modifyMult(id, 1.5f);						//最大航行速度
		stats.getFuelUseMod().modifyMult(id, 0.1f);						//燃油消耗量
		stats.getSuppliesPerMonth().modifyMult(id, 1f);   			    //基础补给消耗
		stats.getCRPerDeploymentPercent().modifyMult(id, 1f);			//每次参战CR消耗
	

		stats.getFluxCapacity().modifyMult(id, 1f);						//Flux总量
		stats.getFluxDissipation().modifyMult(id, 1f);					//Flux消退速率
		stats.getVentRateMult().modifyMult(id, 1f);					    //强制Flux消散速度

		stats.getAcceleration().modifyMult(id, 1f);						//加速度
		stats.getDeceleration().modifyMult(id, 1f);						//减速
		stats.getTurnAcceleration().modifyMult(id, 1f);					//转向加速度
		stats.getMaxTurnRate().modifyMult(id, 1f);						//最大转向速率
		stats.getZeroFluxSpeedBoost().modifyMult(id, 1.5f);				//0幅能时船速

		stats.getShieldArcBonus().modifyMult(id, 1f);					//盾弧度
		stats.getShieldUpkeepMult().modifyMult(id, 1f);					//保持护盾能量消耗
		stats.getShieldDamageTakenMult().modifyMult(id, 1f);			//护盾承受伤害系数
		stats.getShieldTurnRateMult().modifyMult(id, 1f);				//护盾转向速度
		stats.getShieldUnfoldRateMult().modifyMult(id, 1f);			//护盾打开速度
		
		
		stats.getPeakCRDuration().modifyMult(id, 10f);					//CR峰值持续时间
		stats.getCRLossPerSecondPercent().modifyMult(id, 1f);		    //CR消退速度
		stats.getOverloadTimeMod().modifyMult(id, 1f);				//舰船过载时间

		stats.getHullBonus().modifyMult(id, 1f);                        //耐久,结构
		stats.getArmorBonus().modifyMult(id, 1f);                        //装甲
		stats.getSensorStrength().modifyMult(id, 10f);                   //雷达范围
		stats.getSuppliesToRecover().modifyMult(id, 1f);                 // 修复补给消耗
		
		stats.getFighterRefitTimeMult().modifyMult(id, 0.1f);      		//战机整备速率回复时间
		stats.getNumFighterBays().modifyMult(id, 3f);					//加倍战机数量槽
		stats.getCrewLossMult().modifyMult(id, 0.1f);					//舰船人员战损倍数	
		stats.getFighterWingRange().modifyMult(id, 2f);					//战机交战范围

		// ===================== 新增：方案A（系统冷却/回充/次数） =====================
		stats.getSystemCooldownBonus().modifyMult(id, SYSTEM_COOLDOWN_MULT); // 技能冷却倍率（0f=0CD）
		stats.getSystemRegenBonus().modifyMult(id, SYSTEM_REGEN_MULT);       //技能回充倍率（仅有充能的系统）
		stats.getSystemUsesBonus().modifyFlat(id, SYSTEM_USES_FLAT);         //额外可用次数（仅有充能的系统）
	}
	
	//以下为船体所属战机增强
	public void applyEffectsToFighterSpawnedByShip( ShipAPI fighter, ShipAPI ship, String id )
	{
		fighter.getMutableStats().getBeamWeaponDamageMult().modifyMult(id, 1f);             //光束类武器伤害
		fighter.getMutableStats().getEnergyWeaponDamageMult().modifyMult(id, 1f);           //能量类武器伤害
		fighter.getMutableStats().getBallisticWeaponDamageMult().modifyMult(id, 1f);        //实弹类武器伤害
		fighter.getMutableStats().getMissileWeaponDamageMult().modifyMult(id, 1f);          //导弹类武器伤害
	
		fighter.getMutableStats().getProjectileSpeedMult().modifyMult(id, 1.5f);			//武器弹丸类抛射速度
		fighter.getMutableStats().getBallisticWeaponRangeBonus().modifyMult(id, 1f);		//实弹武器射程
		fighter.getMutableStats().getBeamWeaponRangeBonus().modifyFlat(id, 1000f);			   //光束武器射程
		fighter.getMutableStats().getEnergyWeaponRangeBonus().modifyMult(id, 1f);			//能量武器射程
		fighter.getMutableStats().getMissileWeaponRangeBonus().modifyMult(id, 1f);          //导弹类武器射程
		
		fighter.getMutableStats().getMissileRoFMult().modifyMult(id, 10f);					//导弹重装速度
		fighter.getMutableStats().getBallisticRoFMult().modifyMult(id, 10f);					//实弹重装速度
		fighter.getMutableStats().getEnergyRoFMult().modifyMult(id, 10f);					//能量重装速度
		
		fighter.getMutableStats().getBallisticAmmoBonus().modifyMult(id, 10f);			//实弹弹药
		fighter.getMutableStats().getEnergyAmmoBonus().modifyMult(id, 10f);				//能量弹药
		fighter.getMutableStats().getMissileAmmoBonus().modifyMult(id, 10f);			//导弹弹药
		
		fighter.getMutableStats().getEnergyWeaponFluxCostMod().modifyMult(id, 0f);			//能量武器幅能消耗
		fighter.getMutableStats().getBallisticWeaponFluxCostMod().modifyMult(id, 0f);		//实弹武器幅能消耗
		fighter.getMutableStats().getMissileWeaponFluxCostMod().modifyMult(id, 0f);			//导弹类武器幅能消耗
		fighter.getMutableStats().getBeamWeaponFluxCostMult().modifyMult(id, 0f);			//光束武器幅能消耗
		
		fighter.getMutableStats().getMaxSpeed().modifyMult(id, 3f);							//最大速度
		fighter.getMutableStats().getAcceleration().modifyMult(id, 3f);						//加速度
		fighter.getMutableStats().getDeceleration().modifyMult(id, 3f);						//减速
		fighter.getMutableStats().getTurnAcceleration().modifyMult(id, 3f);					//转向加速度
		fighter.getMutableStats().getMaxTurnRate().modifyMult(id, 3f);						//最大转向速率
		
		fighter.getMutableStats().getArmorBonus().modifyMult(id, 1f);                        //装甲
		fighter.getMutableStats().getHullBonus().modifyMult(id, 1f);                        //耐久,结构
		fighter.getMutableStats().getShieldDamageTakenMult().modifyMult(id, 1f);			//护盾承受伤害系数
		
		fighter.getMutableStats().getMissileHealthBonus().modifyMult(id, 10f);				//导弹生命值
		fighter.getMutableStats().getMissileMaxSpeedBonus().modifyMult(id, 1f);				//导弹最大速度加成
		fighter.getMutableStats().getMissileAccelerationBonus().modifyMult(id, 1f);			//导弹加速度
		fighter.getMutableStats().getMissileMaxTurnRateBonus().modifyMult(id, 1f);			//导弹最大转向速度
		fighter.getMutableStats().getMissileTurnAccelerationBonus().modifyMult(id, 1f);		//导弹转向加速度
		fighter.getMutableStats().getMissileGuidance().modifyMult(id, 1f);					//导弹制导
	}

	public void advanceInCombat(ShipAPI ship, float amount) 
	{
		if (!ship.isAlive()) return;
		
		CombatEngineAPI engine = Global.getCombatEngine();
		if (engine == null || engine.isPaused()) return;

		ShipData data = getShipData(engine, ship.getId());

		// 缓存（首次或必要时）
		if (data.fluxMaxCache < 0f) data.fluxMaxCache = ship.getFluxTracker().getMaxFlux();
		if (data.collRadiusCache < 0f) data.collRadiusCache = ship.getCollisionRadius();
		if (data.weaponsCache == null) {
			List<WeaponAPI> tempList = ship.getAllWeapons();
			WeaponAPI[] tempArray = new WeaponAPI[tempList.size()];
			tempList.toArray(tempArray);
			data.weaponsCache = tempArray;
		}
		if (data.armorGridCache == null && ship.getArmorGrid() != null) {
			data.armorGridCache = ship.getArmorGrid().getGrid();
			data.cellMaxCache = ship.getArmorGrid().getMaxArmorInCell();
		}

		// ===================== 装甲/结构恢复（每0.25s直满） =====================
		data.regenT += amount;
		if (data.regenT >= ARMOR_TICK_SECONDS) {
			data.regenT = 0f;
			if (data.armorGridCache != null && data.cellMaxCache > 0f) {
				for (float[] row : data.armorGridCache) {
					for (int i = 0; i < row.length; i++) {
						row[i] = data.cellMaxCache;
					}
				}
				ship.syncWithArmorGridState();
			}
			ship.setHitpoints(ship.getMaxHitpoints());
		}

		// ===================== 新弹药逻辑：每个武器用完（弹药=0）后开始计时，10秒后补满 =====================
		if (data.weaponsCache != null) {
			for (WeaponAPI w : data.weaponsCache) {
				if (w != null && w.usesAmmo() && w.getMaxAmmo() > 0) {  // 防止无限弹药武器干扰
					String wid = w.getSlot().getId() + "_" + ship.getId();  // 用武器槽ID + 舰船ID 确保唯一
					
					if (w.getAmmo() == 0) {
						// Janino终极兼容写法：Map值用Object，手动cast
						Object o = data.weaponAmmoTimer.get(wid);
						float timer = 0f;
						if (o instanceof Float) {
							timer = (Float) o;
						}
						timer += amount;
						data.weaponAmmoTimer.put(wid, timer);  // auto box to Float -> Object
						
						if (timer >= AMMO_REGEN_DELAY) {
							w.setAmmo(w.getMaxAmmo());
							data.weaponAmmoTimer.remove(wid);  // 补满后清除计时
						}
					} else {
						// 弹药未用完，重置计时
						data.weaponAmmoTimer.remove(wid);
					}
				}
			}
		}

		// ===================== 过载EMP圆环 =====================
		if (RING_ON_OVERLOAD_ENABLED && ship.getFluxTracker() != null) {
			boolean isOver = ship.getFluxTracker().isOverloaded();
			if (isOver && !data.prevOver) {
				data.ringT = 0f;
				data.visT = 0f;
				data.spawnedShock = false;
			}
			data.prevOver = isOver;

			if (data.ringT >= 0f) {
				data.ringT += amount;
				if (data.ringT >= RING_DURATION) {
					data.ringT = -1f;
					return;
				}

				data.visT += amount;
				if (data.visT < RING_VIS_STEP_SECONDS) return;
				data.visT = 0f;

				ShipAPI player = engine.getPlayerShip();
				boolean farAway = player == null || Misc.getDistance(ship.getLocation(), player.getLocation()) > RING_MAX_RENDER_DISTANCE;

				Vector2f center = ship.getLocation();
				float progress = data.ringT / RING_DURATION;
				float curR = RING_MAX_RADIUS * progress;

				if (!farAway) {
					// 爆心（仅一次）
					if (!data.spawnedShock) {
						data.spawnedShock = true;
						engine.spawnExplosion(center, new Vector2f(), Color.WHITE, 
							Math.max(120f, data.collRadiusCache * 0.6f), 0.25f);
						engine.addSmoothParticle(center, new Vector2f(), 
							Math.max(200f, data.collRadiusCache), 1.2f, 0.15f, new Color(255,240,220,255));
					}

					// 冲击波
					float ringSize = 30f + curR * 0.06f;
					float bright = 0.8f * (1f - progress);
					for (int i = 0; i < RING_DOTS_PER_STEP; i++) {
						float ang = (360f / RING_DOTS_PER_STEP) * i + (float)Math.random() * 4f;
						float rad = (float) Math.toRadians(ang);
						Vector2f loc = new Vector2f(center.x + (float)Math.cos(rad) * curR, center.y + (float)Math.sin(rad) * curR);
						engine.addSmoothParticle(loc, new Vector2f(), ringSize, bright, 0.4f, SHOCKWAVE_COLOR);
					}

					// 电弧
					float baseAng = engine.getTotalElapsedTime(false) * 120f % 360f;
					for (int i = 0; i < RING_ARCS_PER_STEP; i++) {
						float ang = baseAng + (360f / RING_ARCS_PER_STEP) * i + (float)Math.random() * 8f;
						float rad = (float) Math.toRadians(ang);
						Vector2f loc = new Vector2f(center.x + (float)Math.cos(rad) * curR, center.y + (float)Math.sin(rad) * curR);
						engine.spawnEmpArcVisual(center, ship, loc, null, RING_THICKNESS_VIS, RING_FRINGE_COLOR, RING_CORE_COLOR);
					}

					// 余烬
					for (int i = 0; i < SPARKS_PER_STEP; i++) {
						float ang = (float)(Math.random() * 360f);
						float rad = (float) Math.toRadians(ang);
						Vector2f loc = new Vector2f(center.x + (float)Math.cos(rad) * curR, center.y + (float)Math.sin(rad) * curR);
						Vector2f vel = new Vector2f((float)Math.cos(rad) * (80f + (float)Math.random()*120f), (float)Math.sin(rad) * (80f + (float)Math.random()*120f));
						float size = 6f + (float)Math.random()*10f;
						engine.addHitParticle(loc, vel, size, 0.8f, 0.35f + (float)Math.random()*0.4f, SPARK_COLOR);
					}
				}

				// 纯辐能结算（全场遍历，包含敌方舰载机）
				if (data.fluxMaxCache > 0f) {
					float bandHalf = RING_BAND_WIDTH * 0.5f;
					List<ShipAPI> ships = engine.getShips();
					for (ShipAPI other : ships) {
						if (other == null || !other.isAlive() || other.getOwner() == ship.getOwner()) continue;  // 只针对敌方（包含战机）
						
						float dist = Misc.getDistance(center, other.getLocation());
						if (Math.abs(dist - curR) > bandHalf) continue;
						
						float edge = Math.abs(dist - curR) / bandHalf;
						float t = Math.max(0f, 1f - edge);
						float flux = data.fluxMaxCache * (RING_FLUX_MIN + (RING_FLUX_MAX - RING_FLUX_MIN) * t);
						if (flux > 0f) other.getFluxTracker().increaseFlux(flux, RING_FLUX_HARD);
					}
				}
			}
		}
	}
	
	private ShipData getShipData(CombatEngineAPI engine, String shipId) {
		String key = SHIP_DATA_KEY + shipId;
		Object obj = engine.getCustomData().get(key);
		if (obj instanceof ShipData) return (ShipData) obj;
		ShipData data = new ShipData();
		engine.getCustomData().put(key, data);
		return data;
	}
}