import json
from datetime import datetime
from unittest.mock import AsyncMock, MagicMock, call, patch
from pytest import fixture, mark
from asyncua.crypto.security_policies import SecurityPolicyBasic256
import pytest
from ingestor.managers.opc_manager import OpcManager
from sientia_do.notifications.models import NotificationLevel

tags = {
    "ns=3;i=1001": {
        "aggregation_function": "LTS",
        "frequency": 1000,
        "max_value": 100,
        "min_value": 0,
        "tag_name": "Counter",
    },
    "ns=3;i=1003": {
        "aggregation_function": "AVG",
        "frequency": 1000,
        "max_value": 100,
        "min_value": 0,
        "tag_name": "Random",
    },
    "ns=3;i=1004": {
        "aggregation_function": "MDN",
        "frequency": 1000,
        "max_value": 100,
        "min_value": 0,
        "tag_name": "Sawtooth",
    },
}

metadata = {
    "metadata": {
        "model_id": "test_model",
        "model_name": "test_model",
        "workflow_name": "test_workflow",
        "schema_name": "test_schedule",
    },
}


@fixture
@patch("ingestor.managers.opc_manager.metrics")
def raw_opc_manager(mock_metrics):
    return OpcManager(
        name="TestConnector",
        url="opc.tcp://localhost:4840",
        data_manager=MagicMock(),
        logger=MagicMock(),
        server_uri="opc.tcp://localhost:4840",
        notification_handler=MagicMock(),
        metadata=metadata["metadata"],
    )


@fixture
def opc_manager(raw_opc_manager):
    raw_opc_manager.client = AsyncMock()
    raw_opc_manager.cert_path = "cert.pem"
    raw_opc_manager.private_key_path = "private_key.pem"
    raw_opc_manager.server_cert_path = "server_cert.pem"
    raw_opc_manager.send_notification = MagicMock()

    return raw_opc_manager


@fixture
def opc_manager_subscribed(opc_manager):
    opc_manager.subscriptions["sub1"] = AsyncMock()

    return opc_manager


def test___str__(opc_manager):
    assert (
        str(opc_manager)
        == "OpcManager(name=TestConnector, url=opc.tcp://localhost:4840, server_uri=opc.tcp://localhost:4840)\nnodes={}, subscriptions={}"
    )


@mark.asyncio
async def test_shutdown_success(opc_manager):
    opc_manager.disconnect = AsyncMock()

    await opc_manager.shutdown()

    opc_manager.disconnect.assert_called_once()


@mark.asyncio
async def test_shutdown_error(opc_manager):
    opc_manager.disconnect = AsyncMock(side_effect=Exception("Test error"))

    await opc_manager.shutdown()

    opc_manager.logger.error.assert_called_once_with(
        "Error during cleanup: Test error")


@mark.asyncio
async def test_set_security_success(opc_manager):
    await opc_manager.set_security()

    opc_manager.client.set_application_uri.assert_called_once_with(
        opc_manager.server_uri
    )

    opc_manager.client.set_security.assert_called_once_with(
        SecurityPolicyBasic256,
        certificate=opc_manager.cert_path,
        private_key=opc_manager.private_key_path,
        server_certificate=opc_manager.server_cert_path,
    )

    opc_manager.client.set_secure_channel_timeout.assert_called_once_with(
        10000000)
    opc_manager.client.set_session_timeout.assert_called_once_with(10000000)


@mark.asyncio
async def test_set_security_no_cert(opc_manager):
    opc_manager.cert_path = None
    opc_manager.private_key_path = None

    try:
        await opc_manager.set_security()
    except ValueError as e:
        assert (
            str(e)
            == "Certificate and private key paths must be provided for secure connection."
        )
    else:
        assert False, "ValueError not raised"

    assert opc_manager.client.set_security.call_count == 0


@mark.asyncio
@patch("ingestor.managers.opc_manager.metrics")
@patch("ingestor.managers.opc_manager.Client")
async def test_connect_no_security(client, mock_metrics, raw_opc_manager):
    raw_opc_manager.set_security = AsyncMock()
    client.return_value = AsyncMock()

    await raw_opc_manager.connect()

    client.assert_called_once_with(raw_opc_manager.url, watchdog_intervall=3600000)
    raw_opc_manager.client.connect.assert_called_once()
    raw_opc_manager.set_security.assert_not_called()
    mock_metrics.OPC_CONNECTIONS_TOTAL.labels.assert_called_once_with(
        pod_id=raw_opc_manager.pod_id,
        server_name=raw_opc_manager.name
    )
    mock_metrics.OPC_CONNECTIONS_TOTAL.labels.return_value.inc.assert_called_once()
    mock_metrics.OPC_CONNECTION_STATUS.labels.assert_called_once_with(
        pod_id=raw_opc_manager.pod_id,
        server_name=raw_opc_manager.name,
        server_url=raw_opc_manager.url
    )
    mock_metrics.OPC_CONNECTION_STATUS.labels.return_value.set.assert_called_once_with(
        1)
    mock_metrics.OPC_CONNECTIONS_FAILED.labels.assert_not_called()


