"""
Tests for SM T0/T1 memory tier split.

Verifies acceptance criteria:
- token-migration.AC4.1: SM operations on T1 (< tier_boundary) use I-structure semantics
- token-migration.AC4.2: SM WRITE to T0 (>= tier_boundary) stores data without presence checking
- token-migration.AC4.3: SM READ on T0 address returns immediately (no deferral)
- token-migration.AC4.4: T0 storage is shared across all SMs
- token-migration.AC4.5: I-structure ops (CLEAR, ALLOC, FREE, atomics) on T0 produce error/warning
- token-migration.AC4.6: Tier boundary is configurable via SMConfig; default is 256
- token-migration.AC6.2: Existing I-structure behaviour unchanged (is_wide=False path)
"""

import simpy

from cm_inst import MemOp
from emu import build_topology
from emu.sm import StructureMemory
from emu.types import SMConfig
from sm_mod import Presence
from tokens import CMToken, SMToken


def inject_token(env: simpy.Environment, store: simpy.Store, token):
    """Helper to inject token into store via a process."""
    def _injector():
        yield store.put(token)

    env.process(_injector())


class TestAC4_1T1IStructureSemantics:
    """AC4.1: SM READ on T1 (< tier_boundary) uses I-structure semantics."""

    def test_t1_read_on_full_returns_immediately(self):
        """READ on T1 full cell returns data immediately."""
        env = simpy.Environment()
        sm = StructureMemory(env, 0, cell_count=512, tier_boundary=256)

        # Pre-populate T1 cell (addr < 256) to FULL
        t1_addr = 100
        sm.cells[t1_addr].pres = Presence.FULL
        sm.cells[t1_addr].data_l = 0x1111

        collector = simpy.Store(env)
        sm.route_table[0] = collector

        ret_route = CMToken(target=0, offset=0, act_id=0, data=0)
        read_token = SMToken(target=0, addr=t1_addr, op=MemOp.READ, flags=None, data=None, ret=ret_route)
        inject_token(env, sm.input_store, read_token)

        env.run(until=100)

        assert len(collector.items) == 1
        assert collector.items[0].data == 0x1111

    def test_t1_read_on_empty_defers_and_sets_waiting(self):
        """READ on T1 empty cell sets WAITING and stashes return route."""
        env = simpy.Environment()
        sm = StructureMemory(env, 0, cell_count=512, tier_boundary=256)

        t1_addr = 150
        assert sm.cells[t1_addr].pres == Presence.EMPTY

        collector = simpy.Store(env)
        sm.route_table[0] = collector

        ret_route = CMToken(target=0, offset=5, act_id=1, data=0)
        read_token = SMToken(target=0, addr=t1_addr, op=MemOp.READ, flags=None, data=None, ret=ret_route)
        inject_token(env, sm.input_store, read_token)

        env.run(until=100)

        # Verify deferred read is set
        assert sm.deferred_read is not None
        assert sm.deferred_read.cell_addr == t1_addr
        assert sm.cells[t1_addr].pres == Presence.WAITING
        # No result token yet
        assert len(collector.items) == 0

    def test_t1_deferred_read_satisfied_by_write(self):
        """WRITE on T1 WAITING cell satisfies deferred read."""
        env = simpy.Environment()
        sm = StructureMemory(env, 0, cell_count=512, tier_boundary=256)

        t1_addr = 120
        collector = simpy.Store(env)
        sm.route_table[0] = collector

        def test_sequence():
            # First: READ on empty T1 cell to defer
            ret_route = CMToken(target=0, offset=10, act_id=0, data=0)
            read_token = SMToken(target=0, addr=t1_addr, op=MemOp.READ, flags=None, data=None, ret=ret_route)
            yield sm.input_store.put(read_token)

            # Second: WRITE to satisfy the deferred read
            yield env.timeout(10)
            write_token = SMToken(target=0, addr=t1_addr, op=MemOp.WRITE, flags=None, data=0x2222, ret=None)
            yield sm.input_store.put(write_token)

        env.process(test_sequence())
        env.run(until=100)

        # Verify result token was emitted with correct data
        assert len(collector.items) == 1
        assert collector.items[0].data == 0x2222


