//! Example payload generation from JSON schemas (OpenAPI 3.0/3.1 subset).

use serde_json::{Map, Value};

use super::resolve::deref;

/// Depth cap for generated structures (also breaks schema cycles).
pub const MAX_GEN_DEPTH: usize = 6;

/// Produce an example value for a schema, preferring explicitly authored
/// examples/defaults, then enums, then combinators, then type-based stubs.
pub fn example_for_schema(doc: &Value, schema: &Value) -> Value {
    gen_value(doc, schema, 0)
}

fn gen_value(doc: &Value, schema: &Value, depth: usize) -> Value {
    if depth > MAX_GEN_DEPTH {
        return Value::Null;
    }
    let schema = deref(doc, schema);

    if let Some(ex) = schema.get("example") {
        return ex.clone();
    }
    if let Some(def) = schema.get("default") {
        return def.clone();
    }
    // OpenAPI 3.1 / JSON Schema style `examples` array.
    if let Some(first) = schema
        .get("examples")
        .and_then(Value::as_array)
        .and_then(|a| a.first())
    {
        return first.clone();
    }
    if let Some(first) = schema
        .get("enum")
        .and_then(Value::as_array)
        .and_then(|a| a.first())
    {
        return first.clone();
    }

    if let Some(all) = schema.get("allOf").and_then(Value::as_array) {
        let mut merged = Map::new();
        for sub in all {
            if let Value::Object(props) = gen_value(doc, sub, depth + 1) {
                for (k, v) in props {
                    merged.insert(k, v);
                }
            }
        }
        return Value::Object(merged);
    }
    for key in ["oneOf", "anyOf"] {
        if let Some(first) = schema
            .get(key)
            .and_then(Value::as_array)
            .and_then(|a| a.first())
        {
            return gen_value(doc, first, depth + 1);
        }
    }

    let ty = schema.get("type").and_then(Value::as_str);
    // OpenAPI 3.1 allows `type` arrays like ["string", "null"].
    let ty = ty.or_else(|| {
        schema
            .get("type")
            .and_then(Value::as_array)
            .and_then(|a| a.first())
            .and_then(Value::as_str)
    });
    let ty = ty.or_else(|| {
        if schema.get("properties").is_some() {
            Some("object")
        } else {
            None
        }
    });

    match ty {
        Some("object") => {
            let mut map = Map::new();
            if let Some(props) = schema.get("properties").and_then(Value::as_object) {
                for (k, sub) in props {
                    map.insert(k.clone(), gen_value(doc, sub, depth + 1));
                }
            }
            Value::Object(map)
        }
        Some("array") => {
            let item = schema
                .get("items")
                .map(|s| gen_value(doc, s, depth + 1))
                .unwrap_or(Value::Null);
            Value::Array(vec![item])
        }
        Some("integer") => Value::from(1),
        Some("number") => Value::from(1.0),
        Some("boolean") => Value::from(true),
        _ => string_stub(schema),
    }
}

fn string_stub(schema: &Value) -> Value {
    match schema.get("format").and_then(Value::as_str) {
        // Substituted with a fresh UUID v4 at send time.
        Some("uuid") => Value::from("{{uuid}}"),
        Some("date-time") => Value::from("2024-01-01T00:00:00Z"),
        Some("date") => Value::from("2024-01-01"),
        Some("email") => Value::from("user@example.com"),
        _ => Value::from("string"),
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use serde_json::json;

    #[test]
    fn prefers_authored_example() {
        let doc = json!({});
        let schema = json!({"type": "integer", "example": 42});
        assert_eq!(example_for_schema(&doc, &schema), json!(42));
    }

    #[test]
    fn generates_object_with_refs() {
        let doc = json!({
            "components": { "schemas": {
                "Pet": {
                    "type": "object",
                    "properties": {
                        "id": {"type": "integer", "format": "int64"},
                        "name": {"type": "string"},
                        "tag": {"type": "string", "default": "friendly"}
                    }
                }
            }}
        });
        let schema = json!({"$ref": "#/components/schemas/Pet"});
        let v = example_for_schema(&doc, &schema);
        assert_eq!(v, json!({"id": 1, "name": "string", "tag": "friendly"}));
    }

    #[test]
    fn uuid_format_becomes_variable() {
        let doc = json!({});
        let schema = json!({"type": "string", "format": "uuid"});
        assert_eq!(example_for_schema(&doc, &schema), json!("{{uuid}}"));
    }

    #[test]
    fn all_of_merges() {
        let doc = json!({});
        let schema = json!({"allOf": [
            {"type": "object", "properties": {"a": {"type": "integer"}}},
            {"type": "object", "properties": {"b": {"type": "boolean"}}}
        ]});
        assert_eq!(
            example_for_schema(&doc, &schema),
            json!({"a": 1, "b": true})
        );
    }

    #[test]
    fn terminates_on_self_reference() {
        let doc = json!({
            "components": { "schemas": {
                "Node": {"type": "object", "properties": {
                    "child": {"$ref": "#/components/schemas/Node"}
                }}
            }}
        });
        let schema = json!({"$ref": "#/components/schemas/Node"});
        let _ = example_for_schema(&doc, &schema); // must terminate
    }
}