//! Live QEMU MMIO identity + bounded driver-match refusal in the guest.
//! Unsupported class is deliberately injected after reading real registers.

use super::*;
use turkos_kernel::runtime::device_registry::{DeviceClass, DeviceIdentity, DeviceKey, Driver,
    MatchError, MatchedRegistry, ResourceKind, ResourceRange, Transport};

pub fn run(boot: &BootData) -> Result<(), &'static str> {
    let blob = unsafe { core::slice::from_raw_parts(boot.dtb_address as *const u8, boot.dtb_size) };
    let nodes = dtb::discover_virtio_mmio(blob).map_err(|_| "k1415-dtb-devices")?;
    let mut block = None;
    let mut network = None;
    for node in nodes.as_slice() {
        if unsafe { os_k940_read(node.base, 0) } != turkos_kernel::virtio_mmio::MAGIC {
            return Err("k1415-magic");
        }
        let device_id = unsafe { os_k940_read(node.base, 8) };
        if device_id != 1 && device_id != 2 { continue; }
        let version = unsafe { os_k940_read(node.base, 4) };
        let vendor_id = unsafe { os_k940_read(node.base, 12) };
        if version != 2 || node.size != 0x200 { return Err("k1415-version-or-size"); }
        let identity = DeviceIdentity {
            transport: Transport::Mmio, vendor_id, device_id,
            class: if device_id == 2 { DeviceClass::Block } else { DeviceClass::Network },
        };
        if device_id == 2 && block.replace((node.base, identity)).is_some() {
            return Err("k1415-duplicate-block");
        }
        if device_id == 1 && network.replace((node.base, identity)).is_some() {
            return Err("k1415-duplicate-network");
        }
    }
    let (block, block_identity) = block.ok_or("k1415-no-block")?;
    let (network, network_identity) = network.ok_or("k1415-no-network")?;
    let block_key = DeviceKey { transport: Transport::Mmio, location: block };
    let network_key = DeviceKey { transport: Transport::Mmio, location: network };
    let block_ranges = [ResourceRange { kind: ResourceKind::Mmio, start: block, length: 0x200 }];
    let network_ranges = [ResourceRange { kind: ResourceKind::Mmio, start: network, length: 0x200 }];
    let mut registry = MatchedRegistry::<2, 2>::new();
    let block_handle = registry.attach(block_key, block_identity, &block_ranges)
        .map_err(|_| "k1415-block-bind")?;
    let before = registry.snapshot();
    let unsupported = DeviceIdentity {class: DeviceClass::Other(0xff), ..network_identity};
    if registry.attach(network_key, unsupported, &network_ranges)
        != Err(MatchError::UnsupportedClass) || registry.snapshot() != before {
        return Err("k1415-unsupported-not-atomic");
    }
    write_line("TURKOS/OS/K1415-UNSUPPORTED: CLASS=0xff RESULT=UNSUPPORTED_CLASS STATE=UNCHANGED");
    let mismatched = DeviceIdentity {class: DeviceClass::Block, ..network_identity};
    if registry.attach(network_key, mismatched, &network_ranges)
        != Err(MatchError::UnsupportedDevice) || registry.snapshot() != before {
        return Err("k1415-mismatch-not-atomic");
    }
    let network_handle = registry.attach(network_key, network_identity, &network_ranges)
        .map_err(|_| "k1415-network-bind")?;
    if registry.get(block_handle).map_err(|_| "k1415-block-lost")?.1.driver != Driver::VirtioBlock
        || registry.get(network_handle).map_err(|_| "k1415-network-lost")?.1.driver != Driver::VirtioNetwork
        || registry.binding_count() != 2 || registry.resource_count() != 2 {
        return Err("k1415-healthy-bindings");
    }
    write_str("TURKOS/OS/K1415-TRACE: BLOCK=0x"); write_hex(block as usize);
    write_str(" NETWORK=0x"); write_hex(network as usize);
    write_str(" BLOCK-VENDOR=0x"); write_hex(block_identity.vendor_id as usize);
    write_str(" NETWORK-VENDOR=0x"); write_hex(network_identity.vendor_id as usize);
    write_str(" BLOCK-ID=0x"); write_hex(block_identity.device_id as usize);
    write_str(" NETWORK-ID=0x"); write_hex(network_identity.device_id as usize);
    write_line(" BINDINGS=2 CLAIMS=2");
    registry.detach(block_handle).map_err(|_| "k1415-block-detach")?;
    registry.detach(network_handle).map_err(|_| "k1415-network-detach")?;
    if registry.binding_count() != 0 || registry.resource_count() != 0 {
        return Err("k1415-cleanup");
    }
    write_line("TURKOS/OS/K1415-TRACE: LOGICAL-CLEANUP BINDINGS=0 CLAIMS=0");
    Ok(())
}