use super::*;

pub(super) fn validate_component(
    component: &Map<String, Value>,
    catalog_id: &str,
) -> Result<(), String> {
    let id = required_string(component, "id")?;
    let kind = required_string(component, "component")?;
    let allowed = if catalog_id == CATALOG_ID {
        ds4_catalog()
            .pointer("/components")
            .and_then(Value::as_object)
            .is_some_and(|components| components.contains_key(kind))
    } else {
        BASIC_COMPONENTS.contains(&kind)
    };
    if !allowed {
        return Err(format!(
            "component `{id}` uses `{kind}`, which is not in catalog `{catalog_id}`"
        ));
    }
    let required: &[&str] = match kind {
        "Text" => &["text"],
        "Image" => &["url"],
        "Icon" => &["name"],
        "Video" | "AudioPlayer" => &["url"],
        "Row" | "Column" | "List" => &["children"],
        "Card" => &["child"],
        "Modal" => &["trigger", "content"],
        "Tabs" => &["tabs"],
        "Button" => &["child", "action"],
        "TextField" => &["label"],
        "CheckBox" => &["label", "value"],
        "Slider" => &["value", "max"],
        "DateTimeInput" => &["value"],
        "ChoicePicker" => &["options", "value"],
        "Chart" => &["chartType", "series"],
        "Table" => &["columns", "rows"],
        "Metric" => &["label", "value"],
        "Timeline" => &["events"],
        "Map" => &["locations"],
        "MindMap" => &["nodes"],
        "Form" => &["children"],
        _ => &[],
    };
    if let Some(field) = required
        .iter()
        .find(|field| !component.contains_key(**field))
    {
        return Err(format!("component `{id}` ({kind}) requires `{field}`"));
    }
    let common = ["id", "component", "accessibility", "weight", "checks"];
    let specific: &[&str] = match kind {
        "Text" => &["text", "variant"],
        "Image" => &["url", "description", "fit", "variant"],
        "Icon" => &["name"],
        "Video" => &["url", "posterUrl"],
        "AudioPlayer" => &["url", "description"],
        "Divider" => &["axis"],
        "Row" | "Column" => &["children", "justify", "align"],
        "List" => &["children", "direction", "align"],
        "Card" => &["child"],
        "Modal" => &["trigger", "content"],
        "Tabs" => &["tabs"],
        "Button" => &["child", "variant", "action"],
        "TextField" => &["label", "value", "placeholder", "variant"],
        "CheckBox" => &["label", "value"],
        "Slider" => &["label", "min", "max", "value", "steps"],
        "DateTimeInput" => &["label", "value", "enableDate", "enableTime", "min", "max"],
        "ChoicePicker" => &[
            "label",
            "variant",
            "options",
            "value",
            "displayStyle",
            "filterable",
        ],
        "Chart" => &["title", "chartType", "series"],
        "Table" => &["title", "columns", "rows"],
        "Metric" => &["label", "value", "detail", "trend"],
        "Timeline" => &["title", "events"],
        "Map" => &["title", "locations"],
        "MindMap" => &["title", "nodes"],
        "Form" => &["title", "children", "submitLabel", "action"],
        _ => &[],
    };
    if let Some(field) = component
        .keys()
        .find(|field| !common.contains(&field.as_str()) && !specific.contains(&field.as_str()))
    {
        return Err(format!(
            "component `{id}` ({kind}) contains unknown property `{field}`"
        ));
    }
    if let Some(accessibility) = component.get("accessibility") {
        let accessibility = object(Some(accessibility), "accessibility")?;
        for field in ["label", "description"] {
            validate_optional_dynamic(accessibility, field, Value::is_string, id)?;
        }
    }
    if component
        .get("weight")
        .is_some_and(|value| !value.is_number())
    {
        return Err(format!("component `{id}` weight must be a number"));
    }
    if component
        .get("title")
        .is_some_and(|value| !value.is_string())
    {
        return Err(format!("component `{id}` title must be a string"));
    }
    if catalog_id != CATALOG_ID
        && component.contains_key("checks")
        && !matches!(
            kind,
            "Button" | "TextField" | "CheckBox" | "ChoicePicker" | "Slider" | "DateTimeInput"
        )
    {
        return Err(format!("component `{id}` ({kind}) does not support checks"));
    }
    match kind {
        "Row" | "Column" | "List" | "Form" => {
            validate_children(component.get("children").unwrap(), id)?
        }
        "Card" | "Button" => expect_string(component, "child", id)?,
        "Modal" => {
            expect_string(component, "trigger", id)?;
            expect_string(component, "content", id)?;
        }
        "Tabs" => validate_tabs(component.get("tabs").unwrap(), id)?,
        "ChoicePicker" => validate_options(component.get("options").unwrap(), id)?,
        "Slider" => {
            expect_number(component, "max", id)?;
            if let Some(min) = component.get("min")
                && !min.is_number()
            {
                return Err(format!("component `{id}` min must be a number"));
            }
            if let Some(steps) = component.get("steps")
                && !steps.as_u64().is_some_and(|steps| steps > 0)
            {
                return Err(format!("component `{id}` steps must be a positive integer"));
            }
        }
        _ => {}
    }
    match kind {
        "Text" => validate_dynamic_field(component, "text", Value::is_string, id)?,
        "Image" | "Video" | "AudioPlayer" => {
            validate_dynamic_field(component, "url", Value::is_string, id)?;
            validate_optional_dynamic(component, "description", Value::is_string, id)?;
            validate_optional_dynamic(component, "posterUrl", Value::is_string, id)?;
        }
        "Icon" => validate_dynamic_field(component, "name", Value::is_string, id)?,
        "TextField" | "DateTimeInput" => {
            validate_optional_dynamic(component, "label", Value::is_string, id)?;
            validate_optional_dynamic(component, "value", Value::is_string, id)?;
        }
        "CheckBox" => {
            validate_dynamic_field(component, "label", Value::is_string, id)?;
            validate_dynamic_field(component, "value", Value::is_boolean, id)?;
        }
        "Slider" => validate_dynamic_field(component, "value", Value::is_number, id)?,
        "ChoicePicker" => {
            validate_optional_dynamic(component, "label", Value::is_string, id)?;
            validate_dynamic_field(
                component,
                "value",
                |value| {
                    value
                        .as_array()
                        .is_some_and(|values| values.iter().all(Value::is_string))
                },
                id,
            )?;
        }
        "Chart" | "Table" | "Timeline" | "Map" | "MindMap" => {
            for field in required {
                if *field != "chartType" {
                    validate_dynamic_field(component, field, Value::is_array, id)?;
                }
            }
        }
        _ => {}
    }
    match kind {
        "Text" => validate_enum(component, "variant", &["caption", "body"], id)?,
        "Image" => {
            validate_enum(
                component,
                "fit",
                &["contain", "cover", "fill", "none", "scaleDown"],
                id,
            )?;
            validate_enum(
                component,
                "variant",
                &[
                    "icon",
                    "avatar",
                    "smallFeature",
                    "mediumFeature",
                    "largeFeature",
                    "header",
                ],
                id,
            )?;
        }
        "Icon" if component.get("name").is_some_and(Value::is_string) => validate_enum(
            component,
            "name",
            &[
                "accountCircle",
                "add",
                "arrowBack",
                "arrowForward",
                "attachFile",
                "calendarToday",
                "call",
                "camera",
                "check",
                "close",
                "delete",
                "download",
                "edit",
                "event",
                "error",
                "fastForward",
                "favorite",
                "favoriteOff",
                "folder",
                "help",
                "home",
                "info",
                "locationOn",
                "lock",
                "lockOpen",
                "mail",
                "menu",
                "moreVert",
                "moreHoriz",
                "notificationsOff",
                "notifications",
                "pause",
                "payment",
                "person",
                "phone",
                "photo",
                "play",
                "print",
                "refresh",
                "rewind",
                "search",
                "send",
                "settings",
                "share",
                "shoppingCart",
                "skipNext",
                "skipPrevious",
                "star",
                "starHalf",
                "starOff",
                "stop",
                "upload",
                "visibility",
                "visibilityOff",
                "volumeDown",
                "volumeMute",
                "volumeOff",
                "volumeUp",
                "warning",
            ],
            id,
        )?,
        "Divider" => validate_enum(component, "axis", &["horizontal", "vertical"], id)?,
        "Row" | "Column" => {
            validate_enum(
                component,
                "justify",
                &[
                    "start",
                    "center",
                    "end",
                    "spaceBetween",
                    "spaceAround",
                    "spaceEvenly",
                    "stretch",
                ],
                id,
            )?;
            validate_enum(
                component,
                "align",
                &["start", "center", "end", "stretch"],
                id,
            )?;
        }
        "List" => {
            validate_enum(component, "direction", &["vertical", "horizontal"], id)?;
            validate_enum(
                component,
                "align",
                &["start", "center", "end", "stretch"],
                id,
            )?;
        }
        "Button" => validate_enum(
            component,
            "variant",
            &["default", "primary", "borderless"],
            id,
        )?,
        "TextField" => validate_enum(
            component,
            "variant",
            &["longText", "number", "shortText", "obscured"],
            id,
        )?,
        "ChoicePicker" => {
            validate_enum(
                component,
                "variant",
                &["multipleSelection", "mutuallyExclusive"],
                id,
            )?;
            validate_enum(component, "displayStyle", &["checkbox", "chips"], id)?;
            optional_bool(component, "filterable")?;
        }
        "DateTimeInput" => {
            optional_bool(component, "enableDate")?;
            optional_bool(component, "enableTime")?;
            validate_optional_dynamic(component, "min", Value::is_string, id)?;
            validate_optional_dynamic(component, "max", Value::is_string, id)?;
        }
        "Chart" => validate_enum(
            component,
            "chartType",
            &[
                "bar",
                "line",
                "area",
                "stackedBar",
                "pie",
                "donut",
                "heatmap",
            ],
            id,
        )?,
        _ => {}
    }
    if let Some(action) = component.get("action") {
        validate_action(action, id)?;
    }
    if let Some(checks) = component.get("checks") {
        let checks = checks
            .as_array()
            .ok_or_else(|| format!("component `{id}` checks must be an array"))?;
        for check in checks {
            let check = object(Some(check), "check")?;
            reject_unknown(check, &["condition", "message"], "check")?;
            let condition = check
                .get("condition")
                .ok_or_else(|| format!("component `{id}` check requires condition"))?;
            required_string(check, "message")?;
            validate_function(condition)?;
        }
    }
    validate_dynamic_values(component)?;
    Ok(())
}

