package data.hullmods;

import com.fs.starfarer.api.combat.BaseHullMod;
import com.fs.starfarer.api.combat.MutableShipStatsAPI;
import com.fs.starfarer.api.combat.ShieldAPI;
import com.fs.starfarer.api.combat.ShipAPI;
import com.fs.starfarer.api.combat.ShieldAPI.ShieldType;
import com.fs.starfarer.api.combat.ShipAPI.HullSize;
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.combat.WeaponAPI.WeaponType;
import com.fs.starfarer.api.util.IntervalUtil;
import com.fs.starfarer.api.util.Misc;
import com.fs.starfarer.api.combat.DamageType;

import org.lwjgl.util.vector.Vector2f;
import java.awt.Color;
import java.util.Set;
import java.util.HashSet;

//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.5f;    // 每 0.5 秒跳一次

	// ===================== 新增：方案A（技能系统冷却/回充/次数） =====================
	// 注意：方案A是在创建舰船时生效，作用于“安装了该HullMod的船”，与阵营无关
	// 冷却时间倍率（越小越快；0f=真·无冷却；推荐先用0.25f测试）
	private static final float SYSTEM_COOLDOWN_MULT = 0f; // 可改为 0f -> 0CD
	// 回充速度倍率（仅对“有充能”的系统生效）
	private static final float SYSTEM_REGEN_MULT    = 6f;    // 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; // 总开关

	// 视觉 & 动画参数
	private static final float RING_DURATION      = 1f;   // 圆环从0扩到最大所需时间（秒）
	private static final float RING_MAX_RADIUS    = 1600f;   // 扩散到的最大半径
	private static final float RING_THICKNESS_VIS = 12f;    // EMP 电弧的可视“粗细”
	private static final int   RING_ARCS_PER_TICK = 18;     // 每帧沿圆周生成多少条视觉电弧
	private static final Color RING_FRINGE_COLOR  = new Color(130, 210, 255, 200); // 外沿色
	private static final Color RING_CORE_COLOR    = new Color(255, 255, 255, 220); // 核心色

	// 纯辐能堆积参数（不造成装甲/结构伤害）
	// —— 追加说明：现在 RING_FLUX_MIN/MAX 改为“相对于船舶最大辐能上限（总辐能）的倍率” ——
	// 例如：RING_FLUX_MIN = 0.5f 表示外环为最大辐能的 0.5 倍；RING_FLUX_MAX = 2.0f 表示中心线为 2 倍
	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;   // true=硬辐能；false=软辐能
	private static final float   RING_BAND_WIDTH  = 120f;   // 环带“厚度”（越大越宽）

	// 自定义数据 key
	private static final String ARMOR_REGEN_KEY   = "superplug_armor_regen_key";
	private static final String OVERLOAD_FLAG_KEY = "superplug_overload_flag";
	private static final String RING_DATA_KEY     = "superplug_ring_data";

	private static class ArmorRegenData {
		IntervalUtil interval = new IntervalUtil(ARMOR_TICK_SECONDS, ARMOR_TICK_SECONDS);
	}
	private static class RingWave { float t = 0f; } // EMP 圆环状态

	
	@Override
	public void applyEffectsBeforeShipCreation(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().modifyMult(id, 1f);		//非光束类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, 1f);				//导弹生命值
			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, 1f);						//最大航行速度
			stats.getFuelUseMod().modifyMult(id, 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, 1f);					//战机交战范围

			// ===================== 新增：方案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, 1f);							//最大速度
			fighter.getMutableStats().getAcceleration().modifyMult(id, 1f);						//加速度
			fighter.getMutableStats().getDeceleration().modifyMult(id, 1f);						//减速
			fighter.getMutableStats().getTurnAcceleration().modifyMult(id, 1f);					//转向加速度
			fighter.getMutableStats().getMaxTurnRate().modifyMult(id, 1f);						//最大转向速率
			
			fighter.getMutableStats().getArmorBonus().modifyMult(id, 1f);                        //装甲
			fighter.getMutableStats().getHullBonus().modifyMult(id, 1f);                        //耐久,结构
			fighter.getMutableStats().getShieldDamageTakenMult().modifyMult(id, 1f);			//护盾承受伤害系数
			
			fighter.getMutableStats().getMissileHealthBonus().modifyMult(id, 1f);				//导弹生命值
			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 static String MR_DATA_KEY = "core_reload_data_key";
	
	public static class PeriodicMissileReloadData 
	{
		IntervalUtil interval = new IntervalUtil(10f, 10f);
	}

	public void advanceInCombat(ShipAPI ship, float amount) 
	{
		super.advanceInCombat(ship, amount);

		if (!ship.isAlive()) return;
		
		CombatEngineAPI engine = Global.getCombatEngine();
		if (engine == null || engine.isPaused()) return;

		// ===================== 新增：装甲/结构定时恢复（写法B） =====================
		String ak = ARMOR_REGEN_KEY + "_" + ship.getId();
		ArmorRegenData aregen = (ArmorRegenData) engine.getCustomData().get(ak);
		if (aregen == null) {
			aregen = new ArmorRegenData();
			engine.getCustomData().put(ak, aregen);
		}
		aregen.interval.advance(amount);
		if (aregen.interval.intervalElapsed() && ship.getArmorGrid() != null) {
			float[][] grid = ship.getArmorGrid().getGrid();
			if (grid != null) {
				final float cellMax = ship.getArmorGrid().getMaxArmorInCell();
				final float tick = aregen.interval.getElapsed(); // 本次间隔真实秒数

				// —— 装甲：每格按“最大值 × 比例 × 效率 × tick”恢复 ——
				final float armorDelta = cellMax * ARMOR_REGEN_BASE_PER_SEC * ARMOR_REGEN_EFFICIENCY * tick;
				for (int x = 0; x < grid.length; x++) {
					for (int y = 0; y < grid[0].length; y++) {
						float v = grid[x][y] + armorDelta;
						if (v > cellMax) v = cellMax;
						grid[x][y] = v;
					}
				}
				// —— 结构：按“最大结构 × 比例 × 效率 × tick”恢复 ——
				float hp = ship.getHitpoints();
				float hpMax = ship.getMaxHitpoints();
				if (hp < hpMax) {
					final float hullDelta = hpMax * HULL_REGEN_BASE_PER_SEC * HULL_REGEN_EFFICIENCY * tick;
					ship.setHitpoints(Math.min(hpMax, hp + hullDelta));
				}

				ship.syncWithArmorGridState(); // 同步显示
			}
		}

		// ===================== 过载触发：EMP圆环扩散（视觉+纯辐能，不伤友军） =====================
		if (RING_ON_OVERLOAD_ENABLED && ship.getFluxTracker() != null) {
			String ok = OVERLOAD_FLAG_KEY + "_" + ship.getId();
			boolean wasOver = Boolean.TRUE.equals(engine.getCustomData().get(ok));
			boolean isOver  = ship.getFluxTracker().isOverloaded();

			if (isOver && !wasOver) {
				// 进入过载瞬间：启动一条环波
				String rk = RING_DATA_KEY + "_" + ship.getId();
				engine.getCustomData().put(rk, new RingWave());
			}
			if (isOver != wasOver) {
				engine.getCustomData().put(ok, isOver);
			}

			// 推进&渲染&结算：如果环波存在则推进
			String rk = RING_DATA_KEY + "_" + ship.getId();
			Object obj = engine.getCustomData().get(rk);
			if (obj instanceof RingWave) {
				RingWave ring = (RingWave) obj;
				ring.t += amount;

				if (ring.t >= RING_DURATION) {
					engine.getCustomData().remove(rk); // 结束
				} else {
					float progress = ring.t / RING_DURATION;
					float curR = RING_MAX_RADIUS * progress;

					// —— 视觉：沿圆周撒 EMP 电弧（只视觉，不造成额外伤害）
					Vector2f center = ship.getLocation();
					float baseAngle = (engine.getTotalElapsedTime(false) * 360f) % 360f; // 轻微旋转感
					for (int i = 0; i < RING_ARCS_PER_TICK; i++) {
						float ang = baseAngle + (360f / RING_ARCS_PER_TICK) * i;
						float rad = (float) Math.toRadians(ang);
						Vector2f to = new Vector2f(
								center.x + (float) Math.cos(rad) * curR,
								center.y + (float) Math.sin(rad) * curR
						);
						engine.spawnEmpArcVisual(center, ship, to, null, RING_THICKNESS_VIS, RING_FRINGE_COLOR, RING_CORE_COLOR);
					}

					// —— 纯辐能结算：只在“当前半径±半宽”的环带内，对敌方单位堆辐能
					float bandHalf = RING_BAND_WIDTH * 0.5f;
					for (ShipAPI other : engine.getShips()) {
						if (other == null || !other.isAlive()) continue;
						if (other.getOwner() == ship.getOwner()) continue; // 不伤友军

						float dist = Misc.getDistance(ship.getLocation(), other.getLocation());
						if (Math.abs(dist - curR) > bandHalf) continue; // 不在环带上

						float edge = Math.abs(dist - curR) / bandHalf; // 0~1
						float t = Math.max(0f, 1f - edge);            // 环带中心 t=1，外缘→0

						// === 改动：按“船舶最大辐能上限 × 线性插值(最小/最大倍率)”结算 ===
						float emitterMaxFlux = ship.getFluxTracker().getMaxFlux(); // 船舶总辐能上限（最大辐能）
						float multiplier = RING_FLUX_MIN + (RING_FLUX_MAX - RING_FLUX_MIN) * t;
						float flux = emitterMaxFlux * multiplier;

						if (other.getFluxTracker() != null && flux > 0f) {
							other.getFluxTracker().increaseFlux(flux, RING_FLUX_HARD);
						}
					}
				}
			}
		}

		
		// ===================== 弹药工厂（每10秒：0弹瞬满） =====================
		String key = MR_DATA_KEY + "_" + ship.getId();
		PeriodicMissileReloadData data = (PeriodicMissileReloadData) engine.getCustomData().get(key);
		if (data == null) 
		{
			data = new PeriodicMissileReloadData();
			engine.getCustomData().put(key, data);
		}
		data.interval.advance(amount);
		if (data.interval.intervalElapsed()) 
		{
			for (WeaponAPI w : ship.getAllWeapons()) 
			{
				if (w.usesAmmo() && w.getAmmo() < w.getMaxAmmo()) 
				{
					if(w.getAmmo() == 0)
					{
					 w.setAmmo(w.getMaxAmmo());			
					}
				}
			}
		}
	}
	


}