from types import SimpleNamespace

import pytest

from app.core import cdata_executor, genieacs
from app.core.provisioning_monitor import _finish_job


def test_management_dhcp_readback_waits_for_delayed_olt_confirmation(monkeypatch):
    responses = iter((
        "IP config: DHCP; Manage VLAN: 100",
        "IP config: DHCP; Manage VLAN: 160",
    ))
    calls = []

    def send(command, wait):
        calls.append(command)
        return next(responses)

    monkeypatch.setattr(cdata_executor.time, "sleep", lambda _: None)
    result = cdata_executor._wait_for_management_dhcp(send, "1", 7, 160, timeout=10)
    assert "Manage VLAN: 160" in result
    assert len(calls) == 2
    assert all(command.startswith("show ont ipconfig") for command in calls)


def test_management_dhcp_readback_has_a_bounded_timeout():
    with pytest.raises(cdata_executor.CDataExecutionError, match="setelah 0 detik"):
        cdata_executor._wait_for_management_dhcp(lambda *_: "Manage VLAN: 100", "1", 7, 160, timeout=0)


def test_dhcp_server_selects_a_writable_tr181_parameter(monkeypatch):
    device = {
        "_id": "ONT-1",
        "InternetGatewayDevice": {"LANDevice": {"1": {"LANHostConfigManagement": {
            "DHCPServerEnable": {"_value": True, "_writable": False}
        }}}},
        "Device": {"DHCPv4": {"Server": {"1": {
            "Enable": {"_value": True, "_writable": True}
        }}}},
    }
    monkeypatch.setattr(genieacs, "_device_for_serial", lambda _: device)
    requests = []
    monkeypatch.setattr(genieacs, "_request", lambda path, **kwargs: requests.append((path, kwargs)) or (202, {"_id": "task-1"}))

    result = genieacs.set_dhcp_server_configuration("ABC12345", enabled=False)
    assert result["accepted"] and result["queued"] and result["changed"]
    assert requests[0][1]["body"]["parameterValues"] == [["Device.DHCPv4.Server.1.Enable", False, "xsd:boolean"]]


@pytest.mark.asyncio
async def test_completed_job_closes_waiting_activity():
    event = SimpleNamespace(status="waiting", progress_percent=85, message="Still waiting")

    class Result:
        def scalars(self):
            return self

        def all(self):
            return [event]

    class FakeDB:
        def __init__(self):
            self.added = []

        async def execute(self, _statement):
            return Result()

        def add(self, item):
            self.added.append(item)

        async def commit(self):
            pass

    job = SimpleNamespace(
        id=1, customer_id=2, vendor="C-DATA", olt_device_id=3,
        mikrotik_device_id=4, progress_percent=99, status="waiting",
        result_message="", finished_at=None,
    )
    db = FakeDB()
    await _finish_job(db, job, "completed", "Provisioning verified", progress=100)

    assert job.status == "completed"
    assert job.progress_percent == 100
    assert event.status == "success"
    assert event.progress_percent == 100