fn validate_dynamic_field(
    object: &Map<String, Value>,
    field: &str,
    literal: impl Fn(&Value) -> bool,
    id: &str,
) -> Result<(), String> {
    let value = object
        .get(field)
        .ok_or_else(|| format!("component `{id}` requires `{field}`"))?;
    if literal(value) {
        return Ok(());
    }
    let dynamic = value
        .as_object()
        .ok_or_else(|| format!("component `{id}` {field} has the wrong literal or dynamic type"))?;
    if let Some(path) = dynamic.get("path") {
        if dynamic.len() == 1 && path.is_string() {
            return Ok(());
        }
        return Err(format!(
            "component `{id}` {field} has an invalid data binding"
        ));
    }
    validate_function(value).map_err(|error| format!("component `{id}` {field}: {error}"))
}

fn validate_optional_dynamic(
    object: &Map<String, Value>,
    field: &str,
    literal: impl Fn(&Value) -> bool,
    id: &str,
) -> Result<(), String> {
    if object.contains_key(field) {
        validate_dynamic_field(object, field, literal, id)
    } else {
        Ok(())
    }
}

pub(super) fn ds4_catalog() -> &'static Value {
    static CATALOG: OnceLock<Value> = OnceLock::new();
    CATALOG.get_or_init(|| {
        serde_json::from_str(CATALOG_JSON).expect("embedded DS4Server A2UI catalog must be valid")
    })
}

