"""Entropyk — Unit Tests for Component Wrappers.

Tests for all component constructors, validation, and repr.
"""

import pytest
import entropyk


class TestCompressor:
    """Tests for Compressor component."""

    def test_default(self):
        c = entropyk.Compressor()
        assert "Compressor" in repr(c)

    def test_custom_params(self):
        c = entropyk.Compressor(speed_rpm=3600.0, efficiency=0.9, fluid="R410A")
        assert c.speed == 3600.0
        assert c.efficiency_value == pytest.approx(0.9)
        assert c.fluid_name == "R410A"

    def test_negative_speed_raises(self):
        with pytest.raises(ValueError, match="positive"):
            entropyk.Compressor(speed_rpm=-1.0)

    def test_negative_displacement_raises(self):
        with pytest.raises(ValueError, match="positive"):
            entropyk.Compressor(displacement=-1.0)

    def test_invalid_efficiency_raises(self):
        with pytest.raises(ValueError, match="between"):
            entropyk.Compressor(efficiency=1.5)

    def test_repr(self):
        c = entropyk.Compressor(speed_rpm=2900.0, efficiency=0.85, fluid="R134a")
        r = repr(c)
        assert "2900" in r
        assert "0.85" in r
        assert "R134a" in r


class TestCondenser:
    """Tests for Condenser component."""

    def test_default(self):
        c = entropyk.Condenser()
        assert c.ua_value == pytest.approx(5000.0)

    def test_custom_ua(self):
        c = entropyk.Condenser(ua=10000.0)
        assert c.ua_value == pytest.approx(10000.0)

    def test_negative_ua_raises(self):
        with pytest.raises(ValueError, match="positive"):
            entropyk.Condenser(ua=-1.0)

    def test_repr(self):
        c = entropyk.Condenser(ua=5000.0)
        assert "Condenser" in repr(c)
        assert "5000" in repr(c)


class TestEvaporator:
    """Tests for Evaporator component."""

    def test_default(self):
        e = entropyk.Evaporator()
        assert e.ua_value == pytest.approx(3000.0)

    def test_custom_ua(self):
        e = entropyk.Evaporator(ua=8000.0)
        assert e.ua_value == pytest.approx(8000.0)

    def test_negative_ua_raises(self):
        with pytest.raises(ValueError, match="positive"):
            entropyk.Evaporator(ua=-1.0)

    def test_repr(self):
        e = entropyk.Evaporator(ua=3000.0)
        assert "Evaporator" in repr(e)


class TestEconomizer:
    """Tests for Economizer component."""

    def test_default(self):
        e = entropyk.Economizer()
        assert "Economizer" in repr(e)

    def test_custom_ua(self):
        e = entropyk.Economizer(ua=5000.0)
        assert "5000" in repr(e)

    def test_negative_ua_raises(self):
        with pytest.raises(ValueError, match="positive"):
            entropyk.Economizer(ua=-1.0)


class TestExpansionValve:
    """Tests for ExpansionValve component."""

    def test_default(self):
        v = entropyk.ExpansionValve()
        assert v.fluid_name == "R134a"
        assert v.opening_value is None

    def test_with_opening(self):
        v = entropyk.ExpansionValve(opening=0.5)
        assert v.opening_value == pytest.approx(0.5)

    def test_invalid_opening_raises(self):
        with pytest.raises(ValueError, match="between"):
            entropyk.ExpansionValve(opening=1.5)

    def test_repr(self):
        v = entropyk.ExpansionValve(fluid="R410A", opening=0.8)
        assert "ExpansionValve" in repr(v)
        assert "R410A" in repr(v)


class TestPipe:
    """Tests for Pipe component."""

    def test_default(self):
        p = entropyk.Pipe()
        assert "Pipe" in repr(p)

    def test_custom_params(self):
        p = entropyk.Pipe(length=5.0, diameter=0.025)
        assert "5.00" in repr(p)

    def test_negative_length_raises(self):
        with pytest.raises(ValueError, match="positive"):
            entropyk.Pipe(length=-1.0)

    def test_negative_diameter_raises(self):
        with pytest.raises(ValueError, match="positive"):
            entropyk.Pipe(diameter=-0.01)


class TestPump:
    """Tests for Pump component."""

    def test_default(self):
        p = entropyk.Pump()
        assert "Pump" in repr(p)

    def test_negative_pressure_raises(self):
        with pytest.raises(ValueError, match="positive"):
            entropyk.Pump(pressure_rise_pa=-100.0)

    def test_invalid_efficiency_raises(self):
        with pytest.raises(ValueError, match="between"):
            entropyk.Pump(efficiency=2.0)


class TestFan:
    """Tests for Fan component."""

    def test_default(self):
        f = entropyk.Fan()
        assert "Fan" in repr(f)

    def test_negative_pressure_raises(self):
        with pytest.raises(ValueError, match="positive"):
            entropyk.Fan(pressure_rise_pa=-100.0)


class TestFlowSplitter:
    """Tests for FlowSplitter component."""

    def test_default(self):
        s = entropyk.FlowSplitter()
        assert "FlowSplitter" in repr(s)

    def test_custom_outlets(self):
        s = entropyk.FlowSplitter(n_outlets=3)
        assert "3" in repr(s)

    def test_too_few_outlets_raises(self):
        with pytest.raises(ValueError, match=">="):
            entropyk.FlowSplitter(n_outlets=1)


class TestFlowMerger:
    """Tests for FlowMerger component."""

    def test_default(self):
        m = entropyk.FlowMerger()
        assert "FlowMerger" in repr(m)

    def test_custom_inlets(self):
        m = entropyk.FlowMerger(n_inlets=4)
        assert "4" in repr(m)

    def test_too_few_inlets_raises(self):
        with pytest.raises(ValueError, match=">="):
            entropyk.FlowMerger(n_inlets=1)


class TestFlowSource:
    """Tests for FlowSource component."""

    def test_default(self):
        s = entropyk.FlowSource()
        assert "FlowSource" in repr(s)

    def test_custom(self):
        s = entropyk.FlowSource(pressure_pa=200000.0, temperature_k=350.0)
        assert "200000" in repr(s)

    def test_negative_pressure_raises(self):
        with pytest.raises(ValueError, match="positive"):
            entropyk.FlowSource(pressure_pa=-1.0)


class TestFlowSink:
    """Tests for FlowSink component."""

    def test_default(self):
        s = entropyk.FlowSink()
        assert "FlowSink" in repr(s)


class TestOperationalState:
    """Tests for OperationalState enum."""

    def test_on(self):
        s = entropyk.OperationalState("on")
        assert str(s) == "On"

    def test_off(self):
        s = entropyk.OperationalState("off")
        assert str(s) == "Off"

    def test_bypass(self):
        s = entropyk.OperationalState("bypass")
        assert str(s) == "Bypass"

    def test_invalid_raises(self):
        with pytest.raises(ValueError, match="one of"):
            entropyk.OperationalState("invalid")

    def test_eq(self):
        s1 = entropyk.OperationalState("on")
        s2 = entropyk.OperationalState("on")
        assert s1 == s2