openapi_model_generator/

parser.rs

use crate::{
    models::{
        CompositionModel, EnumModel, Field, Model, ModelType, RequestModel, ResponseModel,
        TypeAliasModel, UnionModel, UnionType, UnionVariant,
    },
    Result,
};
use indexmap::IndexMap;
use openapiv3::{
    OpenAPI, ReferenceOr, Schema, SchemaKind, StringFormat, Type, VariantOrUnknownOrEmpty,
};
use std::collections::HashSet;

/// Information about a field extracted from OpenAPI schema
#[derive(Debug)]
struct FieldInfo {
    field_type: String,
    format: String,
    is_nullable: bool,
}

/// Converts camelCase to PascalCase
/// Example: "createRole" -> "CreateRole", "listRoles" -> "ListRoles", "listRoles-Input" -> "ListRolesInput"
fn to_pascal_case(input: &str) -> String {
    input
        .split(&['-', '_'][..])
        .filter(|s| !s.is_empty())
        .map(|s| {
            let mut chars = s.chars();
            match chars.next() {
                Some(first) => first.to_ascii_uppercase().to_string() + chars.as_str(),
                None => String::new(),
            }
        })
        .collect::<String>()
}

/// Extracts custom Rust attributes from x-rust-attrs extension
fn extract_custom_attrs(schema: &Schema) -> Option<Vec<String>> {
    schema
        .schema_data
        .extensions
        .get("x-rust-attrs")
        .and_then(|value| {
            if let Some(arr) = value.as_array() {
                let attrs: Vec<String> = arr
                    .iter()
                    .filter_map(|v| v.as_str().map(|s| s.to_string()))
                    .collect();
                if attrs.is_empty() {
                    None
                } else {
                    Some(attrs)
                }
            } else {
                tracing::warn!(
                    "x-rust-attrs should be an array of strings, got: {:?}",
                    value
                );
                None
            }
        })
}

pub fn parse_openapi(
    openapi: &OpenAPI,
) -> Result<(Vec<ModelType>, Vec<RequestModel>, Vec<ResponseModel>)> {
    let mut models = Vec::new();
    let mut requests = Vec::new();
    let mut responses = Vec::new();

    let mut added_models = HashSet::new();

    let empty_schemas = IndexMap::new();
    let empty_request_bodies = IndexMap::new();

    let (schemas, request_bodies) = if let Some(components) = &openapi.components {
        (&components.schemas, &components.request_bodies)
    } else {
        (&empty_schemas, &empty_request_bodies)
    };

    // Parse components/schemas
    if let Some(components) = &openapi.components {
        for (name, schema) in &components.schemas {
            let model_types = parse_schema_to_model_type(name, schema, &components.schemas)?;
            for model_type in model_types {
                if added_models.insert(model_type.name().to_string()) {
                    models.push(model_type);
                }
            }
        }

        // Parse components/requestBodies - извлекаем схемы и создаем модели
        for (name, request_body_ref) in &components.request_bodies {
            if let ReferenceOr::Item(request_body) = request_body_ref {
                for media_type in request_body.content.values() {
                    if let Some(schema) = &media_type.schema {
                        let model_types =
                            parse_schema_to_model_type(name, schema, &components.schemas)?;
                        for model_type in model_types {
                            if added_models.insert(model_type.name().to_string()) {
                                models.push(model_type);
                            }
                        }
                    }
                }
            }
        }
    }

    // Parse paths
    for (_path, path_item) in openapi.paths.iter() {
        let path_item = match path_item {
            ReferenceOr::Item(item) => item,
            ReferenceOr::Reference { .. } => continue,
        };

        let operations = [
            &path_item.get,
            &path_item.post,
            &path_item.put,
            &path_item.delete,
            &path_item.patch,
        ];

        for op in operations.iter().filter_map(|o| o.as_ref()) {
            let inline_models =
                process_operation(op, &mut requests, &mut responses, schemas, request_bodies)?;
            for model_type in inline_models {
                if added_models.insert(model_type.name().to_string()) {
                    models.push(model_type);
                }
            }
        }
    }

    Ok((models, requests, responses))
}

