"""Regression checks for reusing ONTs after a customer is deleted."""
import asyncio
import copy
import datetime
import inspect
import os
import tempfile
import unittest
from unittest.mock import patch, AsyncMock
from types import SimpleNamespace
from fastapi.params import Form

from sqlalchemy import delete, select
from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker
from app.core import genieacs, provisioning_monitor, cdata_executor
from app.core.customer_identity import ensure_customer_id_sequence, allocate_customer_id
from app.core.mikrotik import RealMikrotikAdapter
from app.models.models import Base, Customer, ProvisioningJob, Site, OLTDevice, MikrotikDevice, ODP, ServicePackage, DeviceCredential

TABLE = "InternetGatewayDevice.WANDevice.1.WANConnectionDevice.1.WANPPPConnection"
ROUTE = "InternetGatewayDevice.Layer3Forwarding"
BINDING = "InternetGatewayDevice.X_ZTE-COM_PortBinding"


def node(value, now, writable=True):
    return {"_value": value, "_writable": writable, "_timestamp": now}


def obj(now, **values):
    return {"_object": True, "_timestamp": now, "_writable": True, **values}


def wan(user, status, vlan, now):
    return obj(now, Username=node(user, now), Password=node("", now),
        ConnectionStatus=node(status, now, False), ConnectionType=node("IP_Routed", now),
        Enable=node(True, now), NATEnabled=node(True, now),
        ExternalIPAddress=node("170.100.100.10" if status == "Connected" else "0.0.0.0", now, False),
        DNSEnabled=node(True, now), DNSServers=node("8.8.8.8", now),
        **{"X_ZTE-COM_VLANID": node(vlan, now), "X_ZTE-COM_VLANEnable": node(True, now),
           "X_ZTE-COM_ServiceList": node("INTERNET", now)})


def record(now):
    return {"_id": "device-1", "_lastInform": now, "InternetGatewayDevice": {
        "WANDevice": {"1": {"WANConnectionDevice": {"1": {"WANPPPConnection":
            obj(now, **{"1": wan("old-other", "Disconnected", 200, now),
                        "2": wan("old-customer", "Disconnected", 100, now)})}}}},
        "Layer3Forwarding": obj(now, DefaultConnectionService=node(TABLE + ".1", now)),
        "X_ZTE-COM_PortBinding": obj(now, **{"1": obj(now,
            LANInterface=node("InternetGatewayDevice.LANDevice.1.WLANConfiguration.1,InternetGatewayDevice.LANDevice.1.WLANConfiguration.5", now),
            WANInterface=node(TABLE + ".1", now))}),
        "LANDevice": {"1": {"LANHostConfigManagement": obj(now, DHCPServerEnable=node(True, now))}}
    }}


class Requests:
    def __init__(self, device):
        self.device = device
        self.tasks = []
        self.faults = []
        self.posts = []
        self.deleted = []

    def __call__(self, path, query=None, body=None, method=None, **kwargs):
        if path == "/devices/":
            return 200, [self.device]
        if path == "/tasks/":
            return 200, self.tasks
        if path == "/faults/":
            return 200, self.faults
        if method == "DELETE":
            self.deleted.append(path)
            return 200, None
        if body is not None:
            self.posts.append(copy.deepcopy(body))
            self.tasks.append({"_id": "queued", **copy.deepcopy(body)})
            return 202, {"_id": "queued"}
        raise AssertionError(path)