fn expect_string(object: &Map<String, Value>, field: &str, id: &str) -> Result<(), String> {
    if !object.get(field).is_some_and(Value::is_string) {
        return Err(format!("component `{id}` {field} must be a string"));
    }
    Ok(())
}

fn expect_number(object: &Map<String, Value>, field: &str, id: &str) -> Result<(), String> {
    if !object.get(field).is_some_and(Value::is_number) {
        return Err(format!("component `{id}` {field} must be a number"));
    }
    Ok(())
}

fn validate_enum(
    object: &Map<String, Value>,
    field: &str,
    allowed: &[&str],
    id: &str,
) -> Result<(), String> {
    if let Some(value) = object.get(field) {
        let value = value
            .as_str()
            .ok_or_else(|| format!("component `{id}` {field} must be a string"))?;
        if !allowed.contains(&value) {
            return Err(format!(
                "component `{id}` has invalid {field} `{value}`; expected one of: {}",
                allowed.join(", ")
            ));
        }
    }
    Ok(())
}

fn validate_children(value: &Value, id: &str) -> Result<(), String> {
    if value
        .as_array()
        .is_some_and(|children| children.iter().all(Value::is_string))
    {
        return Ok(());
    }
    let template = object(Some(value), "children")?;
    reject_unknown(template, &["componentId", "path"], "children template")?;
    required_string(template, "componentId")?;
    required_string(template, "path")?;
    if !required_string(template, "path")?.starts_with('/') {
        return Err(format!(
            "component `{id}` child template path must be a JSON Pointer"
        ));
    }
    Ok(())
}

