"""Sized cluster demo seeds: small / large / big (+ demo→large alias)."""

from __future__ import annotations

import json
from dataclasses import dataclass
from typing import Any

from asyncpg import Connection

from app.ovirt.ids import stable_id
from app.ovirt.seed import clear_ovirt_state
from app.security.auth import hash_secret


@dataclass(frozen=True)
class ClusterSizeSpec:
    """Topology + inventory density for a demo cluster size."""

    name: str
    hosts: int
    vms: int
    datacenters: int
    clusters_per_dc: int
    hosts_per_cluster: int
    networks_per_dc: int
    storage_per_dc: int
    templates: tuple[str, ...]
    tags: tuple[str, ...]
    groups: tuple[str, ...]
    events: int
    jobs: int
    bookmarks: tuple[tuple[str, str], ...]
    instancetypes: tuple[str, ...]
    macpools: tuple[str, ...]
    vmpools: tuple[str, ...]
    affinitylabels: tuple[str, ...]
    katelloerrata: tuple[str, ...]
    icons: tuple[str, ...]
    operatingsystems: tuple[str, ...]


CLUSTER_SIZES: dict[str, ClusterSizeSpec] = {
    "small": ClusterSizeSpec(
        name="small",
        hosts=3,
        vms=50,
        datacenters=1,
        clusters_per_dc=1,
        hosts_per_cluster=3,
        networks_per_dc=2,
        storage_per_dc=2,
        templates=("rhel9-base", "ubuntu2204-base"),
        tags=("lab", "web"),
        groups=("developers", "readers"),
        events=15,
        jobs=5,
        bookmarks=(("UpVMs", "Vms: status=up"),),
        instancetypes=("Small", "Medium"),
        macpools=("Default",),
        vmpools=("web-pool",),
        affinitylabels=("label-a",),
        katelloerrata=("RHSA-2024:0001",),
        icons=("default",),
        operatingsystems=("rhel_9x64", "ubuntu_22_04"),
    ),
    "large": ClusterSizeSpec(
        name="large",
        hosts=10,
        vms=1000,
        datacenters=2,
        clusters_per_dc=1,
        hosts_per_cluster=5,
        networks_per_dc=3,
        storage_per_dc=3,
        templates=("rhel8-base", "rhel9-base", "win2022-base", "ubuntu2204-base"),
        tags=("production", "web", "database", "batch", "gpu"),
        groups=("developers", "operators", "readers"),
        events=50,
        jobs=20,
        bookmarks=(
            ("UpVMs", "Vms: status=up"),
            ("DownVMs", "Vms: status=down"),
        ),
        instancetypes=("Tiny", "Small", "Medium", "Large", "XLarge"),
        macpools=("Default", "Secondary"),
        vmpools=("web-pool", "batch-pool"),
        affinitylabels=("label-a", "label-b"),
        katelloerrata=("RHSA-2024:0001", "RHBA-2024:0002"),
        icons=("default", "custom"),
        operatingsystems=("rhel_8x64", "rhel_9x64", "windows_2022", "ubuntu_22_04"),
    ),
    "big": ClusterSizeSpec(
        name="big",
        hosts=30,
        vms=2000,
        datacenters=3,
        clusters_per_dc=2,
        hosts_per_cluster=5,
        networks_per_dc=3,
        storage_per_dc=4,
        templates=(
            "rhel8-base",
            "rhel9-base",
            "win2022-base",
            "ubuntu2204-base",
            "centos-stream9",
            "debian12-base",
        ),
        tags=(
            "production",
            "web",
            "database",
            "batch",
            "gpu",
            "edge",
            "staging",
            "critical",
        ),
        groups=("developers", "operators", "readers", "auditors"),
        events=120,
        jobs=40,
        bookmarks=(
            ("UpVMs", "Vms: status=up"),
            ("DownVMs", "Vms: status=down"),
            ("ProdHosts", "Hosts:"),
        ),
        instancetypes=("Tiny", "Small", "Medium", "Large", "XLarge", "2XLarge", "4XLarge"),
        macpools=("Default", "Secondary", "Edge"),
        vmpools=("web-pool", "batch-pool", "gpu-pool", "edge-pool"),
        affinitylabels=("label-a", "label-b", "label-c", "label-d"),
        katelloerrata=("RHSA-2024:0001", "RHBA-2024:0002", "RHSA-2024:1001"),
        icons=("default", "custom", "windows", "linux"),
        operatingsystems=(
            "rhel_8x64",
            "rhel_9x64",
            "windows_2022",
            "ubuntu_22_04",
            "centos_stream9",
            "debian_12",
        ),
    ),
}

