use std::collections::BTreeMap;
use std::io::{self, Write};
use std::process;
use std::time::Duration;

use libredox::Fd;
use log::{LevelFilter, Metadata, Record, error, info, warn};
use redox_scheme::scheme::{SchemeState, SchemeSync};
use redox_scheme::{CallerCtx, OpenResult, RequestKind, SignalBehavior, Socket};
use syscall::dirent::{DirEntry, DirentBuf, DirentKind};
use syscall::error::{EACCES, EBADF, EINTR, EINVAL, ENOENT, ENOTDIR, Error, Result};
use syscall::flag::{O_ACCMODE, O_DIRECTORY, O_STAT};
use syscall::schemev2::NewFdFlags;
use syscall::{MODE_DIR, Stat};

const SCHEME_NAME: &str = "devfs";
const SCHEME_ROOT_ID: usize = 0;
const PROBE_RETRY: usize = 5;
const PROBE_DELAY: Duration = Duration::from_millis(150);

/// Number of lowercase letters available for the sd* Linux-style disk naming.
/// Linux itself extends beyond this (sdaa, sdab, ...) but the on-disk device
/// namespace we serve is a curated subset, so 26 is more than enough for the
/// expected number of disks on a typical Red Bear OS system.
const SD_LETTER_COUNT: u32 = 26;

struct StderrLogger;

impl log::Log for StderrLogger {
    fn enabled(&self, metadata: &Metadata<'_>) -> bool {
        metadata.level() <= LevelFilter::Info
    }

    fn log(&self, record: &Record) {
        if self.enabled(record.metadata()) {
            let _ = writeln!(
                io::stderr().lock(),
                "[{}] devfsd: {}",
                record.level(),
                record.args()
            );
        }
    }

    fn flush(&self) {}
}

static LOGGER: StderrLogger = StderrLogger;

/// How a devfs entry resolves into a kernel-level handle that the caller
/// receives in `OpenResult::OtherScheme`.
#[derive(Clone, Debug)]
enum EntryTarget {
    /// Open the given absolute path (e.g. `/scheme/rand`) and hand the fd to
    /// the caller. The fd is created fresh on every open.
    SchemePath(String),
    /// Duplicate the running daemon's own fd (0, 1, or 2) and hand the new fd
    /// to the caller. Used for `stdin`, `stdout`, `stderr`.
    DupFd(usize),
}

#[derive(Clone, Debug)]
struct DevEntry {
    name: String,
    target: EntryTarget,
    kind: DirentKind,
}

impl DevEntry {
    fn char(name: impl Into<String>, target: impl Into<String>) -> Self {
        Self {
            name: name.into(),
            target: EntryTarget::SchemePath(target.into()),
            kind: DirentKind::CharDev,
        }
    }

    fn block(name: impl Into<String>, target: impl Into<String>) -> Self {
        Self {
            name: name.into(),
            target: EntryTarget::SchemePath(target.into()),
            kind: DirentKind::BlockDev,
        }
    }

    fn dup(name: impl Into<String>, fd: usize) -> Self {
        Self {
            name: name.into(),
            target: EntryTarget::DupFd(fd),
            kind: DirentKind::CharDev,
        }
    }
}

enum Handle {
    SchemeRoot,
    List,
}

struct DevfsdScheme {
    entries: Vec<DevEntry>,
    handles: BTreeMap<usize, Handle>,
    next_id: usize,
}

impl DevfsdScheme {
    fn new(entries: Vec<DevEntry>) -> Self {
        let mut handles = BTreeMap::new();
        handles.insert(SCHEME_ROOT_ID, Handle::SchemeRoot);
        Self {
            entries,
            handles,
            next_id: 1,
        }
    }

    fn alloc_list(&mut self) -> usize {
        let id = self.next_id;
        self.next_id = self
            .next_id
            .checked_add(1)
            .expect("devfsd: handle id overflow");
        self.handles.insert(id, Handle::List);
        id
    }