class TestAC4_2T0WriteDirect:
    """AC4.2: SM WRITE to T0 stores data without presence checking."""

    def test_t0_write_stores_directly(self):
        """WRITE to T0 (addr >= tier_boundary) stores in t0_store directly."""
        env = simpy.Environment()
        sm = StructureMemory(env, 0, cell_count=512, tier_boundary=256)

        t0_addr = 256
        write_token = SMToken(target=0, addr=t0_addr, op=MemOp.WRITE, flags=None, data=0x3333, ret=None)
        inject_token(env, sm.input_store, write_token)

        env.run(until=100)

        # Verify data in t0_store at correct index
        t0_idx = t0_addr - 256
        assert len(sm.t0_store) > t0_idx
        assert sm.t0_store[t0_idx] == 0x3333

    def test_t0_write_overwrites_previous_value(self):
        """WRITE to T0 can overwrite previous value."""
        env = simpy.Environment()
        sm = StructureMemory(env, 0, cell_count=512, tier_boundary=256)

        # Pre-populate
        sm.t0_store.append(0x1111)

        # Overwrite at same index
        t0_addr = 256
        write_token = SMToken(target=0, addr=t0_addr, op=MemOp.WRITE, flags=None, data=0x4444, ret=None)
        inject_token(env, sm.input_store, write_token)

        env.run(until=100)

        # Verify overwrite
        assert sm.t0_store[0] == 0x4444


class TestAC4_3T0ReadImmediate:
    """AC4.3: SM READ on T0 address returns immediately (no deferral)."""

    def test_t0_read_immediate_no_deferral(self):
        """READ on T0 address returns immediately without I-structure blocking."""
        env = simpy.Environment()
        sm = StructureMemory(env, 0, cell_count=512, tier_boundary=256)

        # Pre-populate t0_store
        sm.t0_store.append(0x5555)

        collector = simpy.Store(env)
        sm.route_table[0] = collector

        t0_addr = 256
        ret_route = CMToken(target=0, offset=0, act_id=0, data=0)
        read_token = SMToken(target=0, addr=t0_addr, op=MemOp.READ, flags=None, data=None, ret=ret_route)
        inject_token(env, sm.input_store, read_token)

        env.run(until=100)

        # Verify immediate result
        assert len(collector.items) == 1
        assert collector.items[0].data == 0x5555
        # No deferred read
        assert sm.deferred_read is None

    def test_t0_read_on_empty_returns_zero(self):
        """READ on empty T0 address returns 0."""
        env = simpy.Environment()
        sm = StructureMemory(env, 0, cell_count=512, tier_boundary=256)

        # t0_store is empty
        collector = simpy.Store(env)
        sm.route_table[0] = collector

        t0_addr = 256
        ret_route = CMToken(target=0, offset=0, act_id=0, data=0)
        read_token = SMToken(target=0, addr=t0_addr, op=MemOp.READ, flags=None, data=None, ret=ret_route)
        inject_token(env, sm.input_store, read_token)

        env.run(until=100)

        # Verify 0 returned
        assert len(collector.items) == 1
        assert collector.items[0].data == 0