class WanReuseTests(unittest.TestCase):
    def setUp(self):
        self.now = datetime.datetime.now(datetime.timezone.utc)
        self.stamp = self.now.isoformat()
        self.requests = Requests(record(self.stamp))
        self.patcher = patch.object(genieacs, "_request", self.requests)
        self.patcher.start()
        self.addCleanup(self.patcher.stop)

    def call(self, **kwargs):
        return genieacs.sync_psb_internet_wan("ZTEGD06BD270", username="new-customer",
            password="test-password", vlan=100, **kwargs)

    def test_reuse_wan_then_rebind_without_duplicate(self):
        self.assertFalse(self.call()["ready"])
        first = [x[0] for x in self.requests.posts[0]["parameterValues"]]
        self.assertIn(TABLE + ".2.Username", first)
        self.assertIn(TABLE + ".2.Password", first)
        self.assertNotIn(ROUTE + ".DefaultConnectionService", first)
        self.assertEqual(self.call()["state"], "waiting")
        self.assertEqual(len(self.requests.posts), 1)
        self.requests.tasks.clear()
        device = self.requests.device["InternetGatewayDevice"]
        row = device["WANDevice"]["1"]["WANConnectionDevice"]["1"]["WANPPPConnection"]["2"]
        row["Username"] = node("new-customer", self.stamp)
        self.call()
        second = [x[0] for x in self.requests.posts[1]["parameterValues"]]
        self.assertEqual(second, [ROUTE + ".DefaultConnectionService"])
        self.requests.tasks.clear()
        device["Layer3Forwarding"]["DefaultConnectionService"] = node(TABLE + ".2", self.stamp)
        self.call()
        third = [x[0] for x in self.requests.posts[2]["parameterValues"]]
        self.assertEqual(third, [BINDING + ".1.WANInterface"])
        self.requests.tasks.clear()
        row["ConnectionStatus"] = node("Connected", self.stamp, False)
        row["ExternalIPAddress"] = node("170.100.100.10", self.stamp, False)
        device["X_ZTE-COM_PortBinding"]["1"]["WANInterface"] = node(TABLE + ".2", self.stamp)
        self.assertTrue(self.call()["ready"])
        self.assertEqual(len(self.requests.posts), 3)

    def test_ambiguous_wan_is_not_modified(self):
        rows = self.requests.device["InternetGatewayDevice"]["WANDevice"]["1"]["WANConnectionDevice"]["1"]["WANPPPConnection"]
        rows["3"] = wan("other", "Disconnected", 100, self.stamp)
        with self.assertRaises(genieacs.GenieACSUnavailable):
            self.call()
        self.assertEqual(self.requests.posts, [])

    def test_connected_other_customer_is_not_overwritten(self):
        rows = self.requests.device["InternetGatewayDevice"]["WANDevice"]["1"]["WANConnectionDevice"]["1"]["WANPPPConnection"]
        rows["2"] = wan("other", "Connected", 100, self.stamp)
        with self.assertRaises(genieacs.GenieACSUnavailable):
            self.call()
        self.assertEqual(self.requests.posts, [])

    def test_prior_failed_task_only_is_cleared(self):
        before = (self.now - datetime.timedelta(days=1)).isoformat()
        self.requests.tasks = [
            {"_id": "old", "name": "setParameterValues", "timestamp": before,
             "parameterValues": [["InternetGatewayDevice.LANDevice.1.WLANConfiguration.4.SSID", "old", "xsd:string"]]},
            {"_id": "current", "name": "setParameterValues", "timestamp": self.stamp,
             "parameterValues": [["InternetGatewayDevice.LANDevice.1.WLANConfiguration.4.SSID", "new", "xsd:string"]]},
        ]
        self.requests.faults = [{"channel": "task_old"}, {"channel": "task_current"}]
        result = self.call(customer_created_at=self.now - datetime.timedelta(minutes=1))
        self.assertEqual(result["state"], "waiting")
        self.assertEqual(self.requests.deleted, ["/tasks/old"])

    def test_one_wan_creation_task_is_not_duplicated(self):
        self.requests.device["InternetGatewayDevice"]["WANDevice"]["1"]["WANConnectionDevice"]["1"]["WANPPPConnection"] = obj(self.stamp)
        self.assertEqual(self.call()["state"], "waiting")
        self.assertEqual(self.requests.posts[0]["name"], "addObject")
        self.assertEqual(self.call()["state"], "waiting")
        self.assertEqual(len(self.requests.posts), 1)

    def test_stale_object_refresh_is_not_duplicated(self):
        self.requests.device["InternetGatewayDevice"]["Layer3Forwarding"]["_timestamp"] = "2020-01-01T00:00:00Z"
        self.assertEqual(self.call()["state"], "waiting")
        self.assertEqual(self.requests.posts[0]["name"], "refreshObject")
        self.assertEqual(self.call()["state"], "waiting")
        self.assertEqual(len(self.requests.posts), 1)

    def test_waits_for_inform_after_new_customer_created(self):
        result = self.call(customer_created_at=self.now + datetime.timedelta(seconds=1))
        self.assertEqual(result["state"], "waiting")
        self.assertIn("pembaruan", result["message"])
        self.assertEqual(self.requests.posts, [])

    def test_current_customer_failed_wifi_task_is_not_deleted(self):
        self.requests.tasks = [{"_id": "current", "name": "setParameterValues",
            "timestamp": self.stamp,
            "parameterValues": [["InternetGatewayDevice.LANDevice.1.WLANConfiguration.4.SSID", "new", "xsd:string"]]}]
        self.requests.faults = [{"channel": "task_current", "code": "cwmp.9003"}]
        result = self.call(customer_created_at=self.now - datetime.timedelta(minutes=1))
        self.assertEqual(result["state"], "failed")
        self.assertEqual(self.requests.deleted, [])
        self.assertEqual(self.requests.posts, [])

    def test_inactive_dhcp_does_not_claim_success(self):
        self.requests.device["InternetGatewayDevice"]["LANDevice"]["1"]["LANHostConfigManagement"]["DHCPServerEnable"] = node(False, self.stamp)
        with self.assertRaises(genieacs.GenieACSUnavailable):
            self.call()
        self.assertEqual(self.requests.posts, [])


