from enum import Enum
from typing import List, Optional
from uuid import uuid4
from pydantic import UUID4
from pydantic_xml import BaseXmlModel, attr, element, wrapped

from enum import Enum

class YesNoEnum(str, Enum):
    YES = "yes"
    NO = "no"

class OnOffEnum(str, Enum):
    ON = "on"
    OFF = "off"

class UnitEnum(str, Enum):
    KiB = "KiB"
    MiB = "MiB"
    GiB = "GiB"
    TiB = "TiB"

class Metadata(BaseXmlModel, search_mode='ordered'):
    # wrapped("metadata", element(default=None, ns="deevirt", nsmap={'deevirt': 'https://deevirt.com/'}))
    pass

class OSType(BaseXmlModel, search_mode='ordered'):
    class archEnum(str, Enum):
        x86 = "x86"
        x86_64 = "x86_64"

    arch:archEnum = attr(default=archEnum.x86_64)
    machine:Optional[str] = attr(default="q35")

class OSFirmwareFeature(BaseXmlModel, search_mode='ordered'):
    class nameEnum(str, Enum):
        enrolled_keys = "enrolled-keys"
        secure_boot = "secure-boot"

    enabled:YesNoEnum = attr(default=YesNoEnum.NO)
    name:nameEnum = attr()

class OSFirmware(BaseXmlModel, search_mode='ordered'):
    feature:Optional[List[OSFirmwareFeature]] = element(default=None)

class OSLoader(BaseXmlModel, search_mode='ordered'):
    class typeEnum(str, Enum):
        nvram = "nvram"
        pflash = "pflash"

    readonly:YesNoEnum = attr(default=YesNoEnum.YES)
    secure:YesNoEnum = attr(default=YesNoEnum.YES)
    type:typeEnum = attr(default=typeEnum.pflash)
    path:Optional[str] = ""

class OSBoot(BaseXmlModel, search_mode='ordered'):
    class bootEnum(str, Enum):
        hd = "hd",
        network = "network",
        cdrom = "cdrom"

    dev:bootEnum = attr()

class OSBootMenu(BaseXmlModel, search_mode='ordered'):
    enable:YesNoEnum = attr(default=YesNoEnum.NO)
    timeout:int = attr(default=0)

class OSSmbios(BaseXmlModel, search_mode='ordered'):
    class modeEnum(str, Enum):
        sysinfo = "sysinfo"

    mode:modeEnum = attr(default=modeEnum.sysinfo)

class OS(BaseXmlModel, search_mode='ordered'):
    class firmwareEnum(str, Enum):
        bios = "bios"
        efi = "efi"

    firmware:Optional[firmwareEnum] = attr(default=firmwareEnum.bios)
    type:OSType = element(default=OSType())
    firmware_options:Optional[OSFirmware] = element(tag="firmware", default=None)
    loader:Optional[OSLoader] = element(default=None)
    nvram:Optional[str] = element(default=None)
    boot:Optional[List[OSBoot]] = element(default=None)
    bootmenu:Optional[OSBootMenu] = element(default=None)
    smbios:OSSmbios = element(default=OSSmbios())

class SysinfoEntry(BaseXmlModel, search_mode='ordered'):
    name:str = attr()
    value:str

class SysinfoBIOS(BaseXmlModel, search_mode='ordered'):
    entry:SysinfoEntry = element(default=None)

class SysinfoSystem(BaseXmlModel, search_mode='ordered'):
    entry:List[SysinfoEntry] = element(default=[
            SysinfoEntry(
                name="manufacturer",
                value="Celeonet"
            ),
            SysinfoEntry(
                name="product",
                value="Celeonet Compute"
            ),
            SysinfoEntry(
                name="version",
                value="1.0"
            ),
            SysinfoEntry(
                name="family",
                value="Virtual Machine"
            )
        ])
    
class SysinfoBaseBoard(BaseXmlModel, search_mode='ordered'):
    entry:List[SysinfoEntry] = element(default=None)

class SysinfoChassis(BaseXmlModel, search_mode='ordered'):
    entry:List[SysinfoEntry] = element(default=None)

