"""
SWC 组件和内部行为测试
"""
import pytest
from xml.dom.minidom import Document

from src import (
    ApplicationSwComponentType,
    RPortPrototype,
    PPortPrototype,
    PRPortPrototype,
    SenderReceiverInterface,
    create_sender_receiver_interface,
    create_runnable_entity,
    create_timing_event,
    create_init_event,
    create_operation_invoked_event,
    create_data_received_event,
    create_swc_internal_behavior,
    SwcInternalBehavior,
    VariableAccess,
)


class TestRunnableEntity:
    """RunnableEntity 测试"""

    def test_create_runnable_entity(self):
        """测试创建 Runnable 实体"""
        runnable = create_runnable_entity(
            name="Runnable_Init",
            minimum_start_interval=10,
            can_be_invoked_concurrently=False,
            symbol="Runnable_Init_Function"
        )
        assert runnable.name == "Runnable_Init"
        assert runnable.minimum_start_interval == 10
        assert runnable.can_be_invoked_concurrently is False
        assert runnable.symbol == "Runnable_Init_Function"

    def test_runnable_entity_add_data_access(self):
        """测试 Runnable 添加数据访问"""
        runnable = create_runnable_entity(name="TestRunnable")
        access = VariableAccess(name="DataAccess", port_prototype_ref="Port1")
        runnable.add_variable_access(access)

        assert len(runnable.variable_accesses) == 1

    def test_runnable_entity_to_arxml(self):
        """测试 Runnable 实体 ARXML 转换"""
        runnable = create_runnable_entity(
            name="TestRunnable",
            symbol="TestRunnable_Func"
        )

        doc = Document()
        element = runnable.to_arxml(doc)

        assert element.tagName == "RUNNABLE-ENTITY"
        assert element.hasAttribute("UUID")

        short_name = element.getElementsByTagName("SHORT-NAME")[0]
        assert short_name.firstChild.nodeValue == "TestRunnable"


class TestEvents:
    """事件测试"""

    def test_create_timing_event(self):
        """测试创建定时事件"""
        event = create_timing_event("TimingEvent_10ms", period=0.01)
        assert event.name == "TimingEvent_10ms"
        assert event.period == 0.01

    def test_timing_event_to_arxml(self):
        """测试定时事件 ARXML 转换"""
        event = create_timing_event("PeriodicTask", period=0.05)

        doc = Document()
        element = event.to_arxml(doc)

        assert element.tagName == "TIMING-EVENT"
        assert element.hasAttribute("UUID")

        short_name = element.getElementsByTagName("SHORT-NAME")[0]
        assert short_name.firstChild.nodeValue == "PeriodicTask"

    def test_create_init_event(self):
        """测试创建初始化事件"""
        event = create_init_event("InitEvent")
        assert event.name == "InitEvent"

    def test_init_event_to_arxml(self):
        """测试初始化事件 ARXML 转换"""
        event = create_init_event("InitEvent")

        doc = Document()
        element = event.to_arxml(doc)

        assert element.tagName == "INIT-EVENT"
        assert element.hasAttribute("UUID")

    def test_create_operation_invoked_event(self):
        """测试创建操作调用事件"""
        event = create_operation_invoked_event(
            "OpInvokeEvent",
            operation_ref="/Package/Interface/Operation"
        )
        assert event.name == "OpInvokeEvent"
        assert event.operation_ref == "/Package/Interface/Operation"

    def test_operation_invoked_event_to_arxml(self):
        """测试操作调用事件 ARXML 转换"""
        event = create_operation_invoked_event("OpInvokeEvent")

        doc = Document()
        element = event.to_arxml(doc)

        assert element.tagName == "OPERATION-INVOKED-EVENT"
        assert element.hasAttribute("UUID")

    def test_create_data_received_event(self):
        """测试创建数据接收事件"""
        event = create_data_received_event(
            "DataReceived",
            data_element_ref="/Package/Interface/Port",
            period=0.02
        )
        assert event.name == "DataReceived"
        assert event.data_element_ref == "/Package/Interface/Port"
        assert event.period == 0.02

    def test_data_received_event_to_arxml(self):
        """测试数据接收事件 ARXML 转换"""
        event = create_data_received_event("DataReceived", period=0.01)

        doc = Document()
        element = event.to_arxml(doc)

        assert element.tagName == "DATA-RECEIVED-EVENT"
        assert element.hasAttribute("UUID")