fn process_operation(
    operation: &openapiv3::Operation,
    requests: &mut Vec<RequestModel>,
    responses: &mut Vec<ResponseModel>,
    all_schemas: &IndexMap<String, ReferenceOr<Schema>>,
    request_bodies: &IndexMap<String, ReferenceOr<openapiv3::RequestBody>>,
) -> Result<Vec<ModelType>> {
    let mut inline_models = Vec::new();

    // Parse request body
    if let Some(request_body_ref) = &operation.request_body {
        let (request_body_data, is_inline) = match request_body_ref {
            ReferenceOr::Item(request_body) => (Some((request_body, request_body.required)), true),
            ReferenceOr::Reference { reference } => {
                if let Some(rb_name) = reference.strip_prefix("#/components/requestBodies/") {
                    (
                        request_bodies.get(rb_name).and_then(|rb_ref| match rb_ref {
                            ReferenceOr::Item(rb) => Some((rb, false)),
                            ReferenceOr::Reference { .. } => None,
                        }),
                        false,
                    )
                } else {
                    (None, false)
                }
            }
        };

        if let Some((request_body, is_required)) = request_body_data {
            for (content_type, media_type) in &request_body.content {
                if let Some(schema) = &media_type.schema {
                    let operation_name =
                        to_pascal_case(operation.operation_id.as_deref().unwrap_or("Unknown"));

                    let schema_type = if is_inline {
                        if let ReferenceOr::Item(schema_item) = schema {
                            if matches!(schema_item.schema_kind, SchemaKind::Type(Type::Object(_)))
                            {
                                let model_name = format!("{operation_name}RequestBody");
                                let model_types =
                                    parse_schema_to_model_type(&model_name, schema, all_schemas)?;
                                inline_models.extend(model_types);
                                model_name
                            } else {
                                extract_type_and_format(schema, all_schemas)?.0
                            }
                        } else {
                            extract_type_and_format(schema, all_schemas)?.0
                        }
                    } else {
                        extract_type_and_format(schema, all_schemas)?.0
                    };

                    let request = RequestModel {
                        name: format!("{operation_name}Request"),
                        content_type: content_type.clone(),
                        schema: schema_type,
                        is_required,
                    };
                    requests.push(request);
                }
            }
        }
    }

    // Parse responses
    for (status, response_ref) in operation.responses.responses.iter() {
        if let ReferenceOr::Item(response) = response_ref {
            for (content_type, media_type) in &response.content {
                if let Some(schema) = &media_type.schema {
                    let response = ResponseModel {
                        name: format!(
                            "{}Response",
                            to_pascal_case(operation.operation_id.as_deref().unwrap_or("Unknown"))
                        ),
                        status_code: status.to_string(),
                        content_type: content_type.clone(),
                        schema: extract_type_and_format(schema, all_schemas)?.0,
                        description: Some(response.description.clone()),
                    };
                    responses.push(response);
                }
            }
        }
    }
    Ok(inline_models)
}

fn parse_schema_to_model_type(
    name: &str,
    schema: &ReferenceOr<Schema>,
    all_schemas: &IndexMap<String, ReferenceOr<Schema>>,
) -> Result<Vec<ModelType>> {
    match schema {
        ReferenceOr::Reference { .. } => Ok(Vec::new()),
        ReferenceOr::Item(schema) => {
            if let Some(rust_type) = schema.schema_data.extensions.get("x-rust-type") {
                if let Some(type_str) = rust_type.as_str() {
                    return Ok(vec![ModelType::TypeAlias(TypeAliasModel {
                        name: to_pascal_case(name),
                        target_type: type_str.to_string(),
                        description: schema.schema_data.description.clone(),
                        custom_attrs: extract_custom_attrs(schema),
                    })]);
                }
            }

            match &schema.schema_kind {
                // regular objects
                SchemaKind::Type(Type::Object(obj)) => {
                    // Special case: object with only additionalProperties (no regular properties)
                    if obj.properties.is_empty() && obj.additional_properties.is_some() {
                        let hashmap_type = match &obj.additional_properties {
                            Some(additional_props) => match additional_props {
                                openapiv3::AdditionalProperties::Any(_) => {
                                    "std::collections::HashMap<String, serde_json::Value>"
                                        .to_string()
                                }
                                openapiv3::AdditionalProperties::Schema(schema_ref) => {
                                    let (inner_type, _) =
                                        extract_type_and_format(schema_ref, all_schemas)?;
                                    format!("std::collections::HashMap<String, {inner_type}>")
                                }
                            },
                            None => {
                                "std::collections::HashMap<String, serde_json::Value>".to_string()
                            }
                        };
                        return Ok(vec![ModelType::TypeAlias(TypeAliasModel {
                            name: to_pascal_case(name),
                            target_type: hashmap_type,
                            description: schema.schema_data.description.clone(),
                            custom_attrs: extract_custom_attrs(schema),
                        })]);
                    }

                    let mut fields = Vec::new();
                    let mut inline_models = Vec::new();

                    // Process regular properties
                    for (field_name, field_schema) in &obj.properties {
                        let (field_info, inline_model) = match field_schema {
                            ReferenceOr::Item(boxed_schema) => extract_field_info(
                                field_name,
                                &ReferenceOr::Item((**boxed_schema).clone()),
                                all_schemas,
                            )?,
                            ReferenceOr::Reference { reference } => extract_field_info(
                                field_name,
                                &ReferenceOr::Reference {
                                    reference: reference.clone(),
                                },
                                all_schemas,
                            )?,
                        };
                        if let Some(inline_model) = inline_model {
                            inline_models.push(inline_model);
                        }
                        let is_required = obj.required.contains(field_name);
                        fields.push(Field {
                            name: field_name.clone(),
                            field_type: field_info.field_type,
                            format: field_info.format,
                            is_required,
                            is_nullable: field_info.is_nullable,
                        });
                    }

                    let mut models = inline_models;
                    if obj.properties.is_empty() && obj.additional_properties.is_none() {
                        models.push(ModelType::Struct(Model {
                            name: to_pascal_case(name),
                            fields: vec![], // Пустая структура
                            custom_attrs: extract_custom_attrs(schema),
                        }));
                    } else if !fields.is_empty() {
                        models.push(ModelType::Struct(Model {
                            name: to_pascal_case(name),
                            fields,
                            custom_attrs: extract_custom_attrs(schema),
                        }));
                    }
                    Ok(models)
                }

                // allOf
                SchemaKind::AllOf { all_of } => {
                    let (all_fields, inline_models) =
                        resolve_all_of_fields(name, all_of, all_schemas)?;
                    let mut models = inline_models;

                    if !all_fields.is_empty() {
                        models.push(ModelType::Composition(CompositionModel {
                            name: to_pascal_case(name),
                            all_fields,
                            custom_attrs: extract_custom_attrs(schema),
                        }));
                    }

                    Ok(models)
                }

                // oneOf
                SchemaKind::OneOf { one_of } => {
                    let (variants, inline_models) =
                        resolve_union_variants(name, one_of, all_schemas)?;
                    let mut models = inline_models;

                    models.push(ModelType::Union(UnionModel {
                        name: to_pascal_case(name),
                        variants,
                        union_type: UnionType::OneOf,
                        custom_attrs: extract_custom_attrs(schema),
                    }));

                    Ok(models)
                }

                // anyOf
                SchemaKind::AnyOf { any_of } => {
                    let (variants, inline_models) =
                        resolve_union_variants(name, any_of, all_schemas)?;
                    let mut models = inline_models;

                    models.push(ModelType::Union(UnionModel {
                        name: to_pascal_case(name),
                        variants,
                        union_type: UnionType::AnyOf,
                        custom_attrs: extract_custom_attrs(schema),
                    }));

                    Ok(models)
                }

                // enum strings
                SchemaKind::Type(Type::String(string_type)) => {
                    if !string_type.enumeration.is_empty() {
                        let variants: Vec<String> = string_type
                            .enumeration
                            .iter()
                            .filter_map(|value| value.clone())
                            .collect();

                        if !variants.is_empty() {
                            let models = vec![ModelType::Enum(EnumModel {
                                name: to_pascal_case(name),
                                variants,
                                description: schema.schema_data.description.clone(),
                                custom_attrs: extract_custom_attrs(schema),
                            })];

                            return Ok(models);
                        }
                    }
                    Ok(Vec::new())
                }

                _ => Ok(Vec::new()),
            }
        }
    }
}

