#![cfg_attr(
    test,
    allow(clippy::expect_used, clippy::indexing_slicing, clippy::unwrap_used)
)]

use std::collections::HashMap;
use std::fmt;
use std::num::NonZeroU32;
use std::time::Duration;

use serde::Deserialize;
use serde::de::IgnoredAny;

#[derive(Debug)]
pub struct NonEmptyString(String);

impl NonEmptyString {
    pub fn new(value: String) -> Option<Self> {
        (!value.is_empty()).then_some(NonEmptyString(value))
    }

    pub fn as_str(&self) -> &str {
        &self.0
    }
}

impl fmt::Display for NonEmptyString {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(&self.0)
    }
}

impl<'de> Deserialize<'de> for NonEmptyString {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = String::deserialize(deserializer)?;
        NonEmptyString::new(value).ok_or_else(|| serde::de::Error::custom("empty string"))
    }
}

#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "lowercase")]
pub enum Scheme {
    #[default]
    Light,
    Dark,
}

#[derive(Debug)]
pub struct Variant {
    pub name: NonEmptyString,
    pub width: NonZeroU32,
    pub height: NonZeroU32,
    pub scheme: Scheme,
}

/// Deserialized with mlua's strict defaults, so a stray function is an error.
#[derive(Debug)]
pub(crate) struct Spec {
    pub(crate) variants: Vec<Variant>,

    #[cfg_attr(
        not(test),
        expect(dead_code, reason = "read once the GitHub task lands")
    )]
    pub(crate) baseline: Option<BaselineSource>,

    pub(crate) name: Option<String>,
}

#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct SpecTable {
    variants: HashMap<String, VariantTable>,

    #[serde(default)]
    baseline: Option<BaselineSource>,

    #[serde(default)]
    name: Option<String>,

    // Already taken by the caller; declared so unknown-field errors list them.
    #[serde(default, rename = "server")]
    _server: Option<IgnoredAny>,

    #[serde(default, rename = "flow")]
    _flow: Option<IgnoredAny>,
}

#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct VariantTable {
    viewport: (NonZeroU32, NonZeroU32),

    #[serde(default)]
    scheme: Scheme,
}

impl<'de> Deserialize<'de> for Spec {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let SpecTable {
            variants,
            baseline,
            name,
            ..
        } = SpecTable::deserialize(deserializer)?;
        if variants.is_empty() {
            return Err(serde::de::Error::custom("variants must not be empty"));
        }
        let mut parsed = Vec::with_capacity(variants.len());
        for (key, variant) in &variants {
            let name = NonEmptyString::new(key.clone())
                .ok_or_else(|| serde::de::Error::custom("empty variant name"))?;
            parsed.push(Variant {
                name,
                width: variant.viewport.0,
                height: variant.viewport.1,
                scheme: variant.scheme,
            });
        }
        // Lua tables are unordered, so sorted names are the run order.
        parsed.sort_unstable_by(|a, b| a.name.as_str().cmp(b.name.as_str()));
        Ok(Spec {
            variants: parsed,
            baseline,
            name,
        })
    }
}

/// See the design doc's GitHub releases section.
#[derive(Debug, Deserialize)]
#[serde(deny_unknown_fields)]
#[expect(dead_code, reason = "read once the GitHub task lands")]
pub(crate) struct BaselineSource {
    pub(crate) repo: NonEmptyString,

    #[serde(default)]
    pub(crate) asset: Option<NonEmptyString>,
}

#[derive(Clone, Debug)]
pub struct ServerSpec {
    pub program: String,
    pub args: Vec<String>,

    pub timeout: Duration,
}

impl ServerSpec {
    pub fn command_line(&self) -> String {
        std::iter::once(&self.program)
            .chain(&self.args)
            .map(String::as_str)
            .collect::<Vec<_>>()
            .join(" ")
    }
}

impl<'de> Deserialize<'de> for ServerSpec {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct Table {
            cmd: Vec<String>,

            #[serde(default = "default_timeout")]
            timeout: f64,
        }
        let table = Table::deserialize(deserializer)?;
        let mut words = table.cmd.into_iter();
        let Some(program) = words.next() else {
            return Err(serde::de::Error::custom("cmd must not be empty"));
        };
        let Some(timeout) = Duration::try_from_secs_f64(table.timeout)
            .ok()
            .filter(|timeout| !timeout.is_zero())
        else {
            return Err(serde::de::Error::custom(
                "timeout must be a positive number of seconds",
            ));
        };
        Ok(ServerSpec {
            program,
            args: words.collect(),
            timeout,
        })
    }
}

fn default_timeout() -> f64 {
    30.0
}

#[cfg(test)]
mod tests {
    use super::*;
    use mlua::Lua;
    use mlua::LuaSerdeExt as _;
    use mlua::Value;

    fn with_value<T>(body: &str, check: impl FnOnce(&Lua, Value) -> T) -> T {
        let lua = unsafe { Lua::unsafe_new() };
        let value: Value = lua.load(body).eval().expect("lua source");
        check(&lua, value)
    }