class SysinfoOEMStrings(BaseXmlModel, search_mode='ordered'):
    entry:List[SysinfoEntry] = element(default=None)

class Sysinfo(BaseXmlModel, search_mode='ordered'):
    bios:Optional[SysinfoBIOS] = element(default=None)
    system:Optional[SysinfoSystem] = element(default=SysinfoSystem())
    baseBoard:Optional[SysinfoBaseBoard] = element(default=None)
    chassis:Optional[SysinfoChassis] = element(default=None)
    oemStrings:Optional[SysinfoOEMStrings] = element(default=None)

class VCPU(BaseXmlModel, search_mode='ordered'):
    class placementEnum(str, Enum):
        static = "static"
        auto = "auto"

    placement:placementEnum = attr(default=placementEnum.auto)
    cpuset:str = attr(default=None)
    current:int = attr()
    max:int = None

class VCPUS(BaseXmlModel, search_mode='ordered'):
    id:int = attr()
    enabled:YesNoEnum = attr(default=YesNoEnum.YES)
    hotpluggable:YesNoEnum = attr(default=YesNoEnum.YES)
    order:int = attr()

class CPUTune(BaseXmlModel, search_mode='ordered'):
    """Not implemented"""
    pass

class MaxMemory(BaseXmlModel, search_mode='ordered'):
    slots:int = attr()
    unit:UnitEnum = attr(default=UnitEnum.MiB)
    value:int

class Memory(BaseXmlModel, search_mode='ordered'):
    unit:UnitEnum = attr(default=UnitEnum.MiB)
    value:int

class CurrentMemory(BaseXmlModel, search_mode='ordered'):
    unit:UnitEnum = attr(default=UnitEnum.MiB)
    value:int

class MemoryBacking(BaseXmlModel, search_mode='ordered'):
    """Not implemented"""
    pass

class MemTune(BaseXmlModel, search_mode='ordered'):
    """Not implemented"""
    pass

class NumaTuneMemory(BaseXmlModel, search_mode='ordered'):
    class modeEnum(str, Enum):
        interleave = "interleave"
        strict = "strict"
        preferred = "preferred"
        restrictive = "restrictive"

    mode:modeEnum = attr()
    modeset:str = attr()

class NumaMemnode(BaseXmlModel, search_mode='ordered'):
    cellid:int = attr()
    mode:NumaTuneMemory.modeEnum = attr()
    nodeset:str = attr()

class NumaTune(BaseXmlModel, search_mode='ordered'):
    memory:NumaTuneMemory = element()
    memnode:NumaMemnode = element()

class ResourcePartition(BaseXmlModel, search_mode='ordered'):
    value:str

class Resource(BaseXmlModel, search_mode='ordered'):
    partition:ResourcePartition = element()

class CPUModel(BaseXmlModel, search_mode='ordered'):
    class fallbackEnum(str, Enum):
        force = "force"
        require = "require"
        optional = "optional"
        disable = "disable"
        forbird = "forbid"

    fallback:fallbackEnum = attr()
    value:str

class CPUTopology(BaseXmlModel, search_mode='ordered'):
    sockets:int = attr()
    dies:Optional[int] = attr(default=None)
    clusters:Optional[int] = attr(default=None)
    cores:int = attr()
    threads:int = attr()

class CPUCache(BaseXmlModel, search_mode='ordered'):
    class modeEnum(str, Enum):
        emulate = "emulate"
        passthrough = "passthrough"
        disable = "disable"

    level:int = attr()
    mode:modeEnum = attr()

class CPUMaxphysaddr(BaseXmlModel, search_mode='ordered'):
    class modeEnum(str, Enum):
        emulate = "emulate"
        passthrough = "passthrough"

    mode:modeEnum = attr()
    bits:int = attr()

class CPUFeature(BaseXmlModel, search_mode='ordered'):
    class policyEnum(str, Enum):
        force = "force"
        require = "require"
        optional = "optional"
        disable = "disable"
        forbid = "forbid"

    policy:policyEnum = attr()
    name:str = attr()

class CPUDistancesSibling(BaseXmlModel, search_mode='ordered'):
    id:int = attr()
    value:int = attr()