class ManagementOnlyTests(unittest.TestCase):
    def test_management_path_never_creates_pppoe_iphost_or_olt_wan(self):
        class Sock:
            def close(self):
                pass
        class Channel:
            def __init__(self):
                self.last = ""
                self.commands = []
            def get_pty(self, **kwargs):
                pass
            def invoke_shell(self):
                pass
            def send(self, value):
                self.last = value.strip()
                self.commands.append(self.last)
            def close(self):
                pass
        class Transport:
            def __init__(self, channel):
                self.channel = channel
            def start_client(self, **kwargs):
                pass
            def get_remote_server_key(self):
                return object()
            def auth_password(self, *args, **kwargs):
                pass
            def is_authenticated(self):
                return True
            def open_session(self, **kwargs):
                return self.channel
            def close(self):
                pass
        channel = Channel()
        def read(chan, delay):
            if chan.last.startswith("show ont ipconfig"):
                return "ONT config type : DHCP\nONT manage VLAN : 160\n"
            if chan.last.startswith("show ont info"):
                return "SN : ZTEGD8157855\n<Gem ID 1>\nMapping-ID VLAN Priority Port-ID\n 1 100 - -\n 2 150 - -\n 3 160 - -\n----------------\n"
            return "OK"
        with patch.object(cdata_executor.socket, "create_connection", return_value=Sock()), \
             patch("paramiko.Transport", return_value=Transport(channel)), \
             patch.object(cdata_executor, "_normalize_sha256_fingerprint", return_value="fp"), \
             patch.object(cdata_executor, "_fingerprint", return_value="fp"), \
             patch.object(cdata_executor, "decrypt_secret", return_value="secret"), \
             patch.object(cdata_executor, "_read", side_effect=read):
            result = cdata_executor.provision_cdata_pppoe(
                host="test", port=22, username="admin", encrypted_secret="x",
                pinned_host_key="x", pon_port="0/0/1", onu_id=1,
                serial_number="ZTEGD8157855", pppoe_username="TEST",
                pppoe_password="secret", vlan=100, management_vlan=160,
                management_only=True,
            )
        self.assertFalse(result.runtime_ready)
        self.assertFalse(any(command.startswith("ont wan ") or "ip-index 1" in command for command in channel.commands))


    def test_vlan_mapping_parser_is_scoped_to_requested_gem(self):
        info = ("<Gem ID 1>\nMapping-ID VLAN Priority\n1 100 -\n2 150 -\n3 160 -\n"
                "--------------\n<Gem ID 2>\nMapping-ID VLAN Priority\n1 999 -\n")
        self.assertEqual(cdata_executor._parse_cdata_gem_vlan_mappings(info, 1), {1: 100, 2: 150, 3: 160})
        with self.assertRaises(cdata_executor.CDataExecutionError):
            cdata_executor._parse_cdata_gem_vlan_mappings(info, 3)


class FakeResource:
    def __init__(self, rows):
        self.rows = rows

    def get(self, name):
        return [row.copy() for row in self.rows if row["name"] == name]

    def remove(self, id):
        self.rows[:] = [row for row in self.rows if row["id"] != id]


class FakePool:
    def __init__(self):
        self.secret = FakeResource([{"id": "s1", "name": "target"}, {"id": "s2", "name": "other"}])
        self.active = FakeResource([{"id": "a1", "name": "target"}, {"id": "a2", "name": "other"}])

    def get_api(self):
        return self

    def get_resource(self, path):
        return self.secret if path == "/ppp/secret" else self.active

    def disconnect(self):
        pass