    fn handle(&self, id: usize) -> Result<&Handle> {
        self.handles.get(&id).ok_or_else(|| Error::new(EBADF))
    }

    fn entry(&self, name: &str) -> Option<&DevEntry> {
        self.entries.iter().find(|e| e.name == name)
    }
}

/// Read the names of a single scheme's entries (one per line, the textual
/// encoding of getdents from the namespace manager / scheme daemon).
fn probe_scheme_listing(scheme_name: &str) -> Vec<String> {
    let path = format!("/scheme/{scheme_name}");
    let mut result = Vec::new();
    for _ in 0..PROBE_RETRY {
        match Fd::open(&path, O_DIRECTORY as i32, 0) {
            Ok(fd) => {
                let mut buffer = [0u8; 4096];
                match fd.read(&mut buffer) {
                    Ok(0) => return result,
                    Ok(n) => {
                        let text = String::from_utf8_lossy(&buffer[..n]);
                        for line in text.lines() {
                            let name = line.trim();
                            if !name.is_empty() && !result.iter().any(|n| n == name) {
                                result.push(name.to_string());
                            }
                        }
                        return result;
                    }
                    Err(err) => {
                        warn!("devfsd: read {path} failed: {err}");
                        return result;
                    }
                }
            }
            Err(err) if err.errno() == ENOENT => {
                std::thread::sleep(PROBE_DELAY);
                continue;
            }
            Err(err) => {
                warn!("devfsd: open {path} failed: {err}");
                return result;
            }
        }
    }
    result
}

/// Check whether a given scheme is registered with the namespace manager by
/// attempting to open `/scheme/<name>/` and observing ENOENT vs success.
fn scheme_exists(scheme_name: &str) -> bool {
    let path = format!("/scheme/{scheme_name}");
    for _ in 0..PROBE_RETRY {
        match Fd::open(&path, O_DIRECTORY as i32, 0) {
            Ok(_) => return true,
            Err(err) if err.errno() == ENOENT => {
                std::thread::sleep(PROBE_DELAY);
            }
            Err(_) => return false,
        }
    }
    false
}

/// Convert a zero-based disk index into a Linux-style `sd?` letter sequence.
///
/// `0` -> `sda`, `1` -> `sdb`, ..., `25` -> `sdz`. Indices beyond 25 are
/// rejected by the caller (the on-disk namespace is a curated subset and we
/// prefer to skip overflow over emitting non-Linux names).
fn sd_letter(disk_index: u32) -> Option<char> {
    if disk_index < SD_LETTER_COUNT {
        Some((b'a' + disk_index as u8) as char)
    } else {
        None
    }
}

/// Parse a `diskd` entry name of the form `0`, `0p1`, `0p12` into a
/// `(disk_index, Option<partition>)` tuple. Returns `None` for any input that
/// does not match the expected shape — diskd itself produces well-formed
/// names, but the listing is read as text and we must not panic on garbage.
fn parse_diskd_entry(line: &str) -> Option<(u32, Option<u32>)> {
    let trimmed = line.trim();
    if trimmed.is_empty() {
        return None;
    }
    if let Some(idx) = trimmed.find('p') {
        let (disk_part, part_part) = trimmed.split_at(idx);
        let part_str = &part_part[1..];
        let disk = disk_part.parse::<u32>().ok()?;
        let part = part_str.parse::<u32>().ok()?;
        Some((disk, Some(part)))
    } else {
        let disk = trimmed.parse::<u32>().ok()?;
        Some((disk, None))
    }
}