fn extract_type_and_format(
    schema: &ReferenceOr<Schema>,
    all_schemas: &IndexMap<String, ReferenceOr<Schema>>,
) -> Result<(String, String)> {
    match schema {
        ReferenceOr::Reference { reference } => {
            let type_name = reference.split('/').next_back().unwrap_or("Unknown");

            if let Some(ReferenceOr::Item(schema)) = all_schemas.get(type_name) {
                if matches!(schema.schema_kind, SchemaKind::OneOf { .. }) {
                    return Ok((to_pascal_case(type_name), "oneOf".to_string()));
                }
            }
            Ok((to_pascal_case(type_name), "reference".to_string()))
        }

        ReferenceOr::Item(schema) => match &schema.schema_kind {
            SchemaKind::Type(Type::String(string_type)) => match &string_type.format {
                VariantOrUnknownOrEmpty::Item(fmt) => match fmt {
                    StringFormat::DateTime => {
                        Ok(("DateTime<Utc>".to_string(), "date-time".to_string()))
                    }
                    StringFormat::Date => Ok(("NaiveDate".to_string(), "date".to_string())),
                    _ => Ok(("String".to_string(), format!("{fmt:?}"))),
                },
                VariantOrUnknownOrEmpty::Unknown(unknown_format) => {
                    if unknown_format.to_lowercase() == "uuid" {
                        Ok(("Uuid".to_string(), "uuid".to_string()))
                    } else {
                        Ok(("String".to_string(), unknown_format.clone()))
                    }
                }
                _ => Ok(("String".to_string(), "string".to_string())),
            },
            SchemaKind::Type(Type::Integer(_)) => Ok(("i64".to_string(), "integer".to_string())),
            SchemaKind::Type(Type::Number(_)) => Ok(("f64".to_string(), "number".to_string())),
            SchemaKind::Type(Type::Boolean(_)) => Ok(("bool".to_string(), "boolean".to_string())),
            SchemaKind::Type(Type::Array(arr)) => {
                if let Some(items) = &arr.items {
                    let items_ref: &ReferenceOr<Box<Schema>> = items;
                    let (inner_type, format) = match items_ref {
                        ReferenceOr::Item(boxed_schema) => extract_type_and_format(
                            &ReferenceOr::Item((**boxed_schema).clone()),
                            all_schemas,
                        )?,
                        ReferenceOr::Reference { reference } => {
                            let type_name = reference.split('/').next_back().unwrap_or("Unknown");

                            if let Some(ReferenceOr::Item(schema)) = all_schemas.get(type_name) {
                                if matches!(schema.schema_kind, SchemaKind::OneOf { .. }) {
                                    (to_pascal_case(type_name), "oneOf".to_string())
                                } else {
                                    extract_type_and_format(
                                        &ReferenceOr::Reference {
                                            reference: reference.clone(),
                                        },
                                        all_schemas,
                                    )?
                                }
                            } else {
                                extract_type_and_format(
                                    &ReferenceOr::Reference {
                                        reference: reference.clone(),
                                    },
                                    all_schemas,
                                )?
                            }
                        }
                    };
                    Ok((format!("Vec<{inner_type}>"), format))
                } else {
                    Ok(("Vec<serde_json::Value>".to_string(), "array".to_string()))
                }
            }
            SchemaKind::Type(Type::Object(_obj)) => {
                Ok(("serde_json::Value".to_string(), "object".to_string()))
            }
            _ => Ok(("serde_json::Value".to_string(), "unknown".to_string())),
        },
    }
}