    #[test]
    fn parses_a_setup_table() {
        with_value(
            r#"return {
                variants = {
                    mobile = {viewport = {375, 812}},
                    desktop = {viewport = {1280, 900}, scheme = "dark"},
                },
                baseline = {repo = "kejadlen/ketchup"},
            }"#,
            |lua, value| {
                let setup: Spec = lua.from_value(value).expect("setup table");
                assert_eq!(setup.variants.len(), 2);
                assert_eq!(setup.variants[0].name.as_str(), "desktop");
                assert_eq!(setup.variants[0].scheme, Scheme::Dark);
                assert_eq!(setup.variants[1].name.as_str(), "mobile");
                assert_eq!(setup.variants[1].scheme, Scheme::Light);
                assert_eq!(
                    setup.baseline.as_ref().expect("baseline").repo.as_str(),
                    "kejadlen/ketchup"
                );
                assert_eq!(setup.name, None);
            },
        );
    }

    #[test]
    fn rejects_setup_shapes() {
        let cases = [
            (r#"return {baseline = nil}"#, "missing field `variants`"),
            (r#"return {variants = {}, extra = 1}"#, "unknown field"),
            (r#"return {variants = {}}"#, "variants must not be empty"),
            (
                r#"return {variants = {desktop = {viewport = {1280, 900}}}, extra = 1}"#,
                "`server`, `flow`",
            ),
            (
                r#"return {variants = {desktop = {viewport = {1280, 900}, extra = 1}}}"#,
                "unknown field",
            ),
            (
                r#"return {variants = {[""] = {viewport = {1280, 900}}}}"#,
                "empty variant name",
            ),
            (
                r#"return {variants = {desktop = {viewport = {0, 900}}}}"#,
                "invalid value",
            ),
            (
                r#"return {variants = {desktop = {scheme = "dark"}}}"#,
                "missing field `viewport`",
            ),
            (
                r#"return {variants = {desktop = {viewport = {1280, 900}, scheme = "sepia"}}}"#,
                "unknown variant",
            ),
            (
                r#"return {variants = {desktop = {viewport = {1280, 900}}}, baseline = {asset = "x.tar.gz"}}"#,
                "missing field `repo`",
            ),
        ];
        for (body, fragment) in cases {
            with_value(body, |lua, value| {
                let error = lua
                    .from_value::<Spec>(value)
                    .expect_err("expected an invalid setup table");
                assert!(
                    error.to_string().contains(fragment),
                    "expected {error:?} to contain {fragment:?}"
                );
            });
        }
    }

    #[test]
    fn rejects_functions_in_setup() {
        with_value(
            r#"return {variants = {desktop = {viewport = {1280, 900}}}, name = (function() end)}"#,
            |lua, value| {
                let error = lua
                    .from_value::<Spec>(value)
                    .expect_err("functions cannot appear in setup");
                assert!(error.to_string().contains("unsupported"));
            },
        );
    }

    #[test]
    fn parses_a_server_table_with_defaults() {
        with_value(r#"return {cmd = {"true"}}"#, |lua, value| {
            let server: ServerSpec = lua.from_value(value).expect("server table");
            assert_eq!(server.program, "true");
            assert!(server.args.is_empty());
            assert_eq!(server.timeout, Duration::from_secs(30));
        });
    }

    #[test]
    fn parses_a_server_table_with_a_timeout() {
        with_value(
            r#"return {cmd = {"app", "serve"}, timeout = 5}"#,
            |lua, value| {
                let server: ServerSpec = lua.from_value(value).expect("server table");
                assert_eq!(server.program, "app");
                assert_eq!(server.args, vec!["serve".to_owned()]);
                assert_eq!(server.command_line(), "app serve");
                assert_eq!(server.timeout, Duration::from_secs(5));
            },
        );
    }

    #[test]
    fn rejects_bad_server_tables() {
        let cases = [
            (r#"return {timeout = 5}"#, "missing field `cmd`"),
            (r#"return {cmd = {}}"#, "cmd must not be empty"),
            (r#"return {cmd = {"true"}, extra = 1}"#, "unknown field"),
            (r#"return {cmd = "true"}"#, "invalid type"),
            (
                r#"return {cmd = {"true"}, timeout = 0}"#,
                "timeout must be a positive",
            ),
            (
                r#"return {cmd = {"true"}, timeout = -1}"#,
                "timeout must be a positive",
            ),
            (
                r#"return {cmd = {"true"}, timeout = 1e30}"#,
                "timeout must be a positive",
            ),
        ];
        for (body, fragment) in cases {
            with_value(body, |lua, value| {
                let error = lua
                    .from_value::<ServerSpec>(value)
                    .expect_err("expected an invalid server table");
                assert!(
                    error.to_string().contains(fragment),
                    "expected {error:?} to contain {fragment:?}"
                );
            });
        }
    }
}