class CPUDistances(BaseXmlModel, search_mode='ordered'):
    sibling:Optional[List[CPUDistancesSibling]] = element(default=None)

class CPUNumaCell(BaseXmlModel, search_mode='ordered'):
    class memaccessEnum(str, Enum):
        shared = "shared"
        private = "private"

    id:Optional[int] = attr()
    cpus:Optional[str] = attr()
    memory:Optional[int] = attr()
    unit:Optional[UnitEnum] = attr(default=UnitEnum.KiB)
    discard:Optional[YesNoEnum] = attr(default=None)
    memaccess:Optional[memaccessEnum] = attr(default=None)
    distances:Optional[CPUDistances] = element()

class CPUNuma(BaseXmlModel, search_mode='ordered'):
    cell:Optional[List[CPUNumaCell]] = element(default=[])
        
class CPU(BaseXmlModel, search_mode='ordered'):
    class matchEnum(str, Enum):
        minimum = "minimum"
        exact = "exact"
        strict = "strict"

    class modeEnum(str, Enum):
        custom = "custom"
        host_model = "host-model"

    class checkEnum(str, Enum):
        none = "none"
        partial = "partial"
        full = "full"

    match:Optional[matchEnum] = attr(default=None)
    mode:modeEnum = attr(default=modeEnum.host_model)
    check:Optional[checkEnum] = attr(default=None)
    model:Optional[CPUModel] = element(default=None)
    vendor:Optional[str] = element(default=None)
    topology:Optional[CPUTopology] = element(default=None)
    cache:Optional[CPUCache] = element(default=None)
    maxphysaddr:Optional[CPUMaxphysaddr] = element(default=None)
    feature:Optional[CPUFeature] = element(default=None)
    numa:Optional[CPUNuma] = element(default=None)

class PMSuspendToDisk(BaseXmlModel, search_mode='ordered'):
    enabled:YesNoEnum = attr(default=YesNoEnum.NO)

class PMSuspendToMem(BaseXmlModel, search_mode='ordered'):
    enabled:YesNoEnum = attr(default=YesNoEnum.NO)

class PM(BaseXmlModel, search_mode='ordered'):
    suspend_to_disk:PMSuspendToDisk = element(tag="suspend-to-disk", default=PMSuspendToDisk())
    suspend_to_mem:PMSuspendToMem = element(tag="suspend-to-mem", default=PMSuspendToMem())

class FeaturesKVMHidden(BaseXmlModel, search_mode='ordered'):
    state:OnOffEnum = attr()

class FeaturesKVMHintDedicated(BaseXmlModel, search_mode='ordered'):
    state:OnOffEnum = attr()    

class FeaturesKVMPollControl(BaseXmlModel, search_mode='ordered'):
    state:OnOffEnum = attr()    

class FeaturesKVMPvIpi(BaseXmlModel, search_mode='ordered'):
    state:OnOffEnum = attr()    

class FeaturesKVMDirtyRing(BaseXmlModel, search_mode='ordered'):
    state:OnOffEnum = attr()    
    size:int = attr()

class FeaturesKVM(BaseXmlModel, search_mode='ordered'):
    hidden:Optional[FeaturesKVMHidden] = element(default=None)
    hint_dedicated:Optional[FeaturesKVMHintDedicated] = element(tag="hint-dedicated", default=None)
    poll_control:Optional[FeaturesKVMPollControl] = element(tag="poll-control", default=None)
    pv_ipi:Optional[FeaturesKVMPvIpi] = element(tag="pv-ipi", default=None)
    dirty_ring:Optional[FeaturesKVMDirtyRing] = element(tag="dirty-ring", default=None)

class Features(BaseXmlModel, search_mode='ordered'):
    pae:str = element(default=None)
    acpi:str = element(default="")
    apic:str = element(default="")
    hap:str = element(default=None)
    privnet:str = element(default=None)
    kvm:FeaturesKVM = element(default=None)

class ClockTimerCatchup(BaseXmlModel, search_mode='ordered'):
    threshold:int = attr()
    slew:int = attr()
    limit:int = attr()