class CleanupTests(unittest.TestCase):
    def test_only_target_secret_and_session_are_removed_and_retry_is_safe(self):
        pool = FakePool()
        adapter = RealMikrotikAdapter("host", "user", "password")
        with patch.object(adapter, "_get_api", return_value=pool):
            adapter.delete_pppoe_secret("target")
            adapter.delete_pppoe_secret("target")
        self.assertEqual(pool.secret.rows, [{"id": "s2", "name": "other"}])
        self.assertEqual(pool.active.rows, [{"id": "a2", "name": "other"}])


class ProvisioningJobTests(unittest.IsolatedAsyncioTestCase):
    async def test_saved_customer_waits_for_wan_and_finishes_once(self):
        engine = create_async_engine("sqlite+aiosqlite:///:memory:")
        sessions = async_sessionmaker(engine, expire_on_commit=False)
        async def run_onboarding(customer, db, on_stage=None):
            customer.olt_provisioning_status = "waiting_session"
            customer.mikrotik_provisioning_status = "waiting_session"
            customer.provisioning_status = "waiting_session"
            customer.status = "waiting_session"
            await db.commit()
        async def refresh(customer, db):
            customer.status = "active"
            customer.provisioning_status = "provisioned"
            customer.olt_provisioning_status = "provisioned"
            customer.mikrotik_provisioning_status = "provisioned"
            await db.commit()
            return "active"
        try:
            async with engine.begin() as conn:
                await conn.run_sync(Base.metadata.create_all)
            async with sessions() as db:
                db.add(Customer(id=1, name="test", customer_code="PLG-TEST", ont_sn="ZTEGD06BD270",
                    olt_vendor="C-DATA", olt_model="FD1601S-B1", service_mode="private_pppoe",
                    provisioning_mode="private_pppoe", play_type="1play", is_archived=False,
                    pppoe_username="PLG-TEST", pppoe_password="encrypted"))
                db.add(ProvisioningJob(id=1, customer_id=1, target="onboarding", status="queued",
                    attempts=0, progress_percent=10))
                await db.commit()
            sync = AsyncMock(side_effect=[
                {"ready": False, "state": "waiting", "message": "WAN pending"},
                {"ready": True, "state": "ready", "message": "WAN ready"},
            ])
            with patch.object(provisioning_monitor, "AsyncSessionLocal", sessions), \
                 patch.object(provisioning_monitor, "run_onboarding", run_onboarding), \
                 patch.object(provisioning_monitor, "refresh_customer_online_status", refresh), \
                 patch.object(provisioning_monitor, "sync_psb_customer_wan", sync):
                await provisioning_monitor._process_queued(1)
                async with sessions() as db:
                    job = await db.get(ProvisioningJob, 1)
                    self.assertEqual(job.status, "waiting")
                    self.assertLess(job.progress_percent, 100)
                await provisioning_monitor._check_waiting_job(1)
                async with sessions() as db:
                    job = await db.get(ProvisioningJob, 1)
                    self.assertEqual(job.status, "completed")
                    self.assertEqual(job.progress_percent, 100)
                    self.assertEqual(len((await db.execute(__import__("sqlalchemy").select(Customer))).scalars().all()), 1)
        finally:
            await engine.dispose()