@mark.asyncio
@patch("ingestor.managers.opc_manager.Client")
async def test_connect_with_security(client, raw_opc_manager):
    raw_opc_manager.cert_path = "cert.pem"
    raw_opc_manager.private_key_path = "private_key.pem"
    raw_opc_manager.server_cert_path = "server_cert.pem"
    raw_opc_manager.set_security = AsyncMock()
    client.return_value = AsyncMock()

    await raw_opc_manager.connect()

    client.assert_called_once_with(raw_opc_manager.url, watchdog_intervall=3600000)
    raw_opc_manager.client.connect.assert_called_once()
    raw_opc_manager.set_security.assert_called_once()


@mark.asyncio
@patch("ingestor.managers.opc_manager.Client")
@patch("ingestor.managers.opc_manager.metrics")
async def test_connect_exception_handling_and_metrics(
    mock_metrics_module, mock_opc_client_class, raw_opc_manager
):
    mock_client_instance = mock_opc_client_class.return_value
    simulated_error_message = "Erro de conexão simulado"
    mock_client_instance.connect.side_effect = Exception(
        simulated_error_message)

    opc_manager_instance = raw_opc_manager
    opc_manager_instance.cert_path = None

    with pytest.raises(Exception, match=simulated_error_message):
        await opc_manager_instance.connect()

    mock_metrics_module.OPC_CONNECTIONS_TOTAL.labels.assert_called_once_with(
        pod_id=opc_manager_instance.pod_id, server_name=opc_manager_instance.name
    )
    mock_metrics_module.OPC_CONNECTIONS_TOTAL.labels.return_value.inc.assert_called_once()

    mock_metrics_module.OPC_CONNECTION_STATUS.labels.assert_called_once_with(
        pod_id=opc_manager_instance.pod_id,
        server_name=opc_manager_instance.name,
        server_url=opc_manager_instance.url,
    )
    mock_metrics_module.OPC_CONNECTION_STATUS.labels.return_value.set.assert_called_once_with(
        0
    )

    mock_metrics_module.OPC_CONNECTIONS_FAILED.labels.assert_called_once_with(
        pod_id=opc_manager_instance.pod_id, server_name=opc_manager_instance.name
    )
    mock_metrics_module.OPC_CONNECTIONS_FAILED.labels.return_value.inc.assert_called_once()

    opc_manager_instance.logger.error.assert_called_once_with(
        f"Failed to connect to {opc_manager_instance.name}: {simulated_error_message}"
    )


@mark.asyncio
async def test_create_subscription_no_client(raw_opc_manager):
    try:
        await raw_opc_manager.create_subscription("sub1")
    except ValueError as e:
        assert str(e) == "Client not connected. Call connect first."
    else:
        assert False, "ValueError not raised"


@mark.asyncio
async def test_create_subscription_success_has_period(opc_manager):
    await opc_manager.create_subscription("sub1", 1000)

    opc_manager.client.create_subscription.assert_called_once_with(
        1000, opc_manager)
    assert opc_manager.subscriptions["sub1"] is not None


@mark.asyncio
async def test_create_subscription_success_no_period(opc_manager):
    await opc_manager.create_subscription("sub1", None)

    opc_manager.client.create_subscription.assert_called_once_with(
        500, opc_manager)
    assert opc_manager.subscriptions["sub1"] is not None


@patch("ingestor.managers.opc_manager.metrics")
@mark.asyncio
async def test_create_subscription_with_metrics(metrics, opc_manager):
    await opc_manager.create_subscription("sub1", 1000)

    metrics.OPC_SUBSCRIPTIONS_CREATED.labels.assert_called_once_with(
        pod_id=opc_manager.pod_id, server_name=opc_manager.name, slot_name="sub1"
    )
    metrics.OPC_SUBSCRIPTIONS_CREATED.labels.return_value.inc.assert_called_once()