class ClockTimer(BaseXmlModel, search_mode='ordered'):
    class nameEnum(str, Enum):
        kvmclock = "kvmclock"

    class tickpolicyEnum(str, Enum):
        delay = "delay"
        catchup  = "catchup"
        merge = "merge"
        discard = "discard"

    class trackEnum(str, Enum):
        boot = "boot"
        guest = "guest"
        wall = "wall"

    name:nameEnum = attr(default=nameEnum.kvmclock)
    tickpolicy:Optional[tickpolicyEnum] = attr(default=None)
    track:Optional[trackEnum] = attr(default=None)
    catchup:Optional[ClockTimerCatchup] = element(default=None)

class Clock(BaseXmlModel, search_mode='ordered'):
    class offsetEnum(str, Enum):
        utc = "utc"
        localtime = "localtime"
        timezone = "timezone"
        variable = "variable"
        absolute = "absolute"
    
    offset:Optional[offsetEnum] = attr(default=offsetEnum.utc)
    timer:Optional[ClockTimer] = element(default=None)

class Perf(BaseXmlModel, search_mode='ordered'):
    """Not implemented"""
    pass

class DevicesDiskDriver(BaseXmlModel, search_mode='ordered'):
    class nameEnum(str, Enum):
        qemu = "qemu"

    class typeEnum(str, Enum):
        raw = "raw"

    class discardEnum(str, Enum):
        ignore = "ignore"
        unmap = "unmap"

    name:nameEnum = attr(default=nameEnum.qemu)
    type:typeEnum = attr(default=typeEnum.raw)
    discard:discardEnum = attr(default=discardEnum.unmap)

class DevicesDiskAuthSecret(BaseXmlModel, search_mode='ordered'):
    class typeEnum(str, Enum):
        ceph = "ceph"

    type:typeEnum = attr(default=typeEnum.ceph)
    uuid:UUID4 = attr(default=None)

class DevicesDiskAuth(BaseXmlModel, search_mode='ordered'):
    username:str = attr()
    secret:DevicesDiskAuthSecret = element(default=DevicesDiskAuthSecret())

class DevicesDiskSourceHost(BaseXmlModel, search_mode='ordered'):
    name:str = attr()
    port:int = attr()

class DevicesDiskSource(BaseXmlModel, search_mode='ordered'):
    class protocolEnum(str, Enum):
        rbd = "rbd"
        http = "http"
        https = "https"
        ftp = "ftp"
        ftps = "ftps"

    protocol:protocolEnum = attr(default=protocolEnum.rbd)
    name:str = attr()
    host:List[DevicesDiskSourceHost] = element(default=None)

class DevicesDiskTarget(BaseXmlModel, search_mode='ordered'):
    class busEnum(str, Enum):
        virtio = "virtio"
        scsi = "scsi"
        ide = "ide"

    dev:str = attr()
    bus:busEnum = attr(default=busEnum.virtio)

class DevicesDisk(BaseXmlModel, search_mode='ordered'):
    """
        Disk: CEPH Storage only
        CDROM: Network Only
    """

    class typeEnum(str, Enum):
        network = "network"

    class deviceEnum(str, Enum):
        disk = "disk"
        cdrom = "cdrom"

    type:typeEnum = attr(default=typeEnum.network)
    device:deviceEnum = attr(default=deviceEnum.disk)
    driver:DevicesDiskDriver = element(default=DevicesDiskDriver())
    auth:DevicesDiskAuth = element(default=None)
    source:DevicesDiskSource = element(default=None)
    target:DevicesDiskTarget = element(default=None)
    serial:UUID4 = element(default_factory=uuid4)

class DevicesInterfaceMAC(BaseXmlModel, search_mode='ordered'):
    address:Optional[str] = attr(default=None)

class DevicesInterfaceSource(BaseXmlModel, search_mode='ordered'):
    bridge:str = attr(default="br-int")

class DevicesInterfaceVirtualPortParameters(BaseXmlModel, search_mode='ordered'):
    interfaceid:UUID4 = attr(default=None)