/// Build the dynamic block-device entries from a `diskd` listing. Each disk
/// in the listing gets a `sda`-style name; each partition gets `sda1`,
/// `sda2`, ... in the order returned by the daemon. The diskd layout is
/// already sorted on the producer side, so iterating in the order received
/// yields partitions in the same order.
fn build_disk_entries(diskd_listing: &[String]) -> Vec<DevEntry> {
    if diskd_listing.is_empty() {
        return Vec::new();
    }

    // Collect a sorted, unique set of disk indices present in the listing.
    let mut disks: Vec<u32> = diskd_listing
        .iter()
        .filter_map(|l| parse_diskd_entry(l).map(|(d, _)| d))
        .collect();
    disks.sort_unstable();
    disks.dedup();

    // Group partitions by disk index, preserving the listing order within
    // each group.
    let mut entries = Vec::new();
    for disk_index in &disks {
        let Some(letter) = sd_letter(*disk_index) else {
            warn!(
                "devfsd: skipping disk index {disk_index} (only {SD_LETTER_COUNT} sd* names \
                 are available)"
            );
            continue;
        };
        let sd_name = format!("sd{letter}");
        let mut partitions: Vec<u32> = diskd_listing
            .iter()
            .filter_map(|l| {
                let (d, p) = parse_diskd_entry(l)?;
                if d == *disk_index { p } else { None }
            })
            .collect();
        partitions.sort_unstable();
        partitions.dedup();

        // The whole-disk entry first, then each partition.
        entries.push(DevEntry::block(
            sd_name.clone(),
            format!("/scheme/diskd/{disk_index}"),
        ));
        for part in partitions {
            entries.push(DevEntry::block(
                format!("{sd_name}{part}"),
                format!("/scheme/diskd/{disk_index}p{part}"),
            ));
        }
    }
    entries
}

/// Build the dynamic `net/<iface>` entries from a `netd` listing. Each entry
/// name (e.g. `0`, `1`, `eth0`) becomes a `net/<same-name>` entry pointing at
/// `/scheme/netd/<name>`. netd's listing is already sorted on the producer
/// side, so the relative order is preserved.
fn build_net_entries(netd_listing: &[String]) -> Vec<DevEntry> {
    let mut entries = Vec::new();
    for name in netd_listing {
        let trimmed = name.trim();
        if trimmed.is_empty() {
            continue;
        }
        entries.push(DevEntry::char(
            format!("net/{trimmed}"),
            format!("/scheme/netd/{trimmed}"),
        ));
    }
    entries
}

/// Build the full set of devfs entries: always-present static entries
/// (null/zero/random/urandom/tty/console + stdin/stdout/stderr via fd dup)
/// plus dynamic block and network entries discovered from diskd/netd.
fn build_entries() -> Vec<DevEntry> {
    let mut entries: Vec<DevEntry> = vec![
        DevEntry::char("null", "/scheme/null"),
        DevEntry::char("zero", "/scheme/zero"),
        DevEntry::char("random", "/scheme/rand"),
        DevEntry::char("urandom", "/scheme/rand"),
        DevEntry::char("tty", "/scheme/tty"),
        DevEntry::char("console", "/scheme/tty"),
        DevEntry::dup("stdin", 0),
        DevEntry::dup("stdout", 1),
        DevEntry::dup("stderr", 2),
    ];

    if scheme_exists("diskd") {
        let listing = probe_scheme_listing("diskd");
        let disk_entries = build_disk_entries(&listing);
        info!(
            "devfsd: diskd listing returned {} entries -> {} block device devfs entries",
            listing.len(),
            disk_entries.len()
        );
        entries.extend(disk_entries);
    } else {
        info!("devfsd: diskd not registered; skipping block device entries");
    }

    if scheme_exists("netd") {
        let listing = probe_scheme_listing("netd");
        let net_entries = build_net_entries(&listing);
        info!(
            "devfsd: netd listing returned {} entries -> {} net devfs entries",
            listing.len(),
            net_entries.len()
        );
        entries.extend(net_entries);
    } else {
        info!("devfsd: netd not registered; skipping net/* entries");
    }

    entries
}

impl SchemeSync for DevfsdScheme {
    fn scheme_root(&mut self) -> Result<usize> {
        Ok(SCHEME_ROOT_ID)
    }