# Canonical demo profile names that must not be wiped on simulator restart.
DEMO_PROFILES: frozenset[str] = frozenset(CLUSTER_SIZES) | {"demo"}
# Default / legacy alias target.
DEMO_PROFILE = "large"
DEMO_VM_COUNT = CLUSTER_SIZES["large"].vms


def normalize_cluster_size(size: str | None) -> str:
    """Map CLI/UI aliases to a ClusterSizeSpec name."""

    key = (size or DEMO_PROFILE).strip().lower()
    if key == "demo":
        return "large"
    if key not in CLUSTER_SIZES:
        raise ValueError(f"unknown cluster size {size!r}; expected small|large|big|demo")
    return key


def cluster_size_spec(size: str | None = None) -> ClusterSizeSpec:
    return CLUSTER_SIZES[normalize_cluster_size(size)]


_DC_NAMES = (
    ("dc-prod", "Production", False, 4, 5),
    ("dc-stage", "Staging", False, 4, 4),
    ("dc-edge", "Edge", True, 4, 3),
)
_NETWORK_SPECS = (("ovirtmgmt", None), ("vm-net", 100), ("storage-net", 200))
_STORAGE_TYPES = ("nfs", "iscsi", "fcp", "localfs")
_TEMPLATE_SPECS: dict[str, tuple[int, int]] = {
    "rhel8-base": (4 * 1024**3, 2),
    "rhel9-base": (4 * 1024**3, 2),
    "win2022-base": (8 * 1024**3, 4),
    "ubuntu2204-base": (2 * 1024**3, 2),
    "centos-stream9": (4 * 1024**3, 2),
    "debian12-base": (2 * 1024**3, 2),
}


