use {
    derive_more::{Deref, DerefMut, Display},
    error_stack::{bail, ensure, report, Context, IntoReport, Result, ResultExt},
    fatfs::{FileSystem, FormatVolumeOptions, FsOptions, ReadWriteSeek},
    std::{
        fmt::Display,
        fs::File,
        io::{self, Write},
        path::Path,
        process::Command,
    },
};

fn main() -> Result<(), Error> {
    env_logger::init();
    let mut args = std::env::args();
    args.next();

    // let disk_meta = fs::metadata("target/disk.img").unwrap();
    // let config_meta = fs::metadata("system.toml").unwrap();

    // if disk_meta.modified().unwrap() < config_meta.modified().unwrap() {
    //     // TODO: work on adding in system.toml support
    //     // TODO: rebuild the disk
    // }

    match args.next().as_deref() {
        Some("build" | "b") => {
            let mut release = false;
            let mut target = Target::X86_64;
            for arg in args {
                if arg == "-r" || arg == "--release" {
                    release = true;
                }
                if arg == "rv64" || arg == "riscv64" || arg == "riscv64-virt" {
                    target = Target::Riscv64Virt;
                }
                if arg == "aarch" || arg == "arm64" {
                    target = Target::Aarch64;
                }
            }

            build(release, target).change_context(Error::Build)
        }
        Some("run" | "r") => {
            let mut release = false;
            let mut target = Target::X86_64;
            for arg in args {
                if arg == "-r" || arg == "--release" {
                    release = true;
                }
                if arg == "rv64" || arg == "riscv64" || arg == "riscv64-virt" {
                    target = Target::Riscv64Virt;
                }
                if arg == "arm64" || arg == "aarch64" {
                    target = Target::Aarch64;
                }
            }

            build(release, target)?;
            run(release, target)
        }
        Some("help" | "h") => {
            println!(concat!(
                "AbleOS RepBuild\n",
                "Subcommands:\n",
                "  build (b): Build a bootable disk image\n",
                "   help (h): Print this message\n",
                "    run (r): Build and run AbleOS in QEMU\n\n",
                "Options for build and run:\n",
                "        -r: build in release mode",
                "  [target]: sets target"
            ),);
            Ok(())
        }
        _ => Err(report!(Error::InvalidSubCom)),
    }
}

fn get_fs() -> Result<FileSystem<impl ReadWriteSeek>, io::Error> {
    let path = Path::new("target/disk.img");

    match std::fs::metadata(path) {
        Err(e) if e.kind() == io::ErrorKind::NotFound => (),
        Err(e) => bail!(e),
        Ok(_) => {
            return FileSystem::new(
                File::options().read(true).write(true).open(path)?,
                FsOptions::new(),
            )
            .into_report()
        }
    }

    let mut img = File::options()
        .read(true)
        .write(true)
        .create(true)
        .open(path)?;

    img.set_len(1024 * 1024 * 64)?;

    fatfs::format_volume(&mut img, FormatVolumeOptions::new())?;

    let fs = FileSystem::new(img, FsOptions::new())?;
    let bootdir = fs.root_dir().create_dir("efi")?.create_dir("boot")?;

    io::copy(
        &mut File::open("limine/BOOTX64.EFI")
            .into_report()
            .attach_printable("copying Limine bootloader (have you pulled the submodule?)")?,
        &mut bootdir.create_file("bootx64.efi")?,
    )?;

    io::copy(
        &mut File::open("repbuild/limine.cfg")?,
        &mut fs.root_dir().create_file("limine.cfg")?,
    )?;

    io::copy(
        &mut File::open("repbuild/background.bmp")?,
        &mut fs.root_dir().create_file("background.bmp")?,
    )?;
    io::copy(
        &mut File::open("repbuild/inf_loop.hb")?,
        &mut fs.root_dir().create_file("inf_loop.hb")?,
    )?;

    drop(bootdir);
    Ok(fs)
}

fn build(release: bool, target: Target) -> Result<(), Error> {
    fetch_ovmf().change_context(Error::OvmfFetch)?;

    let fs = get_fs().change_context(Error::Io)?;
    let mut com = Command::new("cargo");
    com.current_dir("kernel");
    com.args(["b"]);
    if release {
        com.arg("-r");
    }

    if target == Target::Riscv64Virt {
        com.args(["--target", "targets/riscv64-virt-ableos.json"]);
    }
    if target == Target::Aarch64 {
        com.args(["--target", "targets/aarch64-virt-ableos.json"]);
    }

    match com.status() {
        Ok(s) if s.code() != Some(0) => bail!(Error::Build),
        Err(e) => bail!(report!(e).change_context(Error::Build)),
        _ => (),
    }

    if target != Target::X86_64 {
        return Ok(());
    }

    (|| -> std::io::Result<_> {
        io::copy(
            &mut File::open(
                Path::new("target/x86_64-ableos")
                    .join(if release { "release" } else { "debug" })
                    .join("kernel"),
            )?,
            &mut fs.root_dir().create_file("kernel")?,
        )
        .map(|_| ())
    })()
    .into_report()
    .change_context(Error::Io)
}

