from __future__ import annotations

import unittest

from app.simulation.components.amesim.flow.orifices import AmesimPnvo001FixedOpening
from app.simulation.components.amesim.media.mediums import (
    AmesimHeliumPengRobinsonMedium,
)
from app.simulation.core.medium import IdealGasMedium
from app.simulation.registry import COMPONENT_MODEL_REGISTRY


class AmesimPnvo001FixedOpeningComponentTests(unittest.TestCase):
    def setUp(self) -> None:
        self.medium = IdealGasMedium()

    def test_default_create_preserves_fixed_opening_contract(self) -> None:
        valve = COMPONENT_MODEL_REGISTRY["amesim_pnvo001_fixed"].create(
            "valve_1",
            self.medium,
            {},
        )

        self.assertIsInstance(valve, AmesimPnvo001FixedOpening)
        self.assertEqual(set(valve.ports), {"port_2", "port_3"})
        self.assertEqual(
            set(valve.parameter_values),
            {"cq", "area0", "Cv", "Kv", "gi", "flowset", "opening"},
        )
        self.assertEqual(valve.opening, 1.0)

    def test_rejects_fractional_flowset(self) -> None:
        with self.assertRaisesRegex(ValueError, "must be one of"):
            COMPONENT_MODEL_REGISTRY["amesim_pnvo001_fixed"].create(
                "valve_1",
                self.medium,
                {"flowset": 1.5},
            )

    def test_opening_scales_effective_area(self) -> None:
        valve = AmesimPnvo001FixedOpening(
            "valve_1",
            self.medium,
            area0=2.0e-6,
            opening=0.25,
        )

        self.assertAlmostEqual(valve.maximum_area, 2.0e-6)
        self.assertAlmostEqual(valve.effective_area, 0.5e-6)
        self.assertEqual(valve.component_result_values()["xv"], 0.25)

    def test_zero_opening_blocks_flow(self) -> None:
        valve = AmesimPnvo001FixedOpening("valve_1", self.medium, opening=0.0)

        self.assertEqual(valve.mass_flow(500000.0, 100000.0), 0.0)

    def test_mass_flow_is_bidirectional_by_pressure_order(self) -> None:
        valve = AmesimPnvo001FixedOpening("valve_1", self.medium, opening=0.5)

        forward = valve.mass_flow(500000.0, 100000.0)
        reverse = valve.mass_flow(100000.0, 500000.0)

        self.assertGreater(forward, 0.0)
        self.assertLess(reverse, 0.0)
        self.assertAlmostEqual(forward, -reverse)

    def test_mass_flow_uses_connected_enthalpy_from_the_upstream_side(self) -> None:
        valve = AmesimPnvo001FixedOpening("valve_1", self.medium, opening=0.5)
        hot_h = self.medium.specific_enthalpy(600.0)
        cold_h = self.medium.specific_enthalpy(200.0)

        valve.update_stream_outflows({"port_2": hot_h, "port_3": cold_h})

        self.assertEqual(valve.port_2.h_outflow, cold_h)
        self.assertEqual(valve.port_3.h_outflow, hot_h)
        self.assertAlmostEqual(
            valve.mass_flow(500000.0, 100000.0),
            valve._one_way_mass_flow(
                upstream_pressure=500000.0,
                downstream_pressure=100000.0,
                upstream_temperature=600.0,
            ),
        )
        self.assertAlmostEqual(
            valve.mass_flow(100000.0, 500000.0),
            -valve._one_way_mass_flow(
                upstream_pressure=500000.0,
                downstream_pressure=100000.0,
                upstream_temperature=200.0,
            ),
        )


    def test_helium_flow_uses_pressure_enthalpy_and_real_gas_factor(self) -> None:
        medium = AmesimHeliumPengRobinsonMedium()
        valve = AmesimPnvo001FixedOpening(
            "valve_1",
            medium,
            cq=0.45,
            area0=78.5e-6,
            opening=1.0,
        )
        upstream_pressure = 15_201_996.778497815
        downstream_pressure = 405_072.8123335606
        upstream_temperature = 292.3997890954483
        valve.port_2.p = upstream_pressure
        valve.port_3.p = downstream_pressure
        upstream_enthalpy = medium.specific_enthalpy_at_pressure(
            upstream_pressure,
            upstream_temperature,
        )
        valve.update_stream_outflows(
            {
                "port_2": upstream_enthalpy,
                "port_3": medium.specific_enthalpy_at_pressure(
                    downstream_pressure,
                    393.46713105173205,
                ),
            }
        )

        self.assertLess(upstream_enthalpy, 0.0)
        self.assertAlmostEqual(
            valve._upstream_temperature("port_2"),
            upstream_temperature,
            delta=1.0e-8,
        )

        self.assertAlmostEqual(
            valve.mass_flow(upstream_pressure, downstream_pressure),
            0.49551308906777447,
            delta=1.0e-9,
        )
        results = valve.component_result_values()

        self.assertAlmostEqual(
            results["cm"],
            0.015778323343746598,
            delta=1.0e-11,
        )
        self.assertAlmostEqual(
            results["gasvel"],
            894.7011595213406,
            delta=1.0e-8,
        )


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