use anyhow::{bail, Result};
use crossbeam::channel::Sender;
use serde_derive::Deserialize;
use std::path::Path;
use std::{
    error::Error,
    io::Read,
    process::{Command, Stdio},
};
#[derive(Deserialize, Debug)]
#[serde(rename_all = "lowercase")]
enum Type {
    Test,
    Suite,
}
#[derive(Deserialize, Debug)]
#[serde(rename_all = "lowercase")]
enum Event {
    Ok,
    #[serde(rename = "started")]
    Start,
    #[serde(rename = "failed")]
    Fail,
    #[serde(rename = "ignored")]
    Ignore,
}

#[derive(Deserialize, Debug)]
// todo: figure out if theres a cool serde trick
struct TestRaw {
    #[serde(rename = "type")]
    ty: Type,
    event: Event,
    name: Option<String>,
    passed: Option<usize>,
    failed: Option<usize>,
    ignored: Option<usize>,
    measured: Option<usize>,
    filtered_out: Option<usize>,
    test_count: Option<usize>,
    stdout: Option<String>,
    exec_time: Option<f32>,
}

#[derive(Debug, PartialEq)]
pub struct TestResult {
    pub name: String,
    pub exec_time: f32,
    pub stdout: Option<String>,
}

#[derive(Debug, PartialEq)]
pub enum TestEvent {
    SuiteStart {
        test_count: usize,
    },
    SuiteOk {
        failed: usize,
        passed: usize,
        ignored: usize,
        measured: usize,
        filtered_out: usize,
        exec_time: f32,
    },
    SuiteFail {
        passed: usize,
        failed: usize,
        ignored: usize,
        measured: usize,
        filtered_out: usize,
        exec_time: f32,
    },
    TestStart {
        name: String,
    },
    TestOk(TestResult),
    TestFail(TestResult),
    TestIgnore {
        name: String,
    },
}

#[derive(Debug)]
pub enum TestMessage {
    Event(TestEvent),
    Finished,
}

pub fn test(to: Sender<TestMessage>, at: Option<&Path>) -> Result<TestEvent> {
    let mut proc = Command::new("cargo");
    if let Some(at) = at {
        proc.arg("-C");
        proc.arg(at.as_os_str());
    }
    proc.args([
        "-Zunstable-options",
        "test",
        "--",
        "-Zunstable-options",
        "--report-time",
        "--show-output",
        "--format",
        "json",
    ]);
    log::trace!("running {proc:?}");
    let mut proc = proc.stdout(Stdio::piped()).stderr(Stdio::null()).spawn()?;
    let mut out = proc.stdout.take().unwrap();
    let mut tmp = Vec::with_capacity(32);
    let mut stdout = [0; 4096];
    loop {
        let n = out.read(&mut stdout)?;
        for &byte in &stdout[..n] {
            match byte {
                b'\n' => {
                    log::debug!("got first event, returning");
                    let event = parse_test(std::str::from_utf8(&tmp).unwrap()).unwrap();
                    tmp.clear();
                    log::debug!("spawning thread");
                    std::thread::spawn(move || loop {
                        let n = out.read(&mut stdout).unwrap();
                        for &byte in &stdout[..n] {
                            match byte {
                                b'\n' => {
                                    let event =
                                        parse_test(std::str::from_utf8(&tmp).unwrap()).unwrap();
                                    tmp.clear();
                                    to.send(TestMessage::Event(event)).unwrap();
                                }
                                b => tmp.push(b),
                            }
                        }
                        if let Ok(Some(_)) = proc.try_wait() {
                            to.send(TestMessage::Finished).unwrap();
                            log::debug!("proc exited, joining thread");
                            break;
                        }
                        std::thread::sleep(std::time::Duration::from_millis(50));
                    });
                    return Ok(event);
                }
                b => tmp.push(b),
            }
        }
        if let Some(exit) = proc.try_wait()? {
            log::trace!("process died, we die");
            bail!("process exited too early ({exit})");
        }
        std::thread::sleep(std::time::Duration::from_millis(10));
    }
}