@patch("ingestor.managers.opc_manager.metrics")
@mark.asyncio
async def test_create_subscription_exception_during_client_call(
    mock_metrics_module, raw_opc_manager
):
    opc_manager_instance = raw_opc_manager
    opc_manager_instance.client = AsyncMock()

    subscription_name = "test_sub_client_error"
    simulated_period = 750
    simulated_error_message = "Falha ao criar subscrição no cliente OPC"

    opc_manager_instance.client.create_subscription.side_effect = Exception(
        simulated_error_message
    )

    with pytest.raises(Exception, match=simulated_error_message):
        await opc_manager_instance.create_subscription(
            subscription_name, period=simulated_period
        )

    opc_manager_instance.client.create_subscription.assert_called_once_with(
        simulated_period, opc_manager_instance
    )

    opc_manager_instance.logger.error.assert_called_once_with(
        f"Failed to create subscription {subscription_name} on {opc_manager_instance.name}: {simulated_error_message}"
    )

    mock_metrics_module.OPC_SUBSCRIPTIONS_CREATED.labels.assert_not_called()


@patch("ingestor.managers.opc_manager.metrics")
@mark.asyncio
async def test_subscribe_no_subscription(metrics, opc_manager):
    try:
        await opc_manager.subscribe("sub1", tags, 1000)
    except ValueError as e:
        assert str(
            e) == "Subscription not created. Call create_subscription first."
    else:
        assert False, "ValueError not raised"
    metrics.OPC_TAGS_SUBSCRIBED.labels.assert_not_called()


@mark.asyncio
async def test_subscribe_success(opc_manager_subscribed):
    opc_manager_subscribed.client.get_node = MagicMock()
    opc_manager_subscribed.nodes = {"ns=3;i=1001": "data"}

    await opc_manager_subscribed.subscribe("sub1", tags, 1000)

    assert opc_manager_subscribed.nodes == tags
    opc_manager_subscribed.subscriptions["sub1"].subscribe_data_change.assert_called_once_with(
        [opc_manager_subscribed.client.get_node(n) for n in tags]
    )


@mark.asyncio
async def test_unsubscribe_no_subscription(opc_manager):
    await opc_manager.unsubscribe("sub1")

    opc_manager.logger.warning.assert_called_once_with(
        "Subscription 'sub1' not found. Cannot unsubscribe."
    )
    assert opc_manager.subscriptions.get("sub1") is None


@mark.asyncio
async def test_unsubscribe_success(opc_manager_subscribed):
    await opc_manager_subscribed.unsubscribe("sub1")

    opc_manager_subscribed.subscriptions.get("sub1") is None


@mark.asyncio
async def test_disconnect_success(opc_manager_subscribed):
    opc_manager_subscribed.client = MagicMock()

    await opc_manager_subscribed.disconnect()

    opc_manager_subscribed.subscriptions["sub1"].delete.assert_called_once()
    assert opc_manager_subscribed.client is None


@mark.asyncio
async def test_disconnect_no_client(opc_manager_subscribed):
    opc_manager_subscribed.client = None
    assert await opc_manager_subscribed.disconnect() is None

    opc_manager_subscribed.logger.warning.assert_has_calls(
        [
            call("Client already disconnected."),
        ]
    )


@mark.asyncio
async def test_disconnect_error_unsubscribe(opc_manager_subscribed):
    opc_manager_subscribed.client = MagicMock(
        disconnect=AsyncMock()
    )
    opc_manager_subscribed.subscriptions["sub1"] = MagicMock(
        delete=AsyncMock(side_effect=Exception("Test error"))
    )

    await opc_manager_subscribed.disconnect()

    opc_manager_subscribed.subscriptions["sub1"].delete.assert_called_once()
    opc_manager_subscribed.client = None
    opc_manager_subscribed.logger.error.assert_called_once_with(
        "Failed to clean up subscription: Test error"
    )


@mark.asyncio
async def test_disconnect_error(opc_manager_subscribed):
    opc_manager_subscribed.client = MagicMock()
    opc_manager_subscribed.client.disconnect = MagicMock(
        side_effect=Exception("Test error")
    )

    await opc_manager_subscribed.disconnect()

    opc_manager_subscribed.subscriptions["sub1"].delete.assert_called_once()
    opc_manager_subscribed.client = None
    opc_manager_subscribed.logger.error.assert_called_once_with(
        "Failed to disconnect from OPC UA server: Test error"
    )