/// Extracts field information including type, format, and nullable flag from OpenAPI schema
fn extract_field_info(
    field_name: &str,
    schema: &ReferenceOr<Schema>,
    all_schemas: &IndexMap<String, ReferenceOr<Schema>>,
) -> Result<(FieldInfo, Option<ModelType>)> {
    let (mut field_type, format) = extract_type_and_format(schema, all_schemas)?;

    let (is_nullable, en) = match schema {
        ReferenceOr::Reference { reference } => {
            let is_nullable =
                if let Some(type_name) = reference.strip_prefix("#/components/schemas/") {
                    all_schemas
                        .get(type_name)
                        .and_then(|s| match s {
                            ReferenceOr::Item(schema) => Some(schema.schema_data.nullable),
                            _ => None,
                        })
                        .unwrap_or(false)
                } else {
                    false
                };
            (is_nullable, None)
        }

        ReferenceOr::Item(schema) => {
            let is_nullable = schema.schema_data.nullable;

            let maybe_enum = match &schema.schema_kind {
                SchemaKind::Type(Type::String(s)) if !s.enumeration.is_empty() => {
                    let variants: Vec<String> =
                        s.enumeration.iter().filter_map(|v| v.clone()).collect();
                    field_type = to_pascal_case(field_name);
                    Some(ModelType::Enum(EnumModel {
                        name: to_pascal_case(field_name),
                        variants,
                        description: schema.schema_data.description.clone(),
                        custom_attrs: extract_custom_attrs(schema),
                    }))
                }
                SchemaKind::Type(Type::Object(_)) => {
                    field_type = "serde_json::Value".to_string();
                    None
                }
                _ => None,
            };
            (is_nullable, maybe_enum)
        }
    };

    Ok((
        FieldInfo {
            field_type,
            format,
            is_nullable,
        },
        en,
    ))
}

fn resolve_all_of_fields(
    _name: &str,
    all_of: &[ReferenceOr<Schema>],
    all_schemas: &IndexMap<String, ReferenceOr<Schema>>,
) -> Result<(Vec<Field>, Vec<ModelType>)> {
    let mut all_fields = Vec::new();
    let mut models = Vec::new();
    let mut all_required_fields = HashSet::new();

    for schema_ref in all_of {
        let schema_to_check = match schema_ref {
            ReferenceOr::Reference { reference } => reference
                .strip_prefix("#/components/schemas/")
                .and_then(|schema_name| all_schemas.get(schema_name)),
            ReferenceOr::Item(_) => Some(schema_ref),
        };

        if let Some(ReferenceOr::Item(schema)) = schema_to_check {
            if let SchemaKind::Type(Type::Object(obj)) = &schema.schema_kind {
                all_required_fields.extend(obj.required.iter().cloned());
            }
        }
    }

    // Теперь собираем поля из всех схем
    for schema_ref in all_of {
        match schema_ref {
            ReferenceOr::Reference { reference } => {
                if let Some(schema_name) = reference.strip_prefix("#/components/schemas/") {
                    if let Some(referenced_schema) = all_schemas.get(schema_name) {
                        let (fields, inline_models) =
                            extract_fields_from_schema(referenced_schema, all_schemas)?;
                        all_fields.extend(fields);
                        models.extend(inline_models);
                    }
                }
            }
            ReferenceOr::Item(_schema) => {
                let (fields, inline_models) = extract_fields_from_schema(schema_ref, all_schemas)?;
                all_fields.extend(fields);
                models.extend(inline_models);
            }
        }
    }

    // Обновляем is_required для полей на основе объединенного множества required
    for field in &mut all_fields {
        if all_required_fields.contains(&field.name) {
            field.is_required = true;
        }
    }

    Ok((all_fields, models))
}