    fn openat(
        &mut self,
        dirfd: usize,
        path: &str,
        flags: usize,
        _fcntl_flags: u32,
        ctx: &CallerCtx,
    ) -> Result<OpenResult> {
        if !matches!(self.handle(dirfd)?, Handle::SchemeRoot) {
            return Err(Error::new(EACCES));
        }

        let trimmed = path.trim_matches('/');

        if trimmed.is_empty() {
            if flags & (O_DIRECTORY | O_STAT) == 0 {
                return Err(Error::new(EINVAL));
            }
            if ctx.uid != 0 {
                return Err(Error::new(EACCES));
            }
            let id = self.alloc_list();
            return Ok(OpenResult::ThisScheme {
                number: id,
                flags: NewFdFlags::empty(),
            });
        }

        if ctx.uid != 0 {
            return Err(Error::new(EACCES));
        }

        let entry = self.entry(trimmed).ok_or(Error::new(ENOENT))?;
        match &entry.target {
            EntryTarget::SchemePath(path) => {
                let underlying = path.clone();
                let fd = Fd::open(path, (flags & O_ACCMODE) as i32, 0).inspect_err(|err| {
                    warn!("devfsd: failed to open {underlying} for caller: {err}");
                })?;
                Ok(OpenResult::OtherScheme { fd: fd.into_raw() })
            }
            EntryTarget::DupFd(raw_fd) => {
                // Duplicate the daemon's own fd. The `buf` argument to dup is
                // the FD_SPACE — the events channel that the resulting fd's
                // notifications should be delivered on. We don't currently
                // have a destination channel, so pass an empty FD_SPACE; the
                // kernel will deliver events to the caller's own FD_SPACE via
                // the inherited /scheme/devfs/* fd table.
                let raw = Fd::new(*raw_fd).dup(&[]).inspect_err(|err| {
                    warn!(
                        "devfsd: failed to dup fd {raw_fd} for {}: {err}",
                        entry.name
                    );
                })?;
                Ok(OpenResult::OtherScheme { fd: raw })
            }
        }
    }

    fn getdents<'buf>(
        &mut self,
        id: usize,
        mut buf: DirentBuf<&'buf mut [u8]>,
        opaque_offset: u64,
    ) -> Result<DirentBuf<&'buf mut [u8]>> {
        if !matches!(self.handle(id)?, Handle::List) {
            return Err(Error::new(ENOTDIR));
        }
        let offset = usize::try_from(opaque_offset).unwrap_or(usize::MAX);
        for (i, entry) in self.entries.iter().enumerate().skip(offset) {
            if let Err(err) = buf.entry(DirEntry {
                inode: 0,
                next_opaque_id: (i as u64) + 1,
                name: &entry.name,
                kind: entry.kind,
            }) {
                if err.errno == EINVAL {
                    break;
                }
                return Err(err);
            }
        }
        Ok(buf)
    }

    fn fstat(&mut self, id: usize, stat: &mut Stat, _ctx: &CallerCtx) -> Result<()> {
        match self.handle(id)? {
            Handle::SchemeRoot => {
                stat.st_mode = MODE_DIR;
                stat.st_size = 0;
                Ok(())
            }
            Handle::List => {
                stat.st_mode = MODE_DIR;
                stat.st_size = 0;
                Ok(())
            }
        }
    }

    fn fpath(&mut self, id: usize, buf: &mut [u8], _ctx: &CallerCtx) -> Result<usize> {
        let mut writer = FpathBuf::new(buf);
        write!(&mut writer, "{SCHEME_NAME}:").map_err(|_| Error::new(EINVAL))?;
        match self.handle(id)? {
            Handle::SchemeRoot => {}
            Handle::List => {
                write!(&mut writer, "/").map_err(|_| Error::new(EINVAL))?;
            }
        }
        Ok(writer.written())
    }

    fn read(
        &mut self,
        _id: usize,
        _buf: &mut [u8],
        _offset: u64,
        _fcntl_flags: u32,
        _ctx: &CallerCtx,
    ) -> Result<usize> {
        Err(Error::new(EBADF))
    }

    fn write(
        &mut self,
        _id: usize,
        _buf: &[u8],
        _offset: u64,
        _fcntl_flags: u32,
        _ctx: &CallerCtx,
    ) -> Result<usize> {
        Err(Error::new(EBADF))
    }

    fn fsize(&mut self, id: usize, _ctx: &CallerCtx) -> Result<u64> {
        match self.handle(id)? {
            Handle::SchemeRoot | Handle::List => Ok(0),
        }
    }

    fn on_close(&mut self, id: usize) {
        if id == SCHEME_ROOT_ID {
            return;
        }
        self.handles.remove(&id);
    }
}