fn run(release: bool, target: Target) -> Result<(), Error> {
    let mut com = match target {
        Target::X86_64 => Command::new("qemu-system-x86_64"),
        Target::Riscv64Virt => Command::new("qemu-system-riscv64"),
        Target::Aarch64 => Command::new("qemu-system-aarch64"),
    };

    if target == Target::X86_64 {
        #[rustfmt::skip]
        com.args([
            "-bios", "target/OVMF_CODE.fd",
            "-drive", "file=target/disk.img,format=raw",
            "-m", "4G",
            // "-serial", "stdio",
            "-smp", "cores=4",
            // "-vga", "cirrus",
            // "-device", "ati-vga",
            // "-device", "virtio-gpu-pci",

	        // "-device", "virtio-serial,id=virtio-serial0",
		    // "-chardev", "stdio,id=char0,mux=on",
            // "-device", "virtconsole,chardev=char0",
            // "-device", "virtio-mouse-pci",

            // "-device", "ati-vga", "model=rage128p"
        ]);

        #[cfg(target_os = "linux")]
        {

            //com.args(["-enable-kvm", "-cpu", "host"]);
        }
    }

    if target == Target::Riscv64Virt {
        #[rustfmt::skip]
        com.args([
            "-M", "virt",
            "-m", "128M",
            "-serial", "stdio",
            "-kernel",
            if release {
                "target/riscv64-virt-ableos/release/kernel"
            } else {
                "target/riscv64-virt-ableos/debug/kernel"
            }
        ]);
    }

    if target == Target::Aarch64 {
        com.args([
            "-M", "virt", "-m", //
            "128M", "-serial", "stdio",
        ]);
    }

    match com
        .status()
        .into_report()
        .change_context(Error::ProcessSpawn)?
    {
        s if s.success() => Ok(()),
        s => Err(report!(Error::Qemu(s.code()))),
    }
}

fn fetch_ovmf() -> Result<(), OvmfFetchError> {
    const OVMF_RPM_URL: &str = "https://kojipkgs.fedoraproject.org/packages/edk2/20230524/3.fc38/noarch/edk2-ovmf-20230524-3.fc38.noarch.rpm";

    let mut file = match std::fs::metadata("target/OVMF_CODE.fd") {
        Err(e) if e.kind() == std::io::ErrorKind::NotFound => std::fs::OpenOptions::new()
            .create(true)
            .write(true)
            .read(true)
            .open("target/OVMF_CODE.fd")
            .into_report()
            .change_context(OvmfFetchError::Io)?,
        Ok(_) => return Ok(()),
        Err(e) => return Err(report!(e).change_context(OvmfFetchError::Io)),
    };

    log::info!("No OVMF found, downloading…");
    let rpm = rpm::RPMPackage::parse(
        &mut std::convert::identity::<reqwest::Result<_>>((|| {
            reqwest::blocking::get(OVMF_RPM_URL)?.bytes()
        })())
        .into_report()
        .change_context(OvmfFetchError::Fetch)?
        .as_ref(),
    )
    .map_err(RpmError)
    .into_report()
    .change_context(OvmfFetchError::RpmParse)?;

    ensure!(
        rpm.metadata
            .get_payload_compressor()
            .map_err(RpmError)
            .into_report()
            .change_context(OvmfFetchError::RpmParse)?
            == rpm::CompressionType::Zstd,
        OvmfFetchError::UnsupportedCompression,
    );

    file.write_all(
        cpio_reader::iter_files(
            &zstd::decode_all(std::io::Cursor::new(rpm.content))
                .into_report()
                .change_context(OvmfFetchError::Zstd)?,
        )
        .find(|file| file.name() == "./usr/share/edk2/ovmf/OVMF_CODE.fd")
        .ok_or_else(|| report!(OvmfFetchError::NoFileFound))?
        .file(),
    )
    .into_report()
    .change_context(OvmfFetchError::Io)?;

    Ok(())
}

#[derive(Debug, Display, Deref, DerefMut)]
struct RpmError(rpm::RPMError);
impl Context for RpmError {}

// Ehhh?? I am pretty sure they just forgot :ferrisClueless:
unsafe impl Sync for RpmError {}
unsafe impl Send for RpmError {}

#[derive(Debug, Display)]
enum OvmfFetchError {
    #[display(fmt = "Failed to fetch OVMF package")]
    Fetch,
    #[display(fmt = "RPM parse error")]
    RpmParse,
    #[display(fmt = "Unsupported compression (ZSTD is the only supported one)")]
    UnsupportedCompression,
    #[display(fmt = "Decompression error")]
    Zstd,
    #[display(fmt = "Requested file not found in package")]
    NoFileFound,
    #[display(fmt = "IO Error")]
    Io,
}

impl Context for OvmfFetchError {}

#[derive(Clone, Copy, PartialEq, Eq)]
enum Target {
    X86_64,
    Riscv64Virt,
    Aarch64,
}

#[derive(Debug, Display)]
enum Error {
    #[display(fmt = "Failed to build the kernel")]
    Build,
    #[display(fmt = "Missing or invalid subcommand (available: build, run)")]
    InvalidSubCom,
    #[display(fmt = "IO Error")]
    Io,
    #[display(fmt = "Failed to spawn a process")]
    ProcessSpawn,
    #[display(fmt = "Failed to fetch UEFI firmware")]
    OvmfFetch,
    #[display(fmt = "QEMU Error: {}", "fmt_qemu_err(*_0)")]
    Qemu(Option<i32>),
}

impl Context for Error {}

fn fmt_qemu_err(e: Option<i32>) -> impl Display {
    struct W(Option<i32>);
    impl Display for W {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            if let Some(c) = self.0 {
                c.fmt(f)
            } else {
                f.write_str("Interrupted by signal")
            }
        }
    }

    W(e)
}