async def seed_ovirt_demo(conn: Connection, size: str | None = None) -> dict[str, Any]:
    """Replace state with a sized multi-host demo inventory."""

    spec = cluster_size_spec(size)
    expected_hosts = spec.datacenters * spec.clusters_per_dc * spec.hosts_per_cluster
    if expected_hosts != spec.hosts:
        raise RuntimeError(
            f"cluster size {spec.name}: topology hosts {expected_hosts} != declared {spec.hosts}"
        )

    await clear_ovirt_state(conn)

    domain_id = stable_id("domain", "internal")
    await conn.execute("INSERT INTO ov_domains(id, name) VALUES($1,'internal')", domain_id)
    pwd = hash_secret("secret", salt=b"ovirt-sim-v1-salt!")
    role_super = stable_id("role", "SuperUser")
    role_user = stable_id("role", "UserRole")
    role_cluster = stable_id("role", "ClusterAdmin")
    for rid, name, admin in (
        (role_super, "SuperUser", True),
        (role_user, "UserRole", False),
        (role_cluster, "ClusterAdmin", True),
        (stable_id("role", "TemplateAdmin"), "TemplateAdmin", True),
        (stable_id("role", "StorageAdmin"), "StorageAdmin", True),
    ):
        await conn.execute(
            "INSERT INTO ov_roles(id, name, administrative) VALUES($1,$2,$3)",
            rid,
            name,
            admin,
        )

    users: dict[str, Any] = {}
    for uname, role in (
        ("admin", role_super),
        ("ops", role_cluster),
        ("developer", role_user),
        ("demo", role_user),
    ):
        uid = stable_id("user", uname)
        users[uname] = uid
        await conn.execute(
            """INSERT INTO ov_users(id, domain_id, name, password_hash, enabled, principal)
               VALUES($1,$2,$3,$4,true,$5)""",
            uid,
            domain_id,
            uname,
            pwd,
            f"{uname}@internal",
        )
        await conn.execute(
            """INSERT INTO ov_permissions(id, role_id, user_id, object_type)
               VALUES($1,$2,$3,'system')""",
            stable_id("perm", uname),
            role,
            uid,
        )

    await conn.execute(
        "INSERT INTO ov_groups(id, domain_id, name) VALUES($1,$2,'engine-admins')",
        stable_id("group", "engine-admins"),
        domain_id,
    )
    for gname in spec.groups:
        await conn.execute(
            "INSERT INTO ov_groups(id, domain_id, name) VALUES($1,$2,$3)",
            stable_id("group", gname),
            domain_id,
            gname,
        )

    dc_specs = list(_DC_NAMES[: spec.datacenters])
    clusters: list[tuple[Any, Any, str]] = []
    hosts: list[Any] = []
    networks: list[Any] = []
    profiles: list[Any] = []
    storage_domains: list[Any] = []

    for dc_idx, (dc_key, dc_name, local, maj, minor) in enumerate(dc_specs):
        dc_id = stable_id("dc", dc_key)
        await conn.execute(
            """INSERT INTO ov_datacenters(id, name, description, local, status, version_major, version_minor)
               VALUES($1,$2,$3,$4,'up',$5,$6)""",
            dc_id,
            dc_name,
            f"{dc_name} datacenter",
            local,
            maj,
            minor,
        )
        await conn.execute(
            """INSERT INTO ov_quotas(id, datacenter_id, name, description)
               VALUES($1,$2,'Default','Default quota')""",
            stable_id("quota", dc_key),
            dc_id,
        )
        for ci in range(spec.clusters_per_dc):
            cname = f"{dc_key}-cluster-{ci + 1}"
            cid = stable_id("cluster", cname)
            clusters.append((cid, dc_id, cname))
            await conn.execute(
                """INSERT INTO ov_clusters(id, datacenter_id, name, description, version_major, version_minor)
                   VALUES($1,$2,$3,$4,$5,$6)""",
                cid,
                dc_id,
                cname,
                f"Cluster {ci + 1} in {dc_name}",
                maj,
                minor,
            )
            await conn.execute(
                """INSERT INTO ov_affinity_groups(id, cluster_id, name, enforcing, positive)
                   VALUES($1,$2,'web-affinity',true,true)""",
                stable_id("ag", cname),
                cid,
            )
            for hi in range(spec.hosts_per_cluster):
                hname = f"{cname}-host-{hi + 1:02d}"
                hid = stable_id("host", hname)
                hosts.append(hid)
                await conn.execute(
                    """INSERT INTO ov_hosts(id, cluster_id, name, address, status, memory, cpu_cores, type)
                       VALUES($1,$2,$3,$4,'up',$5,32,'rhel')""",
                    hid,
                    cid,
                    hname,
                    f"10.{10 + dc_idx}.{ci + 1}.{hi + 10}",
                    (256 + hi * 32) * 1024**3,
                )

        for nname, vlan in _NETWORK_SPECS[: spec.networks_per_dc]:
            nid = stable_id("net", dc_key, nname)
            networks.append(nid)
            if nname == "ovirtmgmt" and dc_key == "dc-prod":
                net_label = "ovirtmgmt"
            elif nname == "ovirtmgmt":
                net_label = f"{dc_key}-ovirtmgmt"
            elif spec.datacenters > 1:
                net_label = f"{dc_key}-{nname}"
            else:
                net_label = nname
            await conn.execute(
                """INSERT INTO ov_networks(id, datacenter_id, name, description, vlan_id)
                   VALUES($1,$2,$3,$4,$5)""",
                nid,
                dc_id,
                net_label,
                f"{nname} in {dc_name}",
                vlan,
            )
            pid = stable_id("vnic", dc_key, nname)
            profiles.append(pid)
            await conn.execute(
                "INSERT INTO ov_vnic_profiles(id, network_id, name) VALUES($1,$2,$3)",
                pid,
                nid,
                nname,
            )

        for si, stype in enumerate(_STORAGE_TYPES[: spec.storage_per_dc]):
            sname = f"{dc_key}-{stype}-{si + 1}"
            sid = stable_id("sd", sname)
            storage_domains.append(sid)
            await conn.execute(
                """INSERT INTO ov_storage_domains(id, name, type, storage_type, status, available, used)
                   VALUES($1,$2,'data',$3,'active',$4,$5)""",
                sid,
                sname,
                stype,
                (5 + si) * 1024**4,
                si * 200 * 1024**3,
            )
            await conn.execute(
                """INSERT INTO ov_storage_domain_attachments(id, storage_domain_id, datacenter_id, status)
                   VALUES($1,$2,$3,'active')""",
                stable_id("sda", sname),
                sid,
                dc_id,
            )
            await conn.execute(
                """INSERT INTO ov_storage_connections(id, type, address, path)
                   VALUES($1,$2,$3,$4)""",
                stable_id("sc", sname),
                stype if stype != "localfs" else "localfs",
                f"storage-{si}.lab.local",
                f"/export/{sname}",
            )

    blank_id = stable_id("template", "Blank")
    await conn.execute(
        """INSERT INTO ov_templates(id, cluster_id, name, description, status, memory, cpu_sockets, cpu_cores)
           VALUES($1,$2,'Blank','Blank template','ok',$3,1,1)""",
        blank_id,
        clusters[0][0],
        1024**3,
    )
    for tname in spec.templates:
        mem, cores = _TEMPLATE_SPECS.get(tname, (2 * 1024**3, 2))
        await conn.execute(
            """INSERT INTO ov_templates(id, cluster_id, name, description, status, memory, cpu_sockets, cpu_cores)
               VALUES($1,$2,$3,$4,'ok',$5,1,$6)""",
            stable_id("template", tname),
            clusters[0][0],
            tname,
            f"Template {tname}",
            mem,
            cores,
        )

    statuses = ["up", "up", "up", "down", "down", "suspended", "powering_up"]
    os_types = list(spec.operatingsystems) or ["other"]
    default_profile = profiles[0]

    vm_rows = []
    disk_rows = []
    da_rows = []
    nic_rows = []
    snap_rows = []

    for i in range(spec.vms):
        cluster_id, _dc, _cname = clusters[i % len(clusters)]
        host_id = hosts[i % len(hosts)] if i % 3 != 0 else None
        status = statuses[i % len(statuses)]
        if status == "down":
            host_id = None
        name = f"vm-{i + 1:04d}"
        vm_id = stable_id("vm", name)
        memory = (1 + (i % 8)) * 1024**3
        cores = 1 + (i % 8)
        vm_rows.append(
            (
                vm_id,
                cluster_id,
                blank_id,
                name,
                f"Demo VM {i + 1}",
                status,
                memory,
                1,
                cores,
                1,
                os_types[i % len(os_types)],
                "server" if i % 5 else "desktop",
                host_id,
            )
        )
        disk_id = stable_id("disk", name)
        size = (10 + (i % 50)) * 1024**3
        disk_rows.append(
            (disk_id, f"{name}_Disk1", size, size, storage_domains[i % len(storage_domains)])
        )
        da_rows.append((stable_id("da", name), vm_id, disk_id, True))
        nic_rows.append(
            (
                stable_id("nic", name),
                vm_id,
                "nic1",
                f"00:1a:4a:{(i >> 16) & 0xFF:02x}:{(i >> 8) & 0xFF:02x}:{i & 0xFF:02x}",
                profiles[i % len(profiles)] if profiles else default_profile,
            )
        )
        if i % 7 == 0:
            snap_rows.append((stable_id("snap", name, "1"), vm_id, f"snapshot-{name}", "ok"))

    await conn.executemany(
        """INSERT INTO ov_vms(id, cluster_id, template_id, name, description, status,
           memory, cpu_sockets, cpu_cores, cpu_threads, os_type, type, host_id)
           VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13)""",
        vm_rows,
    )
    await conn.executemany(
        """INSERT INTO ov_disks(id, name, provisioned_size, actual_size, storage_domain_id)
           VALUES($1,$2,$3,$4,$5)""",
        disk_rows,
    )
    await conn.executemany(
        """INSERT INTO ov_disk_attachments(id, vm_id, disk_id, bootable)
           VALUES($1,$2,$3,$4)""",
        da_rows,
    )
    await conn.executemany(
        """INSERT INTO ov_nics(id, vm_id, name, mac_address, vnic_profile_id)
           VALUES($1,$2,$3,$4,$5)""",
        nic_rows,
    )
    if snap_rows:
        await conn.executemany(
            """INSERT INTO ov_snapshots(id, vm_id, description, status)
               VALUES($1,$2,$3,$4)""",
            snap_rows,
        )

    tag_step = max(1, spec.vms // 10)
    for tname in spec.tags:
        tid = stable_id("tag", tname)
        await conn.execute(
            "INSERT INTO ov_tags(id, name, description) VALUES($1,$2,$3)",
            tid,
            tname,
            f"Tag {tname}",
        )
        for i in range(0, min(spec.vms, tag_step * 5), tag_step):
            await conn.execute(
                """INSERT INTO ov_tag_assignments(id, tag_id, object_type, object_id)
                   VALUES($1,$2,'vm',$3) ON CONFLICT DO NOTHING""",
                stable_id("ta", tname, str(i)),
                tid,
                stable_id("vm", f"vm-{i + 1:04d}"),
            )

    for bname, bvalue in spec.bookmarks:
        await conn.execute(
            "INSERT INTO ov_bookmarks(id, name, value) VALUES($1,$2,$3)",
            stable_id("bm", bname),
            bname,
            bvalue,
        )
    for i in range(spec.events):
        await conn.execute(
            """INSERT INTO ov_events(code, severity, description, user_id)
               VALUES($1,$2,$3,$4)""",
            1000 + i,
            "normal" if i % 4 else "warning",
            f"Demo event {i}",
            users["admin"],
        )
    for i in range(spec.jobs):
        jid = stable_id("job", str(i))
        await conn.execute(
            """INSERT INTO ov_jobs(id, description, status, owner_id)
               VALUES($1,$2,'finished',$3)""",
            jid,
            f"Demo job {i}",
            users["admin"],
        )
        await conn.execute(
            """INSERT INTO ov_job_steps(id, job_id, description, status, type, number)
               VALUES($1,$2,$3,'finished','executing',1)""",
            stable_id("step", str(i)),
            jid,
            f"Step for job {i}",
        )

    surface: list[tuple[str, tuple[str, ...]]] = [
        ("instancetypes", spec.instancetypes),
        ("macpools", spec.macpools),
        (
            "schedulingpolicies",
            ("evenly_distributed", "power_saving", "vm_evenly_distributed"),
        ),
        (
            "schedulingpolicyunits",
            ("EvenlyDistributed", "PowerSaving", "VmEvenlyDistributed"),
        ),
        ("clusterlevels", ("4.3", "4.4", "4.5")),
        ("icons", spec.icons),
        ("operatingsystems", spec.operatingsystems),
        ("networkfilters", ("vdsm-no-mac-spoofing",)),
        ("vmpools", spec.vmpools),
        ("affinitylabels", spec.affinitylabels),
        ("katelloerrata", spec.katelloerrata),
        ("externalhostproviders", ("foreman-lab",)),
        ("openstacknetworkproviders", ("ovn-provider",)),
        ("openstackimageproviders", ("glance-lab",)),
        ("openstackvolumeproviders", ("cinder-lab",)),
        ("imagetransfers", ("transfer-1",)),
    ]
    for collection, names in surface:
        for name in names:
            await conn.execute(
                """INSERT INTO ov_api_objects(id, collection, name, status, data)
                   VALUES($1,$2,$3,'ok',$4::jsonb)""",
                stable_id("obj", collection, name),
                collection,
                name,
                json.dumps({"name": name, "description": f"demo {collection}"}),
            )

    from app.ovirt.settings import seed_engine_options

    await seed_engine_options(conn)

    from app.ovirt.seed_nested import seed_nested_for_inventory

    dc_ids = [stable_id("dc", key) for key, *_ in dc_specs]
    template_ids = [blank_id, *[stable_id("template", n) for n in spec.templates]]
    tag_ids = [stable_id("tag", t) for t in spec.tags]
    await seed_nested_for_inventory(
        conn,
        admin_user_id=users["admin"],
        role_user_id=role_user,
        datacenter_ids=dc_ids,
        cluster_ids=[c[0] for c in clusters],
        host_ids=list(hosts),
        network_ids=list(networks),
        storage_domain_ids=list(storage_domains),
        template_ids=template_ids,
        vm_ids=[stable_id("vm", f"vm-{i:04d}") for i in range(1, spec.vms + 1)],
        disk_ids=[stable_id("disk", f"vm-{i:04d}") for i in range(1, spec.vms + 1)],
        tag_ids=tag_ids,
        user_ids=list(users.values()),
        group_ids=[
            stable_id("group", n)
            for n in ("engine-admins", *spec.groups)
        ],
    )

    await conn.execute(
        "INSERT INTO ov_demo_meta(key, value) VALUES('profile', $1)", spec.name
    )
    return {
        "profile": spec.name,
        "vms": spec.vms,
        "hosts": len(hosts),
        "datacenters": len(dc_specs),
        "clusters": len(clusters),
        "storage_domains": len(storage_domains),
        "networks": len(networks),
    }


__all__ = [
    "CLUSTER_SIZES",
    "DEMO_PROFILE",
    "DEMO_PROFILES",
    "DEMO_VM_COUNT",
    "clear_ovirt_state",
    "cluster_size_spec",
    "normalize_cluster_size",
    "seed_ovirt_demo",
]