fn resolve_union_variants(
    name: &str,
    schemas: &[ReferenceOr<Schema>],
    all_schemas: &IndexMap<String, ReferenceOr<Schema>>,
) -> Result<(Vec<UnionVariant>, Vec<ModelType>)> {
    use std::collections::BTreeSet;

    let mut variants = Vec::new();
    let mut models = Vec::new();
    let mut enum_values: BTreeSet<String> = BTreeSet::new();
    let mut is_all_simple_enum = true;

    for schema_ref in schemas {
        let resolved = match schema_ref {
            ReferenceOr::Reference { reference } => reference
                .strip_prefix("#/components/schemas/")
                .and_then(|n| all_schemas.get(n)),
            ReferenceOr::Item(_) => Some(schema_ref),
        };

        let Some(resolved_schema) = resolved else {
            is_all_simple_enum = false;
            continue;
        };

        match resolved_schema {
            ReferenceOr::Item(schema) => match &schema.schema_kind {
                SchemaKind::Type(Type::String(s)) if !s.enumeration.is_empty() => {
                    enum_values.extend(s.enumeration.iter().filter_map(|v| v.as_ref().cloned()));
                }
                SchemaKind::Type(Type::Integer(n)) if !n.enumeration.is_empty() => {
                    enum_values.extend(
                        n.enumeration
                            .iter()
                            .filter_map(|v| v.map(|num| format!("Value{num}"))),
                    );
                }

                _ => is_all_simple_enum = false,
            },
            ReferenceOr::Reference { reference } => {
                if let Some(n) = reference.strip_prefix("#/components/schemas/") {
                    if let Some(ReferenceOr::Item(inner)) = all_schemas.get(n) {
                        if let SchemaKind::Type(Type::String(s)) = &inner.schema_kind {
                            let values: Vec<String> = s
                                .enumeration
                                .iter()
                                .filter_map(|v| v.as_ref().cloned())
                                .collect();
                            enum_values.extend(values);
                        } else {
                            is_all_simple_enum = false;
                        }
                    }
                }
            }
        }
    }
    if is_all_simple_enum && !enum_values.is_empty() {
        let enum_name = to_pascal_case(name);
        let enum_model = ModelType::Enum(EnumModel {
            name: enum_name.clone(),
            variants: enum_values.iter().map(|v| to_pascal_case(v)).collect(),
            description: None,
            custom_attrs: None, // Collective enum from multiple schemas, no single source for attrs
        });

        return Ok((vec![], vec![enum_model]));
    }

    // fallback for usual union-schemas
    for (index, schema_ref) in schemas.iter().enumerate() {
        match schema_ref {
            ReferenceOr::Reference { reference } => {
                if let Some(schema_name) = reference.strip_prefix("#/components/schemas/") {
                    if let Some(referenced_schema) = all_schemas.get(schema_name) {
                        if let ReferenceOr::Item(schema) = referenced_schema {
                            if matches!(schema.schema_kind, SchemaKind::OneOf { .. }) {
                                variants.push(UnionVariant {
                                    name: to_pascal_case(schema_name),
                                    fields: vec![],
                                });
                            } else {
                                let (fields, inline_models) =
                                    extract_fields_from_schema(referenced_schema, all_schemas)?;
                                variants.push(UnionVariant {
                                    name: to_pascal_case(schema_name),
                                    fields,
                                });
                                models.extend(inline_models);
                            }
                        }
                    }
                }
            }
            ReferenceOr::Item(_) => {
                let (fields, inline_models) = extract_fields_from_schema(schema_ref, all_schemas)?;
                let variant_name = format!("Variant{index}");
                variants.push(UnionVariant {
                    name: variant_name,
                    fields,
                });
                models.extend(inline_models);
            }
        }
    }

    Ok((variants, models))
}