class AddCustomerTests(unittest.IsolatedAsyncioTestCase):
    async def test_deleted_customer_can_be_readded_once_without_inheriting_old_id(self):
        from app.routes import customers as route
        engine = create_async_engine("sqlite+aiosqlite:///:memory:")
        sessions = async_sessionmaker(engine, expire_on_commit=False)
        try:
            async with engine.begin() as conn:
                await conn.run_sync(Base.metadata.create_all)
            async with sessions() as db:
                db.add_all([
                    Site(id=1, code="site1", name="Test", is_active=True),
                    DeviceCredential(id=1, name="olt", protocol="ssh", username="u", encrypted_secret="x", is_active=True),
                    OLTDevice(id=1, name="OLT Test", host="127.0.0.1", vendor="C-DATA", model="FD1601S-B1",
                              management_protocol="ssh", api_port=22, credential_id=1, is_active=True),
                    MikrotikDevice(id=1, name="MK", host="127.0.0.1", site_id=1, is_active=True),
                    ODP(id=1, code="ODP1", name="ODP1", mikrotik_device_id=1, is_active=True),
                    ServicePackage(id=1, code="P1", name="P1", service_type="bulanan_ppp",
                                   service_mode="private_pppoe", price=1000, mikrotik_profile="default",
                                   pppoe_vlan=100, hotspot_vlan=150, iptv_vlan=200, is_active=True),
                    Customer(id=1, name="old", ont_sn="ZTEGD06BD270", is_archived=False),
                    ProvisioningJob(id=1, customer_id=1, target="onboarding", status="completed",
                                    progress_percent=100, submission_key="old-key"),
                ])
                await db.commit()
                await ensure_customer_id_sequence(db)
                await db.commit()
                await db.execute(delete(Customer).where(Customer.id == 1))
                await db.commit()
                kwargs = {name: param.default.default for name, param in inspect.signature(route.add_customer).parameters.items()
                          if isinstance(param.default, Form)}
                kwargs.update(request=None, db=db, submission_key="new-test-key", name="New customer",
                    nik="1234567890123456", address="Test", phone="0812345", cust_type="personal", harga_paket=1000,
                    package_id=1, odp_id=1, olt_device_id=1, mikrotik_device_id=1, ont_sn="ZTEGD06BD270",
                    ont_brand="ZTE", olt_port="0/0/1", onu_id=1, ont_sn_mode="auto", onu_id_mode="auto",
                    olt_port_mode="auto", ont_brand_mode="auto")
                profile = SimpleNamespace(key="cdata-fd1601s-b1", execution_state="live_supported", fields=[])
                discovered = [SimpleNamespace(serial_number="ZTEGD06BD270", port="0/0/1", onu_id=1, brand="ZTE")]
                with patch.object(route, "get_vendor_profile", return_value=profile), \
                     patch.object(route, "discover_unregistered_onts", return_value=discovered), \
                     patch.object(route, "_site_id_for_olt", return_value=1), \
                     patch.object(route, "encrypt_default_pppoe_password", return_value="encrypted-test"):
                    first = await route.add_customer(**kwargs)
                    retry = await route.add_customer(**kwargs)
                customers = (await db.execute(select(Customer))).scalars().all()
                self.assertEqual(len(customers), 1)
                self.assertEqual(customers[0].id, 2)
                self.assertEqual(customers[0].customer_code, "PLG-0000002")
                self.assertEqual(first.headers["location"], retry.headers["location"])
                jobs = (await db.execute(select(ProvisioningJob).where(
                    ProvisioningJob.submission_key == "new-test-key"))).scalars().all()
                self.assertEqual(len(jobs), 1)
                self.assertEqual(jobs[0].customer_id, 2)
                self.assertEqual(jobs[0].status, "queued")
        finally:
            await engine.dispose()


class IdentityTests(unittest.IsolatedAsyncioTestCase):
    async def test_serial_cannot_be_reused_with_case_or_space_changes(self):
        from sqlalchemy.exc import IntegrityError
        engine = create_async_engine("sqlite+aiosqlite:///:memory:")
        sessions = async_sessionmaker(engine, expire_on_commit=False)
        try:
            async with engine.begin() as conn:
                await conn.run_sync(Base.metadata.create_all)
            async with sessions() as db:
                await ensure_customer_id_sequence(db)
                db.add(Customer(id=1, name="first", ont_sn="ZTEGD06BD270"))
                await db.commit()
                db.add(Customer(id=2, name="second", ont_sn=" ztegd06bd270 "))
                with self.assertRaises(IntegrityError):
                    await db.commit()
                await db.rollback()
        finally:
            await engine.dispose()

    async def test_ids_survive_complete_deletion_and_concurrent_creation(self):
        fd, path = tempfile.mkstemp(prefix="bestweb_seq_test_", suffix=".sqlite")
        os.close(fd)
        engine = create_async_engine("sqlite+aiosqlite:///" + path)
        sessions = async_sessionmaker(engine, expire_on_commit=False)
        try:
            async with engine.begin() as conn:
                await conn.run_sync(Base.metadata.create_all)
            async with sessions() as db:
                db.add(Customer(id=3, name="old"))
                db.add(ProvisioningJob(id=1, customer_id=6, target="onboarding", status="completed", progress_percent=100))
                await db.commit()
                await ensure_customer_id_sequence(db)
                await db.commit()
                await db.execute(delete(Customer))
                await db.execute(delete(ProvisioningJob))
                await db.commit()
                first = await allocate_customer_id(db)
                db.add(Customer(id=first, name="new"))
                await db.commit()
                self.assertEqual(first, 7)

            async def create_one():
                async with sessions() as db:
                    number = await allocate_customer_id(db)
                    db.add(Customer(id=number, name="new"))
                    await db.commit()
                    return number

            self.assertEqual(sorted(await asyncio.gather(create_one(), create_one())), [8, 9])
        finally:
            await engine.dispose()
            os.unlink(path)


if __name__ == "__main__":
    unittest.main()
