import sys
sys.path.append('src/')

from protocol_components.dtypes import BprotoFieldBaseType
from nameHandling.base import ComponentName, NameStyleBproto
from protocol_components.message import FactoryMessage
from protocol_components.enumeration import FactoryEnumeration, Enumeration
from protocol_components.bitfields import FactoryBitfield, Bitfield
from protocol_components.protocolFactory import FactoryProtocolDefition
from protocol_components.field import FactoryField, Field, FieldEnum, FieldBitfield, FieldEnumRef, FieldBitfieldRef
from errors import BprotoUnresolvedReferenceError, BprotoAlreadyDefinedError

from nameHandling.resolver import ProtocolReferenceResolver


def test_protocol_factory():
    factory = FactoryProtocolDefition()
    factory.add_message(FactoryMessage().assemble("Message1", 42))
    factory.add_message(FactoryMessage().assemble("Message2", 43))

    message_with_fields_factory = FactoryMessage()
    message_with_fields_factory.add_field(FactoryField().assemble("field1", 0, "uint64", 1, None))
    message_with_fields_factory.add_field(FactoryField().assemble("enum_ref", 1, BprotoFieldBaseType.ENUM, 1, "Enum1"))
    message_with_fields_factory.add_field(FactoryField().assemble("bitfield_ref", 2, BprotoFieldBaseType.BITFIELD, 1, "Bitfield2"))

    factory.add_message(
        message_with_fields_factory.assemble("Message3", 44)
    )

    factory.add_enum(FactoryEnumeration().assemble("Enum1"))
    factory.add_enum(FactoryEnumeration().assemble("Enum2"))
    factory.add_enum(FactoryEnumeration().assemble("Enum3"))

    factory.add_bitfield(FactoryBitfield().assemble("Bitfield1"))
    factory.add_bitfield(FactoryBitfield().assemble("Bitfield2"))
    factory.add_bitfield(FactoryBitfield().assemble("Bitfield3"))

    protocol = factory.assemble("TESTPROTOCOL", 1)

    assert protocol.name.name_parts == ["testprotocol"]
    assert isinstance(protocol.name, ComponentName)
    assert protocol.version == 1

    assert protocol.messages == {
        NameStyleBproto.fromStr("Message1"): factory.messages.get(NameStyleBproto.fromStr("Message1")),
        NameStyleBproto.fromStr("Message2"): factory.messages.get(NameStyleBproto.fromStr("Message2")),
        NameStyleBproto.fromStr("Message3"): factory.messages.get(NameStyleBproto.fromStr("Message3"))
    }

    assert protocol.enums == {
        NameStyleBproto.fromStr("Enum1"): factory.enums.get(NameStyleBproto.fromStr("Enum1")),
        NameStyleBproto.fromStr("Enum2"): factory.enums.get(NameStyleBproto.fromStr("Enum2")),
        NameStyleBproto.fromStr("Enum3"): factory.enums.get(NameStyleBproto.fromStr("Enum3"))
    }

    assert protocol.bitfields == {
        NameStyleBproto.fromStr("Bitfield1"): factory.bitfields.get(NameStyleBproto.fromStr("Bitfield1")),
        NameStyleBproto.fromStr("Bitfield2"): factory.bitfields.get(NameStyleBproto.fromStr("Bitfield2")),
        NameStyleBproto.fromStr("Bitfield3"): factory.bitfields.get(NameStyleBproto.fromStr("Bitfield3"))
    }

    # Check if references are resolved works
    assert isinstance(protocol.messages.get(NameStyleBproto.fromStr("Message3")).fields.get(NameStyleBproto.fromStr("enum_ref")), FieldEnum)
    assert isinstance(protocol.messages.get(NameStyleBproto.fromStr("Message3")).fields.get(NameStyleBproto.fromStr("bitfield_ref")), FieldBitfield)