fn extract_fields_from_schema(
    schema_ref: &ReferenceOr<Schema>,
    _all_schemas: &IndexMap<String, ReferenceOr<Schema>>,
) -> Result<(Vec<Field>, Vec<ModelType>)> {
    let mut fields = Vec::new();
    let mut inline_models = Vec::new();

    match schema_ref {
        ReferenceOr::Reference { .. } => Ok((fields, inline_models)),
        ReferenceOr::Item(schema) => {
            match &schema.schema_kind {
                SchemaKind::Type(Type::Object(obj)) => {
                    for (field_name, field_schema) in &obj.properties {
                        let (field_info, inline_model) = match field_schema {
                            ReferenceOr::Item(boxed_schema) => extract_field_info(
                                field_name,
                                &ReferenceOr::Item((**boxed_schema).clone()),
                                _all_schemas,
                            )?,
                            ReferenceOr::Reference { reference } => extract_field_info(
                                field_name,
                                &ReferenceOr::Reference {
                                    reference: reference.clone(),
                                },
                                _all_schemas,
                            )?,
                        };

                        let is_nullable = field_info.is_nullable
                            || field_name == "value"
                            || field_name == "default_value";

                        let field_type = field_info.field_type.clone();

                        let is_required = obj.required.contains(field_name);
                        fields.push(Field {
                            name: field_name.clone(),
                            field_type,
                            format: field_info.format,
                            is_required,
                            is_nullable,
                        });
                        if let Some(inline_model) = inline_model {
                            match &inline_model {
                                ModelType::Struct(m) if m.fields.is_empty() => {}
                                _ => inline_models.push(inline_model),
                            }
                        }
                    }
                }
                SchemaKind::Type(Type::String(s)) if !s.enumeration.is_empty() => {
                    let name = schema
                        .schema_data
                        .title
                        .clone()
                        .unwrap_or_else(|| "AnonymousStringEnum".to_string());

                    let enum_model = ModelType::Enum(EnumModel {
                        name,
                        variants: s
                            .enumeration
                            .iter()
                            .filter_map(|v| v.as_ref().map(|s| to_pascal_case(s)))
                            .collect(),
                        description: schema.schema_data.description.clone(),
                        custom_attrs: extract_custom_attrs(schema),
                    });

                    inline_models.push(enum_model);
                }
                SchemaKind::Type(Type::Integer(n)) if !n.enumeration.is_empty() => {
                    let name = schema
                        .schema_data
                        .title
                        .clone()
                        .unwrap_or_else(|| "AnonymousIntEnum".to_string());

                    let enum_model = ModelType::Enum(EnumModel {
                        name,
                        variants: n
                            .enumeration
                            .iter()
                            .filter_map(|v| v.map(|num| format!("Value{num}")))
                            .collect(),
                        description: schema.schema_data.description.clone(),
                        custom_attrs: extract_custom_attrs(schema),
                    });

                    inline_models.push(enum_model);
                }

                _ => {}
            }

            Ok((fields, inline_models))
        }
    }
}

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

    #[test]
    fn test_parse_inline_request_body_generates_model() {
        let openapi_spec: OpenAPI = serde_json::from_value(json!({
            "openapi": "3.0.0",
            "info": { "title": "Test API", "version": "1.0.0" },
            "paths": {
                "/items": {
                    "post": {
                        "operationId": "createItem",
                        "requestBody": {
                            "content": {
                                "application/json": {
                                    "schema": {
                                        "type": "object",
                                        "properties": {
                                            "name": { "type": "string" },
                                            "value": { "type": "integer" }
                                        },
                                        "required": ["name"]
                                    }
                                }
                            }
                        },
                        "responses": { "200": { "description": "OK" } }
                    }
                }
            }
        }))
        .expect("Failed to deserialize OpenAPI spec");

        let (models, requests, _responses) =
            parse_openapi(&openapi_spec).expect("Failed to parse OpenAPI spec");

        // 1. Проверяем, что модель запроса была создана
        assert_eq!(requests.len(), 1);
        let request_model = &requests[0];
        assert_eq!(request_model.name, "CreateItemRequest");

        // 2. Проверяем, что схема запроса ссылается на НОВУЮ модель, а не на Value
        assert_eq!(request_model.schema, "CreateItemRequestBody");

        // 3. Проверяем, что сама модель для тела запроса была сгенерирована
        let inline_model = models.iter().find(|m| m.name() == "CreateItemRequestBody");
        assert!(
            inline_model.is_some(),
            "Expected a model named 'CreateItemRequestBody' to be generated"
        );

        if let Some(ModelType::Struct(model)) = inline_model {
            assert_eq!(model.fields.len(), 2);
            assert_eq!(model.fields[0].name, "name");
            assert_eq!(model.fields[0].field_type, "String");
            assert!(model.fields[0].is_required);

            assert_eq!(model.fields[1].name, "value");
            assert_eq!(model.fields[1].field_type, "i64");
            assert!(!model.fields[1].is_required);
        } else {
            panic!("Expected a Struct model for CreateItemRequestBody");
        }
    }

    #[test]
    fn test_parse_ref_request_body_works() {
        let openapi_spec: OpenAPI = serde_json::from_value(json!({
            "openapi": "3.0.0",
            "info": { "title": "Test API", "version": "1.0.0" },
            "components": {
                "schemas": {
                    "ItemData": {
                        "type": "object",
                        "properties": {
                            "name": { "type": "string" }
                        }
                    }
                },
                "requestBodies": {
                    "CreateItem": {
                        "content": {
                            "application/json": {
                                "schema": { "$ref": "#/components/schemas/ItemData" }
                            }
                        }
                    }
                }
            },
            "paths": {
                "/items": {
                    "post": {
                        "operationId": "createItem",
                        "requestBody": { "$ref": "#/components/requestBodies/CreateItem" },
                        "responses": { "200": { "description": "OK" } }
                    }
                }
            }
        }))
        .expect("Failed to deserialize OpenAPI spec");

        let (models, requests, _responses) =
            parse_openapi(&openapi_spec).expect("Failed to parse OpenAPI spec");

        // Проверяем, что модель запроса была создана
        assert_eq!(requests.len(), 1);
        let request_model = &requests[0];
        assert_eq!(request_model.name, "CreateItemRequest");

        // Проверяем, что схема ссылается на существующую модель
        assert_eq!(request_model.schema, "ItemData");

        // Проверяем, что сама модель ItemData существует в списке моделей
        assert!(models.iter().any(|m| m.name() == "ItemData"));
    }

    #[test]
    fn test_parse_no_request_body() {
        let openapi_spec: OpenAPI = serde_json::from_value(json!({
            "openapi": "3.0.0",
            "info": { "title": "Test API", "version": "1.0.0" },
            "paths": {
                "/items": {
                    "get": {
                        "operationId": "listItems",
                        "responses": { "200": { "description": "OK" } }
                    }
                }
            }
        }))
        .expect("Failed to deserialize OpenAPI spec");

        let (_models, requests, _responses) =
            parse_openapi(&openapi_spec).expect("Failed to parse OpenAPI spec");

        // Убеждаемся, что моделей запросов не создано
        assert!(requests.is_empty());
    }

    #[test]
    fn test_nullable_reference_field() {
        // Тест проверяет что nullable корректно читается из целевой схемы при использовании $ref
        let openapi_spec: OpenAPI = serde_json::from_value(json!({
            "openapi": "3.0.0",
            "info": { "title": "Test API", "version": "1.0.0" },
            "paths": {},
            "components": {
                "schemas": {
                    "NullableUser": {
                        "type": "object",
                        "nullable": true,
                        "properties": {
                            "name": { "type": "string" }
                        }
                    },
                    "Post": {
                        "type": "object",
                        "properties": {
                            "author": {
                                "$ref": "#/components/schemas/NullableUser"
                            }
                        }
                    }
                }
            }
        }))
        .expect("Failed to deserialize OpenAPI spec");

        let (models, _, _) = parse_openapi(&openapi_spec).expect("Failed to parse OpenAPI spec");

        // Находим модель Post
        let post_model = models.iter().find(|m| m.name() == "Post");
        assert!(post_model.is_some(), "Expected Post model to be generated");

        if let Some(ModelType::Struct(post)) = post_model {
            let author_field = post.fields.iter().find(|f| f.name == "author");
            assert!(author_field.is_some(), "Expected author field");

            // Проверяем что nullable правильно обработан для ссылочного типа
            // (nullable берется из целевой схемы NullableUser)
            let author = author_field.unwrap();
            assert!(
                author.is_nullable,
                "Expected author field to be nullable (from referenced schema)"
            );
        } else {
            panic!("Expected Post to be a Struct");
        }
    }

    #[test]
    fn test_allof_required_fields_merge() {
        let openapi_spec: OpenAPI = serde_json::from_value(json!({
            "openapi": "3.0.0",
            "info": { "title": "Test API", "version": "1.0.0" },
            "paths": {},
            "components": {
                "schemas": {
                    "BaseEntity": {
                        "type": "object",
                        "properties": {
                            "id": { "type": "string" },
                            "created": { "type": "string" }
                        },
                        "required": ["id"]
                    },
                    "Person": {
                        "allOf": [
                            { "$ref": "#/components/schemas/BaseEntity" },
                            {
                                "type": "object",
                                "properties": {
                                    "name": { "type": "string" },
                                    "age": { "type": "integer" }
                                },
                                "required": ["name"]
                            }
                        ]
                    }
                }
            }
        }))
        .expect("Failed to deserialize OpenAPI spec");

        let (models, _, _) = parse_openapi(&openapi_spec).expect("Failed to parse OpenAPI spec");

        // Находим модель Person
        let person_model = models.iter().find(|m| m.name() == "Person");
        assert!(
            person_model.is_some(),
            "Expected Person model to be generated"
        );

        if let Some(ModelType::Composition(person)) = person_model {
            // Проверяем что id (из BaseEntity) обязательное
            let id_field = person.all_fields.iter().find(|f| f.name == "id");
            assert!(id_field.is_some(), "Expected id field");
            assert!(
                id_field.unwrap().is_required,
                "Expected id to be required from BaseEntity"
            );

            // Проверяем что name (из второго объекта) обязательное
            let name_field = person.all_fields.iter().find(|f| f.name == "name");
            assert!(name_field.is_some(), "Expected name field");
            assert!(
                name_field.unwrap().is_required,
                "Expected name to be required from inline object"
            );

            // Проверяем что created и age не обязательные
            let created_field = person.all_fields.iter().find(|f| f.name == "created");
            assert!(created_field.is_some(), "Expected created field");
            assert!(
                !created_field.unwrap().is_required,
                "Expected created to be optional"
            );

            let age_field = person.all_fields.iter().find(|f| f.name == "age");
            assert!(age_field.is_some(), "Expected age field");
            assert!(
                !age_field.unwrap().is_required,
                "Expected age to be optional"
            );
        } else {
            panic!("Expected Person to be a Composition");
        }
    }

    #[test]
    fn test_x_rust_type_generates_type_alias() {
        let openapi_spec: OpenAPI = serde_json::from_value(json!({
            "openapi": "3.0.0",
            "info": { "title": "Test API", "version": "1.0.0" },
            "paths": {},
            "components": {
                "schemas": {
                    "User": {
                        "type": "object",
                        "x-rust-type": "crate::domain::User",
                        "description": "Custom domain user type",
                        "properties": {
                            "name": { "type": "string" },
                            "age": { "type": "integer" }
                        }
                    }
                }
            }
        }))
        .expect("Failed to deserialize OpenAPI spec");

        let (models, _, _) = parse_openapi(&openapi_spec).expect("Failed to parse OpenAPI spec");

        // Проверяем что создан TypeAlias, а не Struct
        let user_model = models.iter().find(|m| m.name() == "User");
        assert!(user_model.is_some(), "Expected User model");

        match user_model.unwrap() {
            ModelType::TypeAlias(alias) => {
                assert_eq!(alias.name, "User");
                assert_eq!(alias.target_type, "crate::domain::User");
                assert_eq!(
                    alias.description,
                    Some("Custom domain user type".to_string())
                );
            }
            _ => panic!("Expected TypeAlias, got different type"),
        }
    }

    #[test]
    fn test_x_rust_type_works_with_enum() {
        let openapi_spec: OpenAPI = serde_json::from_value(json!({
            "openapi": "3.0.0",
            "info": { "title": "Test API", "version": "1.0.0" },
            "paths": {},
            "components": {
                "schemas": {
                    "Status": {
                        "type": "string",
                        "enum": ["active", "inactive"],
                        "x-rust-type": "crate::domain::Status"
                    }
                }
            }
        }))
        .expect("Failed to deserialize OpenAPI spec");

        let (models, _, _) = parse_openapi(&openapi_spec).expect("Failed to parse OpenAPI spec");

        let status_model = models.iter().find(|m| m.name() == "Status");
        assert!(status_model.is_some(), "Expected Status model");

        // Должен быть TypeAlias, не Enum
        assert!(
            matches!(status_model.unwrap(), ModelType::TypeAlias(_)),
            "Expected TypeAlias for enum with x-rust-type"
        );
    }

    #[test]
    fn test_x_rust_type_works_with_oneof() {
        let openapi_spec: OpenAPI = serde_json::from_value(json!({
            "openapi": "3.0.0",
            "info": { "title": "Test API", "version": "1.0.0" },
            "paths": {},
            "components": {
                "schemas": {
                    "Payment": {
                        "oneOf": [
                            { "type": "object", "properties": { "card": { "type": "string" } } },
                            { "type": "object", "properties": { "cash": { "type": "number" } } }
                        ],
                        "x-rust-type": "payments::Payment"
                    }
                }
            }
        }))
        .expect("Failed to deserialize OpenAPI spec");

        let (models, _, _) = parse_openapi(&openapi_spec).expect("Failed to parse OpenAPI spec");

        let payment_model = models.iter().find(|m| m.name() == "Payment");
        assert!(payment_model.is_some(), "Expected Payment model");

        // Должен быть TypeAlias, не Union
        match payment_model.unwrap() {
            ModelType::TypeAlias(alias) => {
                assert_eq!(alias.target_type, "payments::Payment");
            }
            _ => panic!("Expected TypeAlias for oneOf with x-rust-type"),
        }
    }

    #[test]
    fn test_x_rust_attrs_on_struct() {
        let openapi_spec: OpenAPI = serde_json::from_value(json!({
            "openapi": "3.0.0",
            "info": { "title": "Test API", "version": "1.0.0" },
            "paths": {},
            "components": {
                "schemas": {
                    "User": {
                        "type": "object",
                        "x-rust-attrs": [
                            "#[derive(Serialize, Deserialize)]",
                            "#[serde(rename_all = \"camelCase\")]"
                        ],
                        "properties": {
                            "name": { "type": "string" }
                        }
                    }
                }
            }
        }))
        .expect("Failed to deserialize OpenAPI spec");

        let (models, _, _) = parse_openapi(&openapi_spec).expect("Failed to parse OpenAPI spec");

        let user_model = models.iter().find(|m| m.name() == "User");
        assert!(user_model.is_some(), "Expected User model");

        match user_model.unwrap() {
            ModelType::Struct(model) => {
                assert!(model.custom_attrs.is_some(), "Expected custom_attrs");
                let attrs = model.custom_attrs.as_ref().unwrap();
                assert_eq!(attrs.len(), 2);
                assert_eq!(attrs[0], "#[derive(Serialize, Deserialize)]");
                assert_eq!(attrs[1], "#[serde(rename_all = \"camelCase\")]");
            }
            _ => panic!("Expected Struct model"),
        }
    }

    #[test]
    fn test_x_rust_attrs_on_enum() {
        let openapi_spec: OpenAPI = serde_json::from_value(json!({
            "openapi": "3.0.0",
            "info": { "title": "Test API", "version": "1.0.0" },
            "paths": {},
            "components": {
                "schemas": {
                    "Status": {
                        "type": "string",
                        "enum": ["active", "inactive"],
                        "x-rust-attrs": ["#[serde(rename_all = \"UPPERCASE\")]"]
                    }
                }
            }
        }))
        .expect("Failed to deserialize OpenAPI spec");

        let (models, _, _) = parse_openapi(&openapi_spec).expect("Failed to parse OpenAPI spec");

        let status_model = models.iter().find(|m| m.name() == "Status");
        assert!(status_model.is_some(), "Expected Status model");

        match status_model.unwrap() {
            ModelType::Enum(enum_model) => {
                assert!(enum_model.custom_attrs.is_some());
                let attrs = enum_model.custom_attrs.as_ref().unwrap();
                assert_eq!(attrs.len(), 1);
                assert_eq!(attrs[0], "#[serde(rename_all = \"UPPERCASE\")]");
            }
            _ => panic!("Expected Enum model"),
        }
    }

    #[test]
    fn test_x_rust_attrs_with_x_rust_type() {
        let openapi_spec: OpenAPI = serde_json::from_value(json!({
            "openapi": "3.0.0",
            "info": { "title": "Test API", "version": "1.0.0" },
            "paths": {},
            "components": {
                "schemas": {
                    "User": {
                        "type": "object",
                        "x-rust-type": "crate::domain::User",
                        "x-rust-attrs": ["#[cfg_attr(test, derive(Default))]"],
                        "properties": {
                            "name": { "type": "string" }
                        }
                    }
                }
            }
        }))
        .expect("Failed to deserialize OpenAPI spec");

        let (models, _, _) = parse_openapi(&openapi_spec).expect("Failed to parse OpenAPI spec");

        let user_model = models.iter().find(|m| m.name() == "User");
        assert!(user_model.is_some(), "Expected User model");

        // Должен быть TypeAlias с атрибутами
        match user_model.unwrap() {
            ModelType::TypeAlias(alias) => {
                assert_eq!(alias.target_type, "crate::domain::User");
                assert!(alias.custom_attrs.is_some());
                let attrs = alias.custom_attrs.as_ref().unwrap();
                assert_eq!(attrs.len(), 1);
                assert_eq!(attrs[0], "#[cfg_attr(test, derive(Default))]");
            }
            _ => panic!("Expected TypeAlias with custom attrs"),
        }
    }

    #[test]
    fn test_x_rust_attrs_empty_array() {
        let openapi_spec: OpenAPI = serde_json::from_value(json!({
            "openapi": "3.0.0",
            "info": { "title": "Test API", "version": "1.0.0" },
            "paths": {},
            "components": {
                "schemas": {
                    "User": {
                        "type": "object",
                        "x-rust-attrs": [],
                        "properties": {
                            "name": { "type": "string" }
                        }
                    }
                }
            }
        }))
        .expect("Failed to deserialize OpenAPI spec");

        let (models, _, _) = parse_openapi(&openapi_spec).expect("Failed to parse OpenAPI spec");

        let user_model = models.iter().find(|m| m.name() == "User");
        assert!(user_model.is_some());

        match user_model.unwrap() {
            ModelType::Struct(model) => {
                // Пустой массив должен результировать в None
                assert!(model.custom_attrs.is_none());
            }
            _ => panic!("Expected Struct"),
        }
    }
}