class TestAC4_5T0IStructureOpsRejected:
    """AC4.5: I-structure ops (CLEAR, ALLOC, FREE, RD_INC, RD_DEC, CMP_SW) on T0 are rejected."""

    def test_t0_clear_rejected(self):
        """CLEAR on T0 address is rejected (no-op)."""
        env = simpy.Environment()
        sm = StructureMemory(env, 0, cell_count=512, tier_boundary=256)

        # Pre-populate t0_store
        sm.t0_store.append(0xDEAD)

        t0_addr = 256
        clear_token = SMToken(target=0, addr=t0_addr, op=MemOp.CLEAR, flags=None, data=None, ret=None)
        inject_token(env, sm.input_store, clear_token)

        env.run(until=100)

        # Verify t0_store unchanged
        assert sm.t0_store[0] == 0xDEAD

    def test_t0_alloc_rejected(self):
        """ALLOC on T0 address is rejected."""
        env = simpy.Environment()
        sm = StructureMemory(env, 0, cell_count=512, tier_boundary=256)

        t0_addr = 256
        alloc_token = SMToken(target=0, addr=t0_addr, op=MemOp.ALLOC, flags=None, data=None, ret=None)
        inject_token(env, sm.input_store, alloc_token)

        env.run(until=100)

        # t0_store should remain empty
        assert len(sm.t0_store) == 0

    def test_t0_free_rejected(self):
        """FREE on T0 address is rejected."""
        env = simpy.Environment()
        sm = StructureMemory(env, 0, cell_count=512, tier_boundary=256)

        # Pre-populate
        sm.t0_store.append(0xBEEF)

        t0_addr = 256
        free_token = SMToken(target=0, addr=t0_addr, op=MemOp.FREE, flags=None, data=None, ret=None)
        inject_token(env, sm.input_store, free_token)

        env.run(until=100)

        # t0_store unchanged
        assert sm.t0_store[0] == 0xBEEF

    def test_t0_rd_inc_rejected(self):
        """RD_INC on T0 address is rejected."""
        env = simpy.Environment()
        sm = StructureMemory(env, 0, cell_count=512, tier_boundary=256)

        collector = simpy.Store(env)
        sm.route_table[0] = collector

        t0_addr = 256
        ret_route = CMToken(target=0, offset=0, act_id=0, data=0)
        inc_token = SMToken(target=0, addr=t0_addr, op=MemOp.RD_INC, flags=None, data=None, ret=ret_route)
        inject_token(env, sm.input_store, inc_token)

        env.run(until=100)

        # No result token (operation rejected)
        assert len(collector.items) == 0

    def test_t0_rd_dec_rejected(self):
        """RD_DEC on T0 address is rejected."""
        env = simpy.Environment()
        sm = StructureMemory(env, 0, cell_count=512, tier_boundary=256)

        collector = simpy.Store(env)
        sm.route_table[0] = collector

        t0_addr = 256
        ret_route = CMToken(target=0, offset=0, act_id=0, data=0)
        dec_token = SMToken(target=0, addr=t0_addr, op=MemOp.RD_DEC, flags=None, data=None, ret=ret_route)
        inject_token(env, sm.input_store, dec_token)

        env.run(until=100)

        # No result token
        assert len(collector.items) == 0

    def test_t0_cmp_sw_rejected(self):
        """CMP_SW on T0 address is rejected."""
        env = simpy.Environment()
        sm = StructureMemory(env, 0, cell_count=512, tier_boundary=256)

        # Pre-populate t0_store
        sm.t0_store.append(0x100)

        collector = simpy.Store(env)
        sm.route_table[0] = collector

        t0_addr = 256
        ret_route = CMToken(target=0, offset=0, act_id=0, data=0)
        cmp_token = SMToken(target=0, addr=t0_addr, op=MemOp.CMP_SW, flags=0x100, data=0x200, ret=ret_route)
        inject_token(env, sm.input_store, cmp_token)

        env.run(until=100)

        # No result token and t0_store unchanged
        assert len(collector.items) == 0
        assert sm.t0_store[0] == 0x100


class TestAC4_6ConfigurableTierBoundary:
    """AC4.6: Tier boundary is configurable via SMConfig; default is 256."""

    def test_default_tier_boundary_is_256(self):
        """SMConfig creates SM with default tier_boundary=256."""
        env = simpy.Environment()
        sm = StructureMemory(env, 0, cell_count=512)
        assert sm.tier_boundary == 256

    def test_custom_tier_boundary(self):
        """SMConfig allows custom tier_boundary."""
        env = simpy.Environment()
        sm = StructureMemory(env, 0, cell_count=512, tier_boundary=128)
        assert sm.tier_boundary == 128

    def test_addr_below_custom_tier_boundary_is_t1(self):
        """Addresses below custom tier_boundary use I-structure semantics."""
        env = simpy.Environment()
        sm = StructureMemory(env, 0, cell_count=512, tier_boundary=128)

        # Addr 127 should be T1 (< 128)
        t1_addr = 127
        sm.cells[t1_addr].pres = Presence.FULL
        sm.cells[t1_addr].data_l = 0x7777

        collector = simpy.Store(env)
        sm.route_table[0] = collector

        ret_route = CMToken(target=0, offset=0, act_id=0, data=0)
        read_token = SMToken(target=0, addr=t1_addr, op=MemOp.READ, flags=None, data=None, ret=ret_route)
        inject_token(env, sm.input_store, read_token)

        env.run(until=100)

        # Verify I-structure read worked
        assert len(collector.items) == 1
        assert collector.items[0].data == 0x7777

    def test_addr_at_custom_tier_boundary_is_t0(self):
        """Addresses at or above custom tier_boundary use T0 semantics."""
        env = simpy.Environment()
        sm = StructureMemory(env, 0, cell_count=512, tier_boundary=128)

        # Addr 128 should be T0 (>= 128)
        t0_addr = 128

        collector = simpy.Store(env)
        sm.route_table[0] = collector

        # T0 read on empty should return 0, not defer
        ret_route = CMToken(target=0, offset=0, act_id=0, data=0)
        read_token = SMToken(target=0, addr=t0_addr, op=MemOp.READ, flags=None, data=None, ret=ret_route)
        inject_token(env, sm.input_store, read_token)

        env.run(until=100)

        # Should return 0 immediately
        assert len(collector.items) == 1
        assert collector.items[0].data == 0