def test_protocol_resolve_refernces():
    enum1 = FactoryEnumeration().assemble("Enum1")
    bitfield1 = FactoryBitfield().assemble("Bitfield1")

    message1Factory = FactoryMessage()
    message1Factory.add_field(FactoryField().assemble("field1", 0, "uint64", 1, None))
    message1Factory.add_field(FactoryField().assemble("enum_field", 1, BprotoFieldBaseType.ENUM, 1, enum1))
    message1Factory.add_field(FactoryField().assemble("enum_ref_field", 2, BprotoFieldBaseType.ENUM, 1, "Enum1"))
    message1Factory.add_field(FactoryField().assemble("bitfield_field", 3, BprotoFieldBaseType.BITFIELD, 1, bitfield1))
    message1Factory.add_field(FactoryField().assemble("bitfield_ref_field", 4, BprotoFieldBaseType.BITFIELD, 1, "Bitfield1"))
    message1 = message1Factory.assemble("Message1", 42)

    # Check if message is correctly assembled
    assert isinstance(message1.fields.get(NameStyleBproto.fromStr("field1")), Field)
    assert message1.fields.get(NameStyleBproto.fromStr("field1")).type == BprotoFieldBaseType.UINT64
    assert message1.fields.get(NameStyleBproto.fromStr("field1")).array_size == 1
    assert message1.fields.get(NameStyleBproto.fromStr("field1")).ref is None
    assert isinstance(message1.fields.get(NameStyleBproto.fromStr("field1")).ref, type(None))

    assert isinstance(message1.fields.get(NameStyleBproto.fromStr("enum_field")), FieldEnum)
    assert message1.fields.get(NameStyleBproto.fromStr("enum_field")).type == BprotoFieldBaseType.ENUM
    assert isinstance(message1.fields.get(NameStyleBproto.fromStr("enum_field")).enum, Enumeration)
    assert message1.fields.get(NameStyleBproto.fromStr("enum_field")).enum == enum1

    assert isinstance(message1.fields.get(NameStyleBproto.fromStr("enum_ref_field")), FieldEnumRef)
    assert message1.fields.get(NameStyleBproto.fromStr("enum_ref_field")).type == BprotoFieldBaseType.ENUM
    assert message1.fields.get(NameStyleBproto.fromStr("enum_ref_field")).ref == "Enum1"

    assert isinstance(message1.fields.get(NameStyleBproto.fromStr("bitfield_field")), FieldBitfield)
    assert message1.fields.get(NameStyleBproto.fromStr("bitfield_field")).type == BprotoFieldBaseType.BITFIELD
    assert isinstance(message1.fields.get(NameStyleBproto.fromStr("bitfield_field")).bitfield, Bitfield)
    assert message1.fields.get(NameStyleBproto.fromStr("bitfield_field")).bitfield == bitfield1

    assert isinstance(message1.fields.get(NameStyleBproto.fromStr("bitfield_ref_field")), FieldBitfieldRef)
    assert message1.fields.get(NameStyleBproto.fromStr("bitfield_ref_field")).type == BprotoFieldBaseType.BITFIELD
    assert message1.fields.get(NameStyleBproto.fromStr("bitfield_ref_field")).ref == "Bitfield1"
    
    factory = FactoryProtocolDefition()
    factory.add_message(message1)
    factory.add_enum(enum1)
    factory.add_bitfield(bitfield1)
    protocol = factory.assemble("TestProtocol", 1)

    # Check if references are resolved works

    resolver = ProtocolReferenceResolver(protocol)
    resolver.resolve_refrence_protocol()

    assert protocol.messages.get(NameStyleBproto.fromStr("Message1")).fields.get(NameStyleBproto.fromStr("enum_field")).type == BprotoFieldBaseType.ENUM
    assert isinstance(protocol.messages.get(NameStyleBproto.fromStr("Message1")).fields.get(NameStyleBproto.fromStr("enum_field")), FieldEnum)
    assert protocol.messages.get(NameStyleBproto.fromStr("Message1")).fields.get(NameStyleBproto.fromStr("enum_field")).enum == enum1
    
    assert protocol.messages.get(NameStyleBproto.fromStr("Message1")).fields.get(NameStyleBproto.fromStr("enum_ref_field")).type == BprotoFieldBaseType.ENUM
    assert isinstance(protocol.messages.get(NameStyleBproto.fromStr("Message1")).fields.get(NameStyleBproto.fromStr("enum_ref_field")), FieldEnum)
    assert protocol.messages.get(NameStyleBproto.fromStr("Message1")).fields.get(NameStyleBproto.fromStr("enum_ref_field")).enum == enum1

    assert protocol.messages.get(NameStyleBproto.fromStr("Message1")).fields.get(NameStyleBproto.fromStr("bitfield_field")).type == BprotoFieldBaseType.BITFIELD
    assert isinstance(protocol.messages.get(NameStyleBproto.fromStr("Message1")).fields.get(NameStyleBproto.fromStr("bitfield_field")), FieldBitfield)
    assert protocol.messages.get(NameStyleBproto.fromStr("Message1")).fields.get(NameStyleBproto.fromStr("bitfield_field")).bitfield == bitfield1
    
    assert protocol.messages.get(NameStyleBproto.fromStr("Message1")).fields.get(NameStyleBproto.fromStr("bitfield_ref_field")).type == BprotoFieldBaseType.BITFIELD
    assert isinstance(protocol.messages.get(NameStyleBproto.fromStr("Message1")).fields.get(NameStyleBproto.fromStr("bitfield_ref_field")), FieldBitfield)
    assert protocol.messages.get(NameStyleBproto.fromStr("Message1")).fields.get(NameStyleBproto.fromStr("bitfield_ref_field")).bitfield == bitfield1