class DevicesInterfaceVirtualport(BaseXmlModel, search_mode='ordered'):
    class typeEnum(str, Enum):
        openvswitch = "openvswitch"

    type:typeEnum = attr(default=typeEnum.openvswitch)
    parameters:DevicesInterfaceVirtualPortParameters = element(default=DevicesInterfaceVirtualPortParameters())

class DevicesInterfaceModel(BaseXmlModel, search_mode='ordered'):
    class typeEnum(str, Enum):
        virtio = "virtio"

    type:typeEnum = attr(default=typeEnum.virtio)

class DevicesInterfaceMTU(BaseXmlModel, search_mode='ordered'):
    mtu:int = attr(default=1500)

class DevicesInterface(BaseXmlModel, search_mode='ordered'):
    """Openvswitch Only"""

    class typeEnum(str, Enum):
        bridge = "bridge"

    type:typeEnum = attr(default=typeEnum.bridge)
    mac:DevicesInterfaceMAC = element(default=DevicesInterfaceMAC())
    source:DevicesInterfaceSource = element(default=DevicesInterfaceSource())
    virtualport:DevicesInterfaceVirtualport = element(default=DevicesInterfaceVirtualport())
    model:DevicesInterfaceModel = element(default=DevicesInterfaceModel())
    mtu:DevicesInterfaceMTU = element(default=DevicesInterfaceMTU())

class DevicesChannelSource(BaseXmlModel, search_mode='ordered'):
    class modeEnum(str, Enum):
        bind = "bind"

    mode:modeEnum = attr(default=modeEnum.bind)
    path:str = attr(default=None)

class DevicesChannelTarget(BaseXmlModel, search_mode='ordered'):
    class typeEnum(str, Enum):
        virtio = "virtio"

    type:typeEnum = attr(default=typeEnum.virtio)
    name:str = attr(default="org.qemu.guest_agent.0")

class DevicesChannel(BaseXmlModel):
    class typeEnum(str, Enum):
        unix = "unix"

    type:typeEnum = attr(default=typeEnum.unix)
    source:DevicesChannelSource = element(default=DevicesChannelSource())
    target:DevicesChannelTarget = element(default=DevicesChannelTarget())

class Graphics(BaseXmlModel, search_mode='ordered'):
    class typeEnum(str, Enum):
        vnc = "vnc"

    class keymapEnum(str, Enum):
        ar = "ar"
        bepo = "bepo"
        cz = "cz"
        da = "da"
        de = "de"
        de_ch = "de-ch"
        en_gb = "en-gb"
        en_us = "en-us"
        es = "es"
        et = "et"
        fi = "fi"
        fo = "fo"
        fr = "fr"
        fr_be = "fr-be"
        fr_ca = "fr-ca"
        fr_ch = "fr-ch"
        hr = "hr"
        hu = "hu"
        it = "it"
        lv = "lv"
        mk = "mk"
        nl = "nl"
        no = "no"
        pl = "pl"
        pt = "pt"
        pt_br = "pt-br"
        ru = "ru"
        sl = "sl"
        sv = "sv"
        th = "th"
        tr = "tr"

    type:typeEnum = attr(default=typeEnum.vnc)
    port:int = attr(default=-1)
    autoport:YesNoEnum = attr(default=YesNoEnum.YES)
    websocket:int = attr(default=-1)
    listen:str = attr(default="0.0.0.0")
    password:Optional[str] = attr(default=None)
    keymap:keymapEnum = attr(default=keymapEnum.en_us)
    powerControl:YesNoEnum = attr(default=YesNoEnum.YES)

class Audio(BaseXmlModel, search_mode='ordered'):
    pass

class VideoModel(BaseXmlModel, search_mode='ordered'):
    class typeEnum(str, Enum):
        vga = "vga"
        cirrus = "cirrus"
        virtio = "virtio"

    type:typeEnum = attr()
    vram:int = attr(default=16384)
    primary:YesNoEnum = attr(default=YesNoEnum.YES)

class Video(BaseXmlModel, search_mode='ordered'):
    model:VideoModel = element()    