#[derive(Debug)]
struct Should(&'static str);
impl std::fmt::Display for Should {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "should have had a {}, dang", self.0)
    }
}
impl Error for Should {}

fn parse_test(s: &str) -> Result<TestEvent> {
    let raw = serde_json::from_str::<TestRaw>(s)?;
    log::trace!("got raw event {raw:?}");
    macro_rules! take {
        ($thing:ident { $($holds:ident),+ $(?= $($opt:ident),+)?}) => {
            $thing {
                $($holds: raw.$holds.ok_or(Should(stringify!($holds)))?,)+
                $($($opt: raw.$opt),+)?
            }
        };
        ($thing:ident($inner:ident { $($holds:ident),+ $(?= $($opt:ident),+)? })) => {
            $thing(take!($inner { $($holds),+ $(?= $($opt),+)? }))
        }
    }
    use TestEvent::*;
    Ok(match raw.ty {
        Type::Test => match raw.event {
            Event::Start => take!(TestStart { name }),
            Event::Ok => take!(TestOk(TestResult {
                name,
                exec_time ?= stdout
            })),
            Event::Fail => take!(TestFail(TestResult {
                name,
                exec_time ?= stdout
            })),
            Event::Ignore => take!(TestIgnore { name }),
        },
        Type::Suite => match raw.event {
            Event::Start => take!(SuiteStart { test_count }),
            Event::Ok => take!(SuiteOk {
                failed,
                passed,
                ignored,
                measured,
                filtered_out,
                exec_time
            }),
            Event::Fail => {
                take!(SuiteFail {
                    failed,
                    passed,
                    ignored,
                    measured,
                    filtered_out,
                    exec_time
                })
            }
            Event::Ignore => panic!("ignore suite???"),
        },
    })
}

#[derive(Deserialize)]
pub struct Package {
    pub name: String,
}

#[derive(Deserialize)]
pub struct Metadata {
    pub package: Package,
}

pub fn meta(at: &Path) -> Result<Metadata> {
    Ok(toml::from_str(&std::fs::read_to_string(
        at.join("Cargo.toml"),
    )?)?)
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn test_output() {
        macro_rules! run {
            ($($input:literal parses to $output:expr),+) => {
                $(assert_eq!(parse_test($input).unwrap(), $output);)+
            };
        }
        run![
            r#"{ "type": "suite", "event": "started", "test_count": 2 }"# parses to TestEvent::SuiteStart { test_count: 2},
            r#"{ "type": "test", "event": "started", "name": "fail" }"# parses to TestEvent::TestStart { name: "fail".into() },
            r#"{ "type": "test", "name": "fail", "event": "ok", "exec_time": 0.000003428, "stdout": "hello world" }"# parses to TestEvent::TestOk(TestResult { name: "fail".into(), exec_time: 0.000003428, stdout: Some("hello world".into()) }),
            r#"{ "type": "test", "event": "started", "name": "nope" }"# parses to TestEvent::TestStart { name: "nope".into() },
            r#"{ "type": "test", "name": "nope", "event": "ignored" }"# parses to TestEvent::TestIgnore { name: "nope".into() },
            r#"{ "type": "suite", "event": "ok", "passed": 1, "failed": 0, "ignored": 1, "measured": 0, "filtered_out": 0, "exec_time": 0.000684028 }"# parses to TestEvent::SuiteOk { passed: 1, failed: 0, ignored: 1, measured: 0, filtered_out: 0, exec_time: 0.000684028 }
        ];
        r#"
        { "type": "suite", "event": "started", "test_count": 1 }
        { "type": "test", "event": "started", "name": "fail" }
        { "type": "test", "name": "fail", "event": "failed", "exec_time": 0.000081092, "stdout": "thread 'fail' panicked at src/main.rs:3:5:\nexplicit panic\nnote: run with `RUST_BACKTRACE=1` environment variable to display a backtrace\n" }
        { "type": "suite", "event": "failed", "passed": 0, "failed": 1, "ignored": 0, "measured": 0, "filtered_out": 0, "exec_time": 0.000731068 }
        "#;
    }
}