"""
Unit tests for FreeExile Mathematical Economic Simulation & Anti-Inflation Engine.
Validates Faucets vs Sinks equilibrium, Trade Tax Burn, and Inflation Stabilization.
"""

import unittest
from server.world.economic_simulation_engine import (
    EconomicSimulationEngine,
    EconomyState,
    CurrencyFlowType,
    DailySimulationReport,
)


class TestEconomicSimulationEngine(unittest.TestCase):
    def setUp(self):
        self.engine = EconomicSimulationEngine(initial_currency_supply=10_000_000)

    def test_initial_state_metrics(self):
        state = self.engine.get_state()
        self.assertEqual(state.total_supply, 10_000_000)
        self.assertEqual(state.sink_efficiency_ratio, 1.0)
        self.assertFalse(state.hyperinflation_warning)

    def test_simulate_balanced_day(self):
        # 100k CCU generates 1,000,000 HonNguyen (Faucet)
        # Sinks: 800k crafting + 150k trade tax burn + 50k map device = 1,000,000 (Sink)
        report = self.engine.simulate_day(
            faucets_generated=1_000_000,
            crafting_sink=800_000,
            trade_tax_sink=150_000,
            map_device_sink=50_000
        )
        self.assertAlmostEqual(report.sink_efficiency_ratio, 1.0, places=2)
        self.assertEqual(report.net_currency_delta, 0)
        self.assertFalse(report.hyperinflation_detected)

    def test_hyperinflation_triggered_when_sinks_fail(self):
        # Massive drop without sinks (SER < 0.6)
        report = self.engine.simulate_day(
            faucets_generated=5_000_000,
            crafting_sink=1_000_000,
            trade_tax_sink=200_000,
            map_device_sink=100_000
        )
        # Total sink = 1.3M / 5M = 0.26 (severe deficit)
        self.assertTrue(report.hyperinflation_detected)
        self.assertGreater(report.net_currency_delta, 3_000_000)
        self.assertIn("DEFICIT_SINK_CRITICAL", report.action_recommendation)

    def test_trade_tax_burn_permanently_destroys_currency(self):
        initial_supply = self.engine.get_state().total_supply
        trade_volume = 1_000_000
        # 5% trade fee burned
        burned = self.engine.apply_trade_tax_burn(trade_volume=trade_volume, tax_rate=0.05)
        self.assertEqual(burned, 50_000)
        self.assertEqual(self.engine.get_state().total_supply, initial_supply - 50_000)

    def test_dynamic_sink_auto_adjuster(self):
        # When inflation surges, auto adjuster increases map device fee and crafting cost
        multipliers = self.engine.calculate_dynamic_sink_multipliers(current_ser=0.5)
        self.assertGreater(multipliers.crafting_cost_multiplier, 1.0)
        self.assertGreater(multipliers.map_device_fee_multiplier, 1.0)


if __name__ == "__main__":
    unittest.main()