def test_protocol_resolve_refernces_unknown_refernces():
    message1Factory = FactoryMessage()
    message1Factory.add_field(FactoryField().assemble("field1", 0, "uint64", 1, None))
    message1Factory.add_field(FactoryField().assemble("enum_ref_field", 1, BprotoFieldBaseType.ENUM, 1, "Enum1"))
    message1Factory.add_field(FactoryField().assemble("bitfield_ref_field", 2, BprotoFieldBaseType.BITFIELD, 1, "Bitfield1",))
    message1 = message1Factory.assemble("Message1", 42)

    factory = FactoryProtocolDefition()
    factory.add_message(message1)

    try:
        factory.assemble("TestProtocol", 1)
        assert False
    except Exception as e:
        assert isinstance(e, BprotoUnresolvedReferenceError)
    
    try:
        factory.assemble("TestProtocol", 1)
        assert False
    except Exception as e:
        assert isinstance(e, BprotoUnresolvedReferenceError)


def test_protocol_factory_already_define_error():
    factory = FactoryProtocolDefition()
    factory.add_message(FactoryMessage().assemble("Message1", 42))
    try:
        factory.add_message(FactoryMessage().assemble("Message1", 42))
        factory.assemble("A", 1)
        assert False
    except Exception as e:
        assert isinstance(e, BprotoAlreadyDefinedError)
    
    factory = FactoryProtocolDefition()
    factory.add_enum(FactoryEnumeration().assemble("Enum1"))
    try:
        factory.assemble("A", 1)
        factory.add_enum(FactoryEnumeration().assemble("Enum1"))
        assert False
    except Exception as e:
        assert isinstance(e, BprotoAlreadyDefinedError)
    
    factory = FactoryProtocolDefition()
    factory.add_bitfield(FactoryBitfield().assemble("Bitfield1"))
    try:
        factory.add_bitfield(FactoryBitfield().assemble("Bitfield1"))
        factory.assemble("A", 1)
        assert False
    except Exception as e:
        assert isinstance(e, BprotoAlreadyDefinedError)