#include "include/resource_constants.as"

import resources;
import attributes;
from saving import SaveVersion;

//Amount of money spent in welfare that gives you one influence stock
const int MONEY_PER_INFLUENCE = 350;

//Amount of money spent in welfare that gives you one energy stock
const int MONEY_PER_ENERGY = 350;

//Amount of money spent in welfare that gives you one research stock
const int MONEY_PER_RESEARCH = 350;

//Amount of money spent in welfare that gives you one labor generation on the homeworld
const int MONEY_PER_HW_LABOR = 350;

//Amount of money spent in welfare that gives you one global defense generation
const int MONEY_PER_DEFENSE = 350;

tidy class EnergyFloat {
	Empire@ forEmp;
	double amount;
};

tidy class ResourceManager : Component_ResourceManager, Savable {
	Mutex popMutex;
	Mutex budgetMutex;
	Mutex ftlMutex;
	Mutex energyMutex;

	double Population = 0;

	double FTL_Capacity = 0;
	double FTL_Stored = 0;
	double FTL_Income = 0;
	double FTL_Use = 0;

	double Energy_Stored = 0;
	double Energy_Income = 0;
	double Energy_Use = 0;
	double Energy_Allocated = 0;
	array<EnergyFloat@> floatedEnergy;

	int Budget_Total = 0;
	int Maintenance = 0;
	int PrevBudget = 0;
	int PrevMaintenance = 0;
	int Budget_Remaining = 0;
	int Budget_Forward = 0;
	int Budget_CycleId = 0;
	int Budget_Bonus = 0;
	int Budget_CycleBonus = 0;
	double Budget_Cycle = 3.0 * 60.0;
	double Budget_Tick = Budget_Cycle - 0.2;
	double Borrow_Rate = 1.5;

	double StatRecordDelay = 5.0;

	uint welfareMode = WM_Influence;
	int welfareInfluence = 0, welfareEnergy = 0, welfareResearch = 0, welfareHWLabor = 0, welfareDefense = 0;
	int storedWelfare = 0;

	array<int> moneyTypes = array<int>(MoT_COUNT, 0);

	void load(SaveFile& msg) {
		msg >> Population;

		msg >> FTL_Capacity;
		msg >> FTL_Stored;
		msg >> FTL_Income;
		if(msg >= SV_0009)
			msg >> FTL_Use;

		msg >> Energy_Stored;
		msg >> Energy_Income;
		msg >> Energy_Use;
		if(msg >= SV_0055)
			msg >> Energy_Allocated;

		msg >> Budget_Total;
		msg >> Maintenance;
		msg >> PrevBudget;
		msg >> PrevMaintenance;
		msg >> Budget_Remaining;
		msg >> Budget_Forward;
		msg >> Budget_CycleId;
		msg >> Budget_Cycle;
		msg >> Budget_Tick;
		msg >> Borrow_Rate;
		msg >> Budget_Bonus;
		msg >> Budget_CycleBonus;

		msg >> StatRecordDelay;

		msg >> welfareMode;
		msg >> welfareInfluence;
		if(msg > SV_0003) {
			msg >> welfareEnergy;
			msg >> welfareResearch;
			msg >> welfareHWLabor;
		}
		if(msg >= SV_0125)
			msg >> welfareDefense;
		msg >> storedWelfare;

		for(uint i = 0; i < MoT_COUNT-1; ++i)
			msg >> moneyTypes[i];
		if(msg >= SV_0070)
			msg >> moneyTypes[MoT_Vassals];

		if(msg >= SV_0067) {
			uint cnt = 0;
			msg >> cnt;
			floatedEnergy.length = cnt;
			for(uint i = 0; i < cnt; ++i) {
				EnergyFloat flt;
				msg >> flt.forEmp;
				msg >> flt.amount;
				@floatedEnergy[i] = flt;
			}
		}
	}
	
	void save(SaveFile& msg) {
		msg << Population;

		msg << FTL_Capacity;
		msg << FTL_Stored;
		msg << FTL_Income;
		msg << FTL_Use;

		msg << Energy_Stored;
		msg << Energy_Income;
		msg << Energy_Use;
		msg << Energy_Allocated;

		msg << Budget_Total;
		msg << Maintenance;
		msg << PrevBudget;
		msg << PrevMaintenance;
		msg << Budget_Remaining;
		msg << Budget_Forward;
		msg << Budget_CycleId;
		msg << Budget_Cycle;
		msg << Budget_Tick;
		msg << Borrow_Rate;
		msg << Budget_Bonus;
		msg << Budget_CycleBonus;

		msg << StatRecordDelay;

		msg << welfareMode;
		msg << welfareInfluence;
		msg << welfareEnergy;
		msg << welfareResearch;
		msg << welfareHWLabor;
		msg << welfareDefense;
		msg << storedWelfare;

		for(uint i = 0; i < MoT_COUNT; ++i)
			msg << moneyTypes[i];

		uint cnt = floatedEnergy.length;
		msg << cnt;
		for(uint i = 0; i < cnt; ++i) {
			msg << floatedEnergy[i].forEmp;
			msg << floatedEnergy[i].amount;
		}
	}

	//Population
	double get_EstTotalPopulation() const {
		return max(round(Population / 10.0), 1.0) * 10.0;
	}

	double get_TotalPopulation() const {
		return Population;
	}

	void modTotalPopulation(Empire& emp, double amount) {
		Lock lock(popMutex);
		Population += amount;
	}

	//FTL
	double get_FTLIncome() {
		return FTL_Income;
	}

	double get_FTLStored() {
		return FTL_Stored;
	}

	double get_FTLCapacity() {
		return FTL_Capacity;
	}

	double get_FTLUse(const Empire& emp) {
		return FTL_Use * emp.FTLCostFactor;
	}

	double consumeFTL(Empire& emp, double amount, bool consumePartial = true, bool record = true) {
		if(!consumePartial && FTL_Stored < amount)
			return 0.0;
		Lock lock(ftlMutex);
		amount = min(FTL_Stored, amount);
		FTL_Stored -= amount;
		if(amount > 0 && record)
			emp.modAttribute(EA_FTLEnergySpent, AC_Add, amount);
		return amount;
	}

	void modFTLCapacity(double amount) {
		Lock lock(ftlMutex);
		FTL_Capacity += amount;
	}

	void modFTLStored(double amount, bool obeyMaximum = false) {
		Lock lock(ftlMutex);
		if(obeyMaximum)
			FTL_Stored = clamp(FTL_Stored + amount, 0.0, max(FTL_Capacity, FTL_Stored));
		else
			FTL_Stored = max(FTL_Stored + amount, 0.0);
	}

	void modFTLIncome(double amount) {
		Lock lock(ftlMutex);
		FTL_Income += amount;
	}

	bool get_FTLShortage(const Empire& emp) const {
		return FTL_Stored <= 0.0001 && (FTL_Use * emp.FTLCostFactor) > FTL_Income + 0.0001;
	}

	bool isFTLShortage(const Empire& emp, double amt) const {
		if(FTL_Use + amt <= FTL_Income + 0.0001)
			return false;

		//Only not a shortage if we can run it for at least a minute
		double cons = (FTL_Use + amt) * emp.FTLCostFactor * 60.0;
		double have = FTL_Stored + FTL_Income * 60.0;
		return cons >= have;
	}

	bool consumeFTLUse(Empire& emp, double amt) {
		Lock lock(ftlMutex);
		if(FTL_Use + amt <= FTL_Income + 0.0001) {
			FTL_Use += amt;
			return true;
		}

		//Only not a shortage if we can run it for at least a minute
		double cons = (FTL_Use + amt) * emp.FTLCostFactor * 60.0;
		double have = FTL_Stored + FTL_Income * 60.0;
		if(cons >= have)
			return false;

		FTL_Use += amt;
		return true;
	}

	void modFTLUse(double amount) {
		Lock lock(ftlMutex);
		FTL_Use += amount;
	}

	//Energy
	double get_EnergyIncome(Empire& emp) {
		return Energy_Income * emp.EnergyGenerationFactor;
	}

	double get_EnergyStored() {
		return Energy_Stored;
	}

	double get_EnergyUse() {
		return Energy_Use;
	}

	double get_EnergyEfficiency(Empire& emp) {
		return pow(0.5, max(Energy_Stored + Energy_Allocated - emp.FreeEnergyStorage, 0.0) / config::ENERGY_EFFICIENCY_STEP);
	}

	bool get_EnergyShortage(Empire& emp) {
		return Energy_Stored <= 0.0001 && Energy_Use > (Energy_Income * emp.EnergyGenerationFactor) + 0.0001;
	}

	bool isEnergyShortage(Empire& emp, double amt) {
		if(Energy_Use + amt <= (Energy_Income * emp.EnergyGenerationFactor) + 0.0001)
			return false;

		//Only not a shortage if we can run it for at least a minute
		double cons = (Energy_Use + amt) * 60.0;
		double have = Energy_Stored + Energy_Income * 60.0 * emp.EnergyGenerationFactor;
		return cons >= have;
	}

	bool consumeEnergyUse(Empire& emp, double amt) {
		Lock lock(energyMutex);
		if(Energy_Use + amt <= (Energy_Income * emp.EnergyGenerationFactor) + 0.0001) {
			Energy_Use += amt;
			return true;
		}

		//Only not a shortage if we can run it for at least a minute
		double cons = (Energy_Use + amt) * 60.0;
		double have = Energy_Stored + Energy_Income * 60.0 * emp.EnergyGenerationFactor;
		if(cons >= have)
			return false;

		Energy_Use += amt;
		return true;
	}

	double consumeEnergy(double amount, bool consumePartial = true) {
		if(!consumePartial && Energy_Stored < amount)
			return 0.0;
		Lock lock(energyMutex);
		amount = min(Energy_Stored, amount);
		Energy_Stored -= amount;
		for(uint i = 0, cnt = floatedEnergy.length; i < cnt && amount > 0; ++i) {
			auto@ flt = floatedEnergy[i];
			double take = min(flt.amount, amount);

			if(take != 0) {
				flt.amount -= take;
				amount -= take;
				flt.forEmp.modEnergyAllocated(-take);

				if(flt.amount < 0.001) {
					floatedEnergy.removeAt(i);
					--i; --cnt;
				}
			}
		}
		return amount;
	}

	void addFloatedEnergy(Empire@ forEmp, double value) {
		EnergyFloat flt;
		@flt.forEmp = forEmp;
		flt.amount = value;
		floatedEnergy.insertLast(flt);
	}

	void modEnergyAllocated(double amount) {
		Lock lock(energyMutex);
		Energy_Allocated += amount;
	}

	void modEnergyStored(double amount) {
		Lock lock(energyMutex);
		Energy_Stored = max(Energy_Stored + amount, 0.0);
	}

	void modEnergyIncome(double amount) {
		Lock lock(energyMutex);
		Energy_Income += amount;
	}

	void modEnergyUse(double amount) {
		Lock lock(energyMutex);
		Energy_Use += amount;
	}

	//Budget
	int get_TotalBudget() {
		return Budget_Total;
	}

	int get_MaintenanceBudget() {
		return Maintenance;
	}

	int get_RemainingBudget() {
		return Budget_Remaining;
	}

	int get_ForwardBudget() {
		return Budget_Forward;
	}

	int get_BonusBudget() {
		return Budget_Bonus;
	}

	double get_BorrowRate() {
		return Borrow_Rate;
	}

	void multBorrowPenalty(double multiply) {
		Borrow_Rate = 1.0 + (Borrow_Rate - 1.0) * multiply;
	}

	double get_BudgetCycle() {
		return Budget_Cycle;
	}

	double get_BudgetTimer() {
		return Budget_Tick;
	}

	float get_DebtFactor() {
		auto remaining = Budget_Remaining - Budget_Bonus;
		if(remaining >= 0)
			return 0.f;
		if(Budget_Total < 100)
			return float(-remaining) / 100.f;
		return float(-remaining) / float(Budget_Total);
	}

	int getMoneyFromType(uint type) {
		if(type < MoT_COUNT)
			return moneyTypes[type];
		return 0;
	}

	int get_EstNextBudget() const {
		int budget = Budget_Total - Maintenance + Budget_Forward;
		budget += min(Budget_Remaining - min(PrevBudget - PrevMaintenance, 0), 0);
		return budget;
	}

	int getEstBudgetConsuming(int amount) const {
		int budget = Budget_Total - Maintenance + Budget_Forward;
		budget += min(Budget_Remaining - amount - min(PrevBudget - PrevMaintenance, 0), 0);
		return budget;
	}

	void addBonusBudget(Empire& emp, int amount) {
		amount = floor(double(amount) * emp.SpecialFundsFactor);

		Lock lock(budgetMutex);
		Budget_Bonus += amount;
		Budget_CycleBonus += amount;
		Budget_Remaining += amount;
	}

	int get_BudgetCycleId() {
		return Budget_CycleId;
	}
	
	uint get_WelfareMode() const {
		return welfareMode;
	}
	
	void set_WelfareMode(uint mode) {
		welfareMode = mode;
	}

	int consumeBudget(int amount, bool borrow) {
		if(amount == 0)
			return Budget_CycleId;
		Lock lock(budgetMutex);
		if(Budget_Remaining >= amount) {
			Budget_Remaining -= amount;
			Budget_Bonus = max(Budget_Bonus - amount, 0);
			return Budget_CycleId;
		}
		else {
			if(!borrow)
				return -1;
			int borrowAmount = amount;
			if(Budget_Remaining > 0)
				borrowAmount -= Budget_Remaining;
			int borrowCost = ceil(double(borrowAmount) * Borrow_Rate);
			if(getEstBudgetConsuming(borrowCost) < borrowCost)
				return -1;
			Budget_Remaining -= amount;
			Budget_Bonus = max(Budget_Bonus - amount, 0);
			Budget_Forward -= (borrowCost - borrowAmount);
			return Budget_CycleId;
		}
	}

	int lowerBudget(int amount) {
		Lock lock(budgetMutex);
		if(Budget_Remaining >= amount) {
			Budget_Remaining -= amount;
			Budget_Bonus = max(Budget_Bonus - amount, 0);
			return Budget_CycleId;
		}
		else {
			int borrowAmount = amount;
			if(Budget_Remaining > 0)
				borrowAmount -= Budget_Remaining;
			int borrowCost = ceil(double(borrowAmount) * Borrow_Rate);
			Budget_Remaining -= amount;
			Budget_Bonus = max(Budget_Bonus - amount, 0);
			Budget_Forward -= (borrowCost - borrowAmount);
			return Budget_CycleId;
		}
	}

	bool canBorrow(int amount) const {
		if(amount == 0)
			return true;
		amount = ceil(double(amount) * Borrow_Rate);
		return getEstBudgetConsuming(amount) >= amount;
	}

	bool canPay(int amount) const {
		if(amount == 0)
			return true;
		if(amount <= Budget_Remaining)
			return true;
		return canBorrow(amount - Budget_Remaining);
	}

	void refundBudget(int amount, int cycleId) {
		Lock lock(budgetMutex);
		if(cycleId != Budget_CycleId)
			return;
		int refundedBorrow = min(amount, -Budget_Remaining);
		Budget_Remaining += amount;
		Budget_Bonus = min(Budget_Bonus + amount, Budget_CycleBonus);
		if(refundedBorrow > 0)
			Budget_Forward += round(double(refundedBorrow) * (Borrow_Rate - 1.0));
	}

	void modMaintenance(int amount, uint type = 0) {
		Lock lock(budgetMutex);
		Maintenance += amount;

		if(type < MoT_COUNT)
			moneyTypes[type] -= amount;
	}

	void modTotalBudget(Empire& emp, int amount, uint type = 0) {
		Lock lock(budgetMutex);
		Budget_Total += amount;

		if(type < MoT_COUNT)
			moneyTypes[type] += amount;
	}

	void modForwardBudget(int amount) {
		Lock lock(budgetMutex);
		Budget_Forward += amount;
	}

	void modRemainingBudget(int amount) {
		Lock lock(budgetMutex);
		Budget_Remaining += amount;
	}

	void resetBudget(Empire& emp) {
		if(Budget_CycleId != 0) {
			int remaining = Budget_Remaining + storedWelfare - Budget_Bonus;

			//New values for each welfare type
			int nwf_influence = 0, nwf_energy = 0, nwf_research = 0, nwf_hw_labor = 0, nwf_defense = 0;
			
			if(remaining > 0) {
				switch(welfareMode) {
					case WM_Influence:
					{
						double fact = MONEY_PER_INFLUENCE / emp.WelfareEfficiency;
						nwf_influence = floor(double(remaining) / fact);
						storedWelfare = remaining - (nwf_influence * fact);
					} break;
					case WM_Energy:
					{
						double fact = MONEY_PER_ENERGY / emp.WelfareEfficiency;
						nwf_energy = floor(double(remaining) / fact);
						storedWelfare = remaining - (nwf_energy * fact);
					} break;
					case WM_Research:
					{
						double fact = MONEY_PER_RESEARCH / emp.WelfareEfficiency;
						nwf_research = floor(double(remaining) / fact);
						storedWelfare = remaining - (nwf_research * fact);
					} break;
					case WM_HW_Labor:
					{
						double fact = MONEY_PER_HW_LABOR / emp.WelfareEfficiency;
						nwf_hw_labor = floor(double(remaining) / fact);
						storedWelfare = remaining - (nwf_hw_labor * fact);
					} break;
					case WM_Defense:
					{
						double fact = MONEY_PER_DEFENSE / emp.WelfareEfficiency;
						nwf_defense = floor(double(remaining) / fact);
						storedWelfare = remaining - (nwf_defense * fact);
					} break;
					default:
						storedWelfare = remaining;
					break;
				}
			}
			else {
				storedWelfare = 0;
			}
			
			if(nwf_influence != welfareInfluence) {
				emp.modInfluenceIncome(nwf_influence - welfareInfluence);
				welfareInfluence = nwf_influence;
			}
			if(nwf_energy != welfareEnergy) {
				emp.modEnergyIncome(double(nwf_energy - welfareEnergy) * TILE_ENERGY_RATE);
				welfareEnergy = nwf_energy;
			}
			if(nwf_research != welfareResearch) {
				emp.modResearchRate(double(nwf_research - welfareResearch) * TILE_RESEARCH_RATE);
				welfareResearch = nwf_research;
			}
			if(nwf_defense != welfareDefense) {
				emp.modDefenseRate(double(nwf_defense - welfareDefense) * (1.0 / 60.0));
				welfareDefense = nwf_defense;
			}
			if(nwf_hw_labor != welfareHWLabor) {
				Object@ home = emp.Homeworld;
				if(home is null) {
					@home = emp.HomeObj;
					if(home !is null && !home.hasConstruction)
						@home = null;
				}
				if(home !is null && home.valid) {
					if(home.owner !is emp) {
						//In case we lose access to our homeworld, reset the labor being sent
						nwf_hw_labor = 0;
						welfareMode = WM_Influence;
					}
					home.modLaborIncome(double(nwf_hw_labor - welfareHWLabor) * TILE_LABOR_RATE);
				}
				welfareHWLabor = nwf_hw_labor;
			}
		}

		Budget_CycleBonus = Budget_Bonus;
		Budget_Remaining = EstNextBudget + Budget_Bonus;
		PrevBudget = Budget_Total;
		PrevMaintenance = Maintenance;
		Budget_Forward = 0;
		Budget_Tick = 0;
		++Budget_CycleId;
	}

	void resourceTick(Empire& emp, double time) {
		StatRecordDelay -= time;
		
		bool recordStats = StatRecordDelay <= 0;
		if(recordStats)
			StatRecordDelay += 5.0;

		Object@ home = emp.HomeObj;
		if(home is null || !home.valid || home.owner !is emp)
			@emp.HomeObj = null;
	
		//Handle FTL income rate
		{
			Lock lock(ftlMutex);
			FTL_Stored = clamp(FTL_Stored + time * (FTL_Income - FTL_Use * emp.FTLCostFactor), 0, max(FTL_Capacity, FTL_Stored));

			if(FTL_Use > 0) {
				double usedFTL = time * min(FTL_Use * emp.FTLCostFactor, FTL_Stored + FTL_Income);
				if(usedFTL > 0)
					emp.modAttribute(EA_FTLEnergySpent, AC_Add, usedFTL);
			}
			
			if(recordStats)
				emp.recordStat(stat::FTL, float(FTL_Stored));
		}

		//Handle Energy income rate
		{
			Lock lock(energyMutex);
			double netEnergy = ((Energy_Income * emp.EnergyGenerationFactor) - Energy_Use);
			if(netEnergy > 0)
				netEnergy *= emp.EnergyEfficiency;
			Energy_Stored = max(Energy_Stored + time * netEnergy, 0.0);
			if(recordStats)
				emp.recordStat(stat::EnergyIncome, netEnergy);
		}

		//Handle budget ticks
		{
			Lock lock(budgetMutex);

			if(Budget_Tick >= Budget_Cycle) {
				double remainder = Budget_Tick - Budget_Cycle;
				resetBudget(emp);
				Budget_Tick += remainder;
			}
			else
				Budget_Tick += time;

			if(recordStats) {
				emp.recordStat(stat::Budget, float(Budget_Total));
				emp.recordStat(stat::NetBudget, float(EstNextBudget));
			}
		}

		//Handle extra stats
		if(recordStats) {
			emp.recordStat(stat::Points, emp.points.value);
			emp.recordStat(stat::Military, float(sqr(emp.TotalMilitary) * 0.001));
		}
	}

	//Networking
	void writeResources(Message& msg) {
		msg << float(Population);

		msg << float(FTL_Capacity);
		msg << float(FTL_Stored);
		msg << float(FTL_Income);
		msg << float(FTL_Use);

		msg << float(Energy_Stored);
		msg << float(Energy_Income);
		msg << float(Energy_Use);
		msg << float(Energy_Allocated);

		msg << Budget_Total;
		msg << Maintenance;
		msg << PrevMaintenance;
		msg << PrevBudget;
		msg << Budget_Remaining;
		msg << Budget_Forward;
		msg << Budget_Bonus;
		msg << Budget_CycleId;
		msg << float(Budget_Cycle);
		msg << float(Budget_Tick);
		msg << float(Borrow_Rate);
		
		for(uint i = 0; i < MoT_COUNT; ++i)
			msg.writeSignedSmall(moneyTypes[i]);
		
		msg.writeLimited(welfareMode, WM_COUNT-1);
	}
};