@patch('ingestor.managers.opc_manager.metrics')
@mark.asyncio
async def test_disconnect_metrics_on_successful_path(mock_metrics_module, raw_opc_manager):
    mock_metrics_module.OPC_CONNECTION_STATUS.reset_mock()
    mock_metrics_module.OPC_TAGS_SUBSCRIBED.reset_mock()

    raw_opc_manager.client = MagicMock()
    mock_sub1 = MagicMock()
    mock_sub2 = MagicMock()
    raw_opc_manager.subscriptions = {"sub1": mock_sub1, "sub2": mock_sub2}

    await raw_opc_manager.disconnect()

    mock_metrics_module.OPC_CONNECTION_STATUS.labels.assert_called_once_with(
        pod_id=raw_opc_manager.pod_id,
        server_name=raw_opc_manager.name,
        server_url=raw_opc_manager.url
    )
    mock_metrics_module.OPC_CONNECTION_STATUS.labels.return_value.set.assert_called_once_with(
        0)

    mock_metrics_module.OPC_TAGS_SUBSCRIBED.labels.assert_called_once_with(
        pod_id=raw_opc_manager.pod_id,
        server_name=raw_opc_manager.name
    )
    mock_metrics_module.OPC_TAGS_SUBSCRIBED.labels.return_value.set.assert_called_once_with(
        0)


@patch('ingestor.managers.opc_manager.metrics')
@mark.asyncio
async def test_datachange_notification(metrics, opc_manager_subscribed):
    data = MagicMock(
        monitored_item=MagicMock(
            Value=MagicMock(
                Value=MagicMock(Value=42),
                SourceTimestamp=datetime.strptime(
                    "2021-01-01T00:00:00", "%Y-%m-%dT%H:%M:%S"
                ),
            )
        )
    )
    opc_manager_subscribed.nodes = {
        "ns=3;i=1001": {
            "tag_name": "Counter",
            "cycle_rule": {"cycle_increment": 1.0, "cycle_count": 2},
            "topics": ["topic1", "topic2"],
        }
    }

    metrics.OPC_CYCLES_WITHOUT_DATA.reset_mock()

    await opc_manager_subscribed.datachange_notification("ns=3;i=1001", None, data)

    opc_manager_subscribed.data_manager.publish.assert_any_call(
        "topic1",
        {
            "tag": "ns=3;i=1001",
            "name": "Counter",
            "timestamp": "2021-01-01 00:00:00-0300",
            "value": 42,
        },
    )
    opc_manager_subscribed.data_manager.publish.assert_any_call(
        "topic2",
        {
            "tag": "ns=3;i=1001",
            "name": "Counter",
            "timestamp": "2021-01-01 00:00:00-0300",
            "value": 42,
        },
    )
    assert opc_manager_subscribed.nodes["ns=3;i=1001"]["cycle_rule"]["cycle_count"] == 0

    metrics.OPC_CYCLES_WITHOUT_DATA.labels.assert_called_once_with(
        pod_id=opc_manager_subscribed.pod_id,
        server_name=opc_manager_subscribed.name
    )
    metrics.OPC_CYCLES_WITHOUT_DATA.labels.return_value.set.assert_called_once_with(
        0)


def test_check_cycles_no_notification(opc_manager):
    # Setup: node with cycle_count just below threshold
    opc_manager.nodes = {
        "ns=3;i=1001": {
            "tag_name": "Counter",
            "cycle_rule": {"cycle_increment": 1.0, "cycle_count": 3.0},
        }
    }

    opc_manager.check_cycles()

    # After one increment, cycle_count = 4.0, still below threshold
    assert opc_manager.nodes["ns=3;i=1001"]["cycle_rule"][
        "cycle_count"
    ] == pytest.approx(4.0)
    opc_manager.send_notification.assert_not_called()


def test_check_cycles_triggers_notification(opc_manager):
    # Setup: node with cycle_count just below threshold, increment will cross threshold
    opc_manager.nodes = {
        "ns=3;i=1001": {
            "tag_name": "Counter",
            "cycle_rule": {"cycle_increment": 2.5, "cycle_count": 3.0},
        }
    }
    opc_manager.notification_handler.build_and_send_notification = MagicMock()

    opc_manager.check_cycles()

    # After increment, cycle_count = 5.5, should trigger notification
    assert opc_manager.nodes["ns=3;i=1001"]["cycle_rule"][
        "cycle_count"
    ] == pytest.approx(5.5)
    opc_manager.send_notification.assert_called_once_with(
        notification_id="TAG_ns=3;i=1001:Counter_LISTENNING_STOPPED",
        message="5.5 cycles without receive from ns=3;i=1001:Counter",
        block="opc_manager",
        level=NotificationLevel.WARNING,
        metadata=metadata["metadata"],
    )