class TestSwcInternalBehavior:
    """SWC 内部行为测试"""

    def test_create_swc_internal_behavior(self):
        """测试创建 SWC 内部行为"""
        runnable = create_runnable_entity(name="MainRunnable")
        timing = create_timing_event("MainTiming", period=0.01)

        behavior = create_swc_internal_behavior(
            name="ComponentBehavior",
            runnable_entities=[runnable],
            events=[timing],
            symbol="Component_Symbol"
        )
        assert behavior.name == "ComponentBehavior"
        assert len(behavior.runnable_entities) == 1
        assert len(behavior.events) == 1
        assert behavior.symbol == "Component_Symbol"

    def test_swc_internal_behavior_add_runnable(self):
        """测试 SWC 内部行为添加 Runnable"""
        behavior = create_swc_internal_behavior(name="Behavior")
        runnable = create_runnable_entity(name="NewRunnable")

        behavior.add_runnable(runnable)
        assert behavior.get_runnable("NewRunnable") == runnable

    def test_swc_internal_behavior_add_event(self):
        """测试 SWC 内部行为添加事件"""
        behavior = create_swc_internal_behavior(name="Behavior")
        event = create_timing_event("NewTiming", period=0.02)

        behavior.add_event(event)
        assert behavior.get_event("NewTiming") == event

    def test_swc_internal_behavior_to_arxml(self):
        """测试 SWC 内部行为 ARXML 转换"""
        runnable = create_runnable_entity(name="MainRunnable", symbol="MainRunnable_Func")
        timing = create_timing_event("Periodic", period=0.01)

        behavior = create_swc_internal_behavior(
            name="ComponentBehavior",
            runnable_entities=[runnable],
            events=[timing]
        )

        doc = Document()
        element = behavior.to_arxml(doc)

        assert element.tagName == "SWC-INTERNAL-BEHAVIOR"
        assert element.hasAttribute("UUID")


class TestSwComponent:
    """软件组件测试"""

    def test_create_application_swc(self):
        """测试创建应用组件"""
        swc = ApplicationSwComponentType(name="TestComponent")
        assert swc.name == "TestComponent"
        assert swc.atomic_type.value == "Application"

    def test_application_swc_add_port(self):
        """测试应用组件添加端口"""
        swc = ApplicationSwComponentType(name="TestComponent")

        data_element = SenderReceiverInterface.DataElement(name="TestData")
        interface = create_sender_receiver_interface("TestInterface", data_element=data_element)
        port = PPortPrototype(name="TestPort", interface=interface)

        swc.add_port(port)
        assert swc.get_port("TestPort") == port

    def test_application_swc_to_arxml(self):
        """测试应用组件 ARXML 转换"""
        swc = ApplicationSwComponentType(name="TestComponent")

        doc = Document()
        element = swc.to_arxml(doc)

        assert element.tagName == "APPLICATION-SW-COMPONENT-TYPE"
        assert element.hasAttribute("UUID")

        short_name = element.getElementsByTagName("SHORT-NAME")[0]
        assert short_name.firstChild.nodeValue == "TestComponent"

    def test_application_swc_with_ports_to_arxml(self):
        """测试带端口的应用组件 ARXML 转换"""
        swc = ApplicationSwComponentType(name="ComponentWithPorts")

        data_element = SenderReceiverInterface.DataElement(name="StatusData")
        interface = create_sender_receiver_interface("StatusInterface", data_element=data_element)
        port = PPortPrototype(name="StatusPort", interface=interface)
        swc.add_port(port)

        doc = Document()
        element = swc.to_arxml(doc)

        assert element.tagName == "APPLICATION-SW-COMPONENT-TYPE"
        ports = element.getElementsByTagName("PORTS")
        assert len(ports) == 1


class TestPortPrototypes:
    """端口原型测试"""

    def test_r_port_prototype_to_arxml(self):
        """测试 R-Port ARXML 转换"""
        data_element = SenderReceiverInterface.DataElement(name="RxData")
        interface = create_sender_receiver_interface("RxInterface", data_element=data_element)
        port = RPortPrototype(name="RPort1", interface=interface)

        doc = Document()
        element = port.to_arxml(doc)

        assert element.tagName == "R-PORT-PROTOTYPE"
        assert element.hasAttribute("UUID")

        short_name = element.getElementsByTagName("SHORT-NAME")[0]
        assert short_name.firstChild.nodeValue == "RPort1"

    def test_p_port_prototype_to_arxml(self):
        """测试 P-Port ARXML 转换"""
        data_element = SenderReceiverInterface.DataElement(name="TxData")
        interface = create_sender_receiver_interface("TxInterface", data_element=data_element)
        port = PPortPrototype(name="PPort1", interface=interface)

        doc = Document()
        element = port.to_arxml(doc)

        assert element.tagName == "P-PORT-PROTOTYPE"
        assert element.hasAttribute("UUID")

        short_name = element.getElementsByTagName("SHORT-NAME")[0]
        assert short_name.firstChild.nodeValue == "PPort1"

    def test_pr_port_prototype_to_arxml(self):
        """测试 PR-Port ARXML 转换"""
        data_element = SenderReceiverInterface.DataElement(name="BidirectionalData")
        interface = create_sender_receiver_interface("BiInterface", data_element=data_element)
        port = PRPortPrototype(name="PRPort1", interface=interface)

        doc = Document()
        element = port.to_arxml(doc)

        assert element.tagName == "P-PORT-PROTOTYPE"
        assert element.hasAttribute("UUID")


if __name__ == "__main__":
    pytest.main([__file__, "-v"])