use crate::color::{BasicColor, Color};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum DomainGroup {
    Core,
    Platform,
    Execution,
    Drivers,
    Filesystem,
    Network,
    Shell,
}

impl DomainGroup {
    pub const fn label_color(self) -> Color {
        match self {
            Self::Core => Color::hex(0x6E8FA8),
            Self::Platform => Color::hex(0x5BA8A0),
            Self::Execution => Color::hex(0x8A7EB8),
            Self::Drivers => Color::hex(0x4ABFCF),
            Self::Filesystem => Color::hex(0x7BAE7F),
            Self::Network => Color::hex(0xC4A24E),
            Self::Shell => Color::hex(0xA0AAB4),
        }
    }

    pub const fn label_color_basic(self) -> BasicColor {
        match self {
            Self::Core => BasicColor::Blue,
            Self::Platform => BasicColor::Cyan,
            Self::Execution => BasicColor::Magenta,
            Self::Drivers => BasicColor::BrightCyan,
            Self::Filesystem => BasicColor::Green,
            Self::Network => BasicColor::Yellow,
            Self::Shell => BasicColor::White,
        }
    }
}

const DOMAIN_TABLE: &[(&str, DomainGroup)] = &[
    ("mem", DomainGroup::Core),
    ("gdt", DomainGroup::Core),
    ("idt", DomainGroup::Core),
    ("phys", DomainGroup::Core),
    ("virt", DomainGroup::Core),
    ("kern", DomainGroup::Core),
    ("boot", DomainGroup::Core),
    ("sys", DomainGroup::Core),
    ("apic", DomainGroup::Platform),
    ("pci", DomainGroup::Platform),
    ("acpi", DomainGroup::Platform),
    ("ioapic", DomainGroup::Platform),
    ("cpu", DomainGroup::Platform),
    ("iommu", DomainGroup::Platform),
    ("sched", DomainGroup::Execution),
    ("proc", DomainGroup::Execution),
    ("cap", DomainGroup::Execution),
    ("wcet", DomainGroup::Execution),
    ("ipc", DomainGroup::Execution),
    ("loader", DomainGroup::Execution),
    ("nvme", DomainGroup::Drivers),
    ("serial", DomainGroup::Drivers),
    ("fbcon", DomainGroup::Drivers),
    ("ps2", DomainGroup::Drivers),
    ("virtio", DomainGroup::Drivers),
    ("fb", DomainGroup::Drivers),
    ("vfs", DomainGroup::Filesystem),
    ("ramfs", DomainGroup::Filesystem),
    ("lancerfs", DomainGroup::Filesystem),
    ("net", DomainGroup::Network),
    ("arp", DomainGroup::Network),
    ("dns", DomainGroup::Network),
    ("udp", DomainGroup::Network),
    ("init", DomainGroup::Shell),
    ("rsh", DomainGroup::Shell),
    ("fstest", DomainGroup::Shell),
    ("test", DomainGroup::Shell),
];

pub fn classify(domain: &str) -> DomainGroup {
    let bytes = domain.as_bytes();
    DOMAIN_TABLE
        .iter()
        .fold(DomainGroup::Shell, |result, &(name, group)| {
            match name.as_bytes() == bytes {
                true => group,
                false => result,
            }
        })
}