class Watchdog(BaseXmlModel, search_mode='ordered'):
    class modelEnum(str, Enum):
        itco = "itco"

    class actionEnum(str, Enum):
        reset = "reset"
        shutdown = "shutdown"
        poweroff = "poweroff"
        pause = "pause"
        none = "none"
        dump = "dump"
        inject_nmi = "inject-nmi"


    model:modelEnum = attr(default=modelEnum.itco)
    action:actionEnum = attr(default=actionEnum.reset)

class TPMBackendEncryption(BaseXmlModel):
    secret:UUID4 = attr()

class TPMBackend(BaseXmlModel, search_mode='ordered'):
    class typeEnum(str, Enum):
        emulator = "emulator"

    class versionEnum(str, Enum):
        v12 = "1.2"
        v20 = "2.0"

    type:typeEnum = attr(default=typeEnum.emulator)
    version:versionEnum = attr(default=versionEnum.v20)
    encryption:Optional[TPMBackendEncryption] = element(default=None)

class TPM(BaseXmlModel, search_mode='ordered'):
    class modelEnum(str, Enum):
        tpm_tis = "tpm-tis"
        tpm_crb = "tpm-crb"

    model:modelEnum = attr(default=modelEnum.tpm_tis)
    backend:TPMBackend = element(default=TPMBackend())

class Devices(BaseXmlModel, search_mode='ordered'):
    emulator:str = element(default="/usr/libexec/qemu-kvm")
    disk:Optional[List[DevicesDisk]] = element(default=[])
    interface:Optional[List[DevicesInterface]] = element(default=[])
    channel:Optional[DevicesChannel] = element(default=None)
    graphics:Optional[Graphics] = element(default=None)
    audio:Optional[Audio] = element(default=None)
    video:Optional[Video] = element(default=None)
    watchdog:Optional[Watchdog] = element(default=None)
    tpm:Optional[TPM] = element(default=None)

class Dom(BaseXmlModel, tag='domain', search_mode='ordered'):
    class on_poweroffEnum(str, Enum):
        destroy = "destroy"
        restart = "restart"
        preserve = "preverse"

    class on_rebootEnum(str, Enum):
        restart = "restart"
        preserve = "preverse"

    class on_crashEnum(str, Enum):
        destroy = "destroy"
        restart = "restart"
        preserve = "preverse"

    class on_failurelockEnum(str, Enum):
        poweroff = "poweroff"
        restart = "restart"
        pause = "pause"
        ignore = "ignore"

    # General metadata
    uuid:Optional[UUID4] = element(default=None)
    genid:Optional[UUID4] = element(default=None)
    title:Optional[str] = element(default=None)
    description:Optional[str] = element(default=None)
    metadata:Optional[Metadata] = element(default=None)

    # Memory Allocation
    maxMemory:Optional[MaxMemory] = element(default=None)
    memory:Memory = element()
    currentMemory:Optional[CurrentMemory] = element(default=None)
    memoryBacking:Optional[MemoryBacking] = element(default=None)
    memtune:Optional[MemTune] = element(default=None)
    numatune:Optional[NumaTune] = element(default=None)

    # CPU Allocation
    vcpu:VCPU = element()
    vcpus:Optional[List[VCPUS]] = element(default=None)
    cputune:Optional[CPUTune] = element(default=None)

    # Resource patitioning
    resource:Optional[Resource] = element(default=None)

    # BIOS BootLoader
    os:OS = element(default=OS())

    # SMBIOS System Information
    sysinfo:Sysinfo = element(default=Sysinfo())

    # CPU model and topology
    cpu:CPU = element(default=CPU())

    # Power Management
    pm:PM = element(default=None)

    # Hypervisor features
    features:Features = element(default=Features())

    # Time keeping
    clock:Optional[Clock] = element(default=None)

    # Events configuration
    on_poweroff:on_poweroffEnum = element(default=on_poweroffEnum.destroy)
    on_reboot:on_rebootEnum = element(default=on_rebootEnum.restart)
    on_crash:on_crashEnum = element(default=on_crashEnum.restart)
    on_failurelock:on_failurelockEnum = element(default=on_failurelockEnum.ignore)

    # Performance monitoring events
    perf:Perf = element(default=None)

    # Devices
    devices:Devices = element(default=Devices())