fn validate_tabs(value: &Value, id: &str) -> Result<(), String> {
    let tabs = value
        .as_array()
        .filter(|tabs| !tabs.is_empty())
        .ok_or_else(|| format!("component `{id}` tabs must be a non-empty array"))?;
    for tab in tabs {
        let tab = object(Some(tab), "tab")?;
        reject_unknown(tab, &["title", "child"], "tab")?;
        validate_dynamic_field(tab, "title", Value::is_string, id)?;
        required_string(tab, "child")?;
    }
    Ok(())
}

fn validate_options(value: &Value, id: &str) -> Result<(), String> {
    let options = value
        .as_array()
        .ok_or_else(|| format!("component `{id}` options must be an array"))?;
    for option in options {
        let option = object(Some(option), "choice option")?;
        reject_unknown(option, &["label", "value"], "choice option")?;
        validate_dynamic_field(option, "label", Value::is_string, id)?;
        required_string(option, "value")?;
    }
    Ok(())
}

fn validate_action(value: &Value, id: &str) -> Result<(), String> {
    let action = object(Some(value), "action")?;
    if let Some(event) = action.get("event") {
        reject_unknown(action, &["event"], "action")?;
        let event = object(Some(event), "action.event")?;
        reject_unknown(
            event,
            &["name", "context", "wantResponse", "responsePath"],
            "action.event",
        )?;
        required_string(event, "name")?;
        if let Some(context) = event.get("context")
            && !context.is_object()
        {
            return Err(format!("component `{id}` action context must be an object"));
        }
        optional_bool(event, "wantResponse")?;
        if let Some(path) = event.get("responsePath")
            && !path.as_str().is_some_and(|path| path.starts_with('/'))
        {
            return Err(format!(
                "component `{id}` responsePath must be a JSON Pointer"
            ));
        }
        return Ok(());
    }
    reject_unknown(action, &["functionCall"], "action")?;
    validate_function(
        action
            .get("functionCall")
            .ok_or_else(|| format!("component `{id}` action requires event or functionCall"))?,
    )
}

fn validate_dynamic_values(value: &Map<String, Value>) -> Result<(), String> {
    for value in value.values() {
        if value.get("call").is_some() {
            validate_function(value)?;
        }
        match value {
            Value::Object(object) => validate_dynamic_values(object)?,
            Value::Array(values) => {
                for value in values {
                    if let Value::Object(object) = value {
                        validate_dynamic_values(object)?;
                    }
                }
            }
            _ => {}
        }
    }
    Ok(())
}