@patch('ingestor.managers.opc_manager.metrics')
def test_check_opc_listenning_no_notification(metrics, opc_manager):
    opc_manager.non_receive_count = 3
    opc_manager.notification_handler.build_and_send_notification = MagicMock()
    metrics.OPC_CYCLES_WITHOUT_DATA.reset_mock()
    metrics.OPC_RECONNECTIONS_TOTAL.reset_mock()

    result = opc_manager.check_opc_listenning()

    assert opc_manager.non_receive_count == 4
    opc_manager.notification_handler.build_and_send_notification.assert_not_called()
    assert result is False

    metrics.OPC_CYCLES_WITHOUT_DATA.labels.assert_called_once_with(
        pod_id=opc_manager.pod_id,
        server_name=opc_manager.name
    )
    metrics.OPC_CYCLES_WITHOUT_DATA.labels.return_value.set.assert_called_once_with(
        opc_manager.non_receive_count)
    metrics.OPC_RECONNECTIONS_TOTAL.labels.assert_not_called()


def test_check_opc_listenning_warning_notification(opc_manager):
    opc_manager.non_receive_count = 4

    result = opc_manager.check_opc_listenning()

    assert opc_manager.non_receive_count == 5
    opc_manager.send_notification.assert_called_once_with(
        notification_id=f"OPC_LISTENNING_STOPPED__{opc_manager.name}",
        message=f"5 cycles without receive from OPC {opc_manager.name}. Tags: {json.dumps(opc_manager.nodes)}",
        block="opc_manager",
        level=NotificationLevel.ERROR,
        metadata=metadata["metadata"],
    )
    assert result is False


@patch('ingestor.managers.opc_manager.metrics')
def test_check_opc_listenning_error_notification_and_retry(metrics, opc_manager):
    opc_manager.non_receive_count = 14
    opc_manager.notification_handler.build_and_send_notification = MagicMock()
    metrics.OPC_CYCLES_WITHOUT_DATA.reset_mock()
    metrics.OPC_RECONNECTIONS_TOTAL.reset_mock()

    result = opc_manager.check_opc_listenning()

    assert opc_manager.non_receive_count == 15
    # Should be called twice: once for 5, once for 15
    assert opc_manager.send_notification.call_count == 2
    calls = opc_manager.send_notification.call_args_list
    # First call: 5 cycles warning
    assert calls[0].kwargs == {
        "notification_id": f"OPC_LISTENNING_STOPPED__{opc_manager.name}",
        "message": f"15 cycles without receive from OPC {opc_manager.name}. Tags: {json.dumps(opc_manager.nodes)}",
        "block": "opc_manager",
        "level": NotificationLevel.ERROR,
        "metadata": metadata["metadata"],
    }
    # Second call: 15 cycles retry
    assert calls[1].kwargs == {
        "notification_id": f"OPC_CONNECTION_RETRY__{opc_manager.name}",
        "message": f"Retrying to connect to server {opc_manager.name}",
        "block": "opc_manager",
        "level": NotificationLevel.ERROR,
        "metadata": metadata["metadata"],
    }
    assert result is True

    metrics.OPC_CYCLES_WITHOUT_DATA.labels.assert_called_once_with(
        pod_id=opc_manager.pod_id,
        server_name=opc_manager.name
    )
    metrics.OPC_CYCLES_WITHOUT_DATA.labels.return_value.set.assert_called_once_with(
        opc_manager.non_receive_count)

    metrics.OPC_RECONNECTIONS_TOTAL.labels.assert_called_once_with(
        pod_id=opc_manager.pod_id,
        server_name=opc_manager.name
    )
    metrics.OPC_RECONNECTIONS_TOTAL.labels.return_value.inc.assert_called_once()


@patch("ingestor.managers.opc_manager.metrics")
def test_init_metrics_calls_correct_metric_methods(metrics):

    opc_manager = OpcManager(
        name="TestInitConnector",
        url="opc.tcp://init.test:4840",
        data_manager=MagicMock(),
        logger=MagicMock(),
        server_uri="opc.tcp://init.test:4840/uri",
        notification_handler=MagicMock(),
        metadata=metadata["metadata"],
    )

    metrics.OPC_CONNECTION_STATUS.labels.assert_called_with(
        pod_id=opc_manager.pod_id,
        server_name=opc_manager.name,
        server_url=opc_manager.url,
    )

    metrics.OPC_CONNECTION_STATUS.labels.return_value.set.assert_called_once_with(
        0)

    metrics.OPC_TAGS_SUBSCRIBED.labels.assert_called_once_with(
        pod_id=opc_manager.pod_id,
        server_name=opc_manager.name
    )

    metrics.OPC_TAGS_SUBSCRIBED.labels.return_value.set.assert_called_once_with(
        0)