class TestAC4_4T0SharedAcrossTopology:
    """AC4.4: T0 storage is shared — all SMs reference the same T0 store."""

    def test_all_sms_share_same_t0_store(self):
        """All SMs in topology reference identical t0_store object."""
        env = simpy.Environment()

        sys = build_topology(
            env,
            [],
            [
                SMConfig(sm_id=0, cell_count=512, tier_boundary=256),
                SMConfig(sm_id=1, cell_count=512, tier_boundary=256),
                SMConfig(sm_id=2, cell_count=512, tier_boundary=256),
            ],
        )

        # Verify all SMs share same t0_store object
        assert sys.sms[0].t0_store is sys.sms[1].t0_store
        assert sys.sms[1].t0_store is sys.sms[2].t0_store

    def test_t0_write_by_sm0_visible_to_sm1(self):
        """Data written to T0 by SM0 is visible to SM1 READ."""
        env = simpy.Environment()

        sys = build_topology(
            env,
            [],
            [
                SMConfig(sm_id=0, cell_count=512, tier_boundary=256),
                SMConfig(sm_id=1, cell_count=512, tier_boundary=256),
            ],
        )

        # Collector for SM1 results
        collector = simpy.Store(env)
        sys.sms[1].route_table[0] = collector

        def test_sequence():
            # SM0 writes to T0
            write_token = SMToken(target=0, addr=256, op=MemOp.WRITE, flags=None, data=0x9999, ret=None)
            yield sys.sms[0].input_store.put(write_token)

            # SM1 reads from same T0
            yield env.timeout(10)
            ret_route = CMToken(target=0, offset=0, act_id=0, data=0)
            read_token = SMToken(target=1, addr=256, op=MemOp.READ, flags=None, data=None, ret=ret_route)
            yield sys.sms[1].input_store.put(read_token)

        env.process(test_sequence())
        env.run(until=100)

        # Verify SM1 read returned SM0's written data
        assert len(collector.items) == 1
        assert collector.items[0].data == 0x9999


class TestAC6_1SMCellIsWideField:
    """AC6.1: SMCell has is_wide field (default False)."""

    def test_is_wide_defaults_to_false(self):
        from sm_mod import Presence, SMCell
        cell = SMCell(Presence.EMPTY, None, None)
        assert cell.is_wide is False

    def test_is_wide_can_be_set_true(self):
        from sm_mod import Presence, SMCell
        cell = SMCell(Presence.EMPTY, None, None, is_wide=True)
        assert cell.is_wide is True


class TestAC6_2IsWideMetadata:
    """AC6.2: Existing I-structure behaviour unchanged (is_wide=False path)."""

    def test_is_wide_false_preserves_existing_behavior(self):
        """Frame-based PE can be created with proper configuration.

        Note: This test has been updated for frame-based architecture.
        The detailed token matching behavior is tested elsewhere (test_integration.py).
        This test just verifies PE can be initialized with frame config.
        """
        env = simpy.Environment()

        from emu.types import PEConfig
        from emu.pe import ProcessingElement

        # Create PE with frame-based config
        config = PEConfig(
            pe_id=0,
            frame_count=8,
            frame_slots=64,
            matchable_offsets=8,
        )
        pe = ProcessingElement(env, 0, config)

        # Verify PE was initialized correctly
        assert pe.pe_id == 0
        assert pe.frame_count == 8
        assert len(pe.frames) == 8
        assert all(len(f) == 64 for f in pe.frames)
        assert len(pe.free_frames) == 8  # All frames initially free
        assert len(pe.tag_store) == 0  # No activations allocated yet