struct FpathBuf<'a> {
    buf: &'a mut [u8],
    written: usize,
}

impl<'a> FpathBuf<'a> {
    fn new(buf: &'a mut [u8]) -> Self {
        Self { buf, written: 0 }
    }

    fn written(&self) -> usize {
        self.written
    }
}

impl Write for FpathBuf<'_> {
    fn write(&mut self, src: &[u8]) -> io::Result<usize> {
        if self.written >= self.buf.len() {
            return Ok(0);
        }
        let avail = self.buf.len() - self.written;
        let count = src.len().min(avail);
        self.buf[self.written..self.written + count].copy_from_slice(&src[..count]);
        self.written += count;
        Ok(count)
    }

    fn flush(&mut self) -> io::Result<()> {
        Ok(())
    }
}

#[cfg(target_os = "redox")]
fn enter_null_namespace() {
    if let Err(err) = libredox::call::setrens(0, 0) {
        error!("devfsd: setrens(0, 0) failed: {err}");
    }
}

#[cfg(not(target_os = "redox"))]
fn enter_null_namespace() {}

#[cfg(target_os = "redox")]
fn run_daemon() -> io::Result<()> {
    enter_null_namespace();

    let entries = build_entries();
    info!("devfsd: serving {} devfs entries", entries.len());
    for e in &entries {
        match &e.target {
            EntryTarget::SchemePath(p) => info!("devfsd:   {} ({:?}) -> {}", e.name, e.kind, p),
            EntryTarget::DupFd(fd) => info!("devfsd:   {} ({:?}) -> dup({})", e.name, e.kind, fd),
        }
    }

    let socket = Socket::create().map_err(|err| {
        io::Error::other(format!("devfsd: failed to create scheme socket: {err}"))
    })?;
    let mut state = SchemeState::new();
    let mut scheme = DevfsdScheme::new(entries);

    info!("devfsd: scheme {SCHEME_NAME} ready");

    loop {
        let request = match socket.next_request(SignalBehavior::Restart) {
            Ok(Some(req)) => req,
            Ok(None) => {
                info!("devfsd: scheme socket closed; exiting");
                return Ok(());
            }
            Err(err) if err.errno == EINTR => continue,
            Err(err) => {
                error!("devfsd: next_request failed: {err}");
                return Err(io::Error::other(format!("devfsd: {err}")));
            }
        };

        if let RequestKind::Call(call_request) = request.kind() {
            let response = call_request.handle_sync(&mut scheme, &mut state);
            if let Err(err) = socket.write_response(response, SignalBehavior::Restart) {
                error!("devfsd: write_response failed: {err}");
                return Err(io::Error::other(format!("devfsd: {err}")));
            }
        }
    }
}

#[cfg(not(target_os = "redox"))]
fn run_daemon() -> io::Result<()> {
    info!("devfsd: host build: scheme serving disabled outside Redox");
    Ok(())
}

fn main() {
    let _ = log::set_logger(&LOGGER);
    log::set_max_level(LevelFilter::Info);

    match run_daemon() {
        Ok(()) => process::exit(0),
        Err(err) => {
            error!("devfsd: fatal: {err}");
            process::exit(1);
        }
    }
}