pub(super) fn validate_function(value: &Value) -> Result<(), String> {
    let function = object(Some(value), "function call")?;
    reject_unknown(function, &["call", "args"], "function call")?;
    let call = value
        .get("call")
        .and_then(Value::as_str)
        .ok_or_else(|| "function call requires `call`".to_owned())?;
    if !FUNCTIONS.contains(&call) {
        return Err(format!("function `{call}` is not declared by the catalog"));
    }
    if value.get("args").is_some_and(|args| !args.is_object()) {
        return Err(format!("function `{call}` requires object `args`"));
    }
    let args = value
        .get("args")
        .and_then(Value::as_object)
        .cloned()
        .unwrap_or_default();
    let allowed: &[&str] = match call {
        "required" | "email" | "formatString" | "not" => &["value"],
        "regex" => &["value", "pattern"],
        "length" | "numeric" => &["value", "min", "max"],
        "formatNumber" => &["value", "decimals", "grouping"],
        "formatCurrency" => &["value", "currency", "decimals", "grouping"],
        "formatDate" => &["value", "format"],
        "pluralize" => &["value", "zero", "one", "two", "few", "many", "other"],
        "openUrl" => &["url"],
        "and" | "or" => &["values"],
        "@index" => &["offset"],
        _ => &[],
    };
    reject_unknown(&args, allowed, &format!("function `{call}` args"))?;
    let required: &[&str] = match call {
        "required" | "regex" | "length" | "numeric" | "email" | "formatString" | "formatNumber"
        | "not" | "pluralize" => &["value"],
        "formatCurrency" => &["value", "currency"],
        "formatDate" => &["value", "format"],
        "openUrl" => &["url"],
        "and" | "or" => &["values"],
        "@index" => &[],
        _ => &[],
    };
    if let Some(field) = required.iter().find(|field| !args.contains_key(**field)) {
        return Err(format!("function `{call}` requires argument `{field}`"));
    }
    if call == "regex" && !args.get("pattern").is_some_and(Value::is_string) {
        return Err("function `regex` requires string argument `pattern`".into());
    }
    if matches!(call, "length" | "numeric")
        && !args.contains_key("min")
        && !args.contains_key("max")
    {
        return Err(format!("function `{call}` requires `min` or `max`"));
    }
    if call == "pluralize" && !args.contains_key("other") {
        return Err("function `pluralize` requires argument `other`".into());
    }
    if matches!(call, "and" | "or")
        && !args
            .get("values")
            .and_then(Value::as_array)
            .is_some_and(|values| values.len() >= 2)
    {
        return Err(format!("function `{call}` requires at least two values"));
    }
    match call {
        "regex" | "length" | "email" | "formatString" => {
            validate_dynamic_field(&args, "value", Value::is_string, call)?;
        }
        "numeric" | "formatNumber" | "formatCurrency" | "pluralize" => {
            validate_dynamic_field(&args, "value", Value::is_number, call)?;
        }
        "not" => validate_dynamic_field(&args, "value", Value::is_boolean, call)?,
        "formatDate" => validate_dynamic_field(&args, "format", Value::is_string, call)?,
        "openUrl" => {
            let url = required_string(&args, "url")?;
            url::Url::parse(url).map_err(|error| format!("invalid openUrl URL: {error}"))?;
        }
        "and" | "or" => {
            for item in args["values"].as_array().unwrap() {
                if !item.is_boolean() {
                    let item = item.as_object().ok_or_else(|| {
                        format!("function `{call}` values must be dynamic booleans")
                    })?;
                    if !item.contains_key("path") && !item.contains_key("call") {
                        return Err(format!("function `{call}` values must be dynamic booleans"));
                    }
                }
            }
        }
        _ => {}
    }
    for field in ["min", "max", "decimals", "offset"] {
        if args.contains_key(field) {
            validate_dynamic_field(&args, field, Value::is_number, call)?;
        }
    }
    if args.contains_key("grouping") {
        validate_dynamic_field(&args, "grouping", Value::is_boolean, call)?;
    }
    for field in ["currency", "zero", "one", "two", "few", "many", "other"] {
        if args.contains_key(field) {
            validate_dynamic_field(&args, field, Value::is_string, call)?;
        }
    }
    Ok(())
}