use heck::{ToSnakeCase, ToUpperCamelCase};
use indexmap::{map::Entry, IndexMap};
use proc_macro2::TokenStream;
use quote::{format_ident, quote, ToTokens};
use syn::Ident;

use crate::openapi::r#type::OpenApiType;

use super::{r#enum::Enum, ResolvedSchema, WarningReporter};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PrimitiveType {
    Bool,
    I32,
    I64,
    String,
    Float,
    DateTime,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum PropertyType {
    Primitive(PrimitiveType),
    Ref(String),
    Enum(Enum),
    Nested(Box<Object>),
    Array(Box<PropertyType>),
    Any,
}

impl PropertyType {
    pub fn codegen(
        &self,
        namespace: &mut ObjectNamespace,
        resolved: &ResolvedSchema,
    ) -> Option<TokenStream> {
        match self {
            Self::Primitive(PrimitiveType::Bool) => Some(format_ident!("bool").into_token_stream()),
            Self::Primitive(PrimitiveType::I32) => Some(format_ident!("i32").into_token_stream()),
            Self::Primitive(PrimitiveType::I64) => Some(format_ident!("i64").into_token_stream()),
            Self::Primitive(PrimitiveType::String) => {
                Some(format_ident!("String").into_token_stream())
            }
            Self::Primitive(PrimitiveType::DateTime) => {
                Some(quote! { chrono::DateTime<chrono::Utc> })
            }
            Self::Primitive(PrimitiveType::Float) => Some(format_ident!("f64").into_token_stream()),
            Self::Ref(path) => {
                let name = path.strip_prefix("#/components/schemas/")?;
                let name = format_ident!("{name}");

                Some(quote! { crate::models::#name })
            }
            Self::Enum(r#enum) => {
                let code = r#enum.codegen(resolved)?;
                namespace.push_element(code);

                let ns = namespace.get_ident();
                let name = format_ident!("{}", r#enum.name);

                Some(quote! {
                    #ns::#name
                })
            }
            Self::Array(array) => {
                let inner_ty = array.codegen(namespace, resolved)?;

                Some(quote! {
                    Vec<#inner_ty>
                })
            }
            Self::Nested(nested) => {
                let code = nested.codegen(resolved)?;
                namespace.push_element(code);

                let ns = namespace.get_ident();
                let name = format_ident!("{}", nested.name);

                Some(quote! {
                    #ns::#name
                })
            }
            Self::Any => Some(quote! {
                serde_json::Value
            }),
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Property {
    pub field_name: String,
    pub name: String,
    pub description: Option<String>,
    pub required: bool,
    pub nullable: bool,
    pub r#type: PropertyType,
    pub deprecated: bool,
}

impl Property {
    pub fn from_schema(
        name: &str,
        required: bool,
        schema: &OpenApiType,
        schemas: &IndexMap<&str, OpenApiType>,
        warnings: WarningReporter,
    ) -> Option<Self> {
        let name = name.to_owned();
        let field_name = name.to_snake_case();
        let description = schema.description.as_deref().map(ToOwned::to_owned);

        match schema {
            OpenApiType {
                r#enum: Some(_), ..
            } => {
                let Some(r#enum) = Enum::from_schema(
                    &name.clone().to_upper_camel_case(),
                    schema,
                    warnings.clone(),
                ) else {
                    warnings.push("Failed to create enum");
                    return None;
                };
                Some(Self {
                    r#type: PropertyType::Enum(r#enum),
                    name,
                    field_name,
                    description,
                    required,
                    deprecated: schema.deprecated,
                    nullable: false,
                })
            }
            OpenApiType {
                one_of: Some(types),
                ..
            } => match types.as_slice() {
                [left, OpenApiType {
                    r#type: Some("null"),
                    ..
                }] => {
                    let mut inner = Self::from_schema(&name, required, left, schemas, warnings)?;
                    inner.nullable = true;
                    Some(inner)
                }
                [left @ .., OpenApiType {
                    r#type: Some("null"),
                    ..
                }] => {
                    let rest = OpenApiType {
                        one_of: Some(left.to_owned()),
                        ..schema.clone()
                    };
                    let mut inner = Self::from_schema(&name, required, &rest, schemas, warnings)?;
                    inner.nullable = true;
                    Some(inner)
                }
                cases => {
                    let Some(r#enum) =
                        Enum::from_one_of(&name.to_upper_camel_case(), cases, warnings.clone())
                    else {
                        warnings.push("Failed to create oneOf enum");
                        return None;
                    };

                    Some(Self {
                        name,
                        field_name,
                        description,
                        required,
                        nullable: false,
                        deprecated: schema.deprecated,
                        r#type: PropertyType::Enum(r#enum),
                    })
                }
            },
            OpenApiType {
                all_of: Some(types),
                ..
            } => {
                let obj_name = name.to_upper_camel_case();
                let composite =
                    Object::from_all_of(&obj_name, types, schemas, warnings.child(&obj_name));
                Some(Self {
                    name,
                    field_name,
                    description,
                    required,
                    nullable: false,
                    deprecated: schema.deprecated,
                    r#type: PropertyType::Nested(Box::new(composite)),
                })
            }
            OpenApiType {
                r#type: Some("object"),
                properties: None,
                ..
            } => Some(Self {
                field_name,
                name,
                description,
                required,
                nullable: false,
                r#type: PropertyType::Any,
                deprecated: schema.deprecated,
            }),
            OpenApiType {
                r#type: Some("object"),
                ..
            } => {
                let obj_name = name.to_upper_camel_case();
                Some(Self {
                    r#type: PropertyType::Nested(Box::new(Object::from_schema_object(
                        &obj_name,
                        schema,
                        schemas,
                        warnings.child(&obj_name),
                    ))),
                    name,
                    field_name,
                    description,
                    required,
                    deprecated: schema.deprecated,
                    nullable: false,
                })
            }
            OpenApiType {
                ref_path: Some(path),
                ..
            } => Some(Self {
                name,
                field_name,
                description,
                r#type: PropertyType::Ref((*path).to_owned()),
                required,
                deprecated: schema.deprecated,
                nullable: false,
            }),
            OpenApiType {
                r#type: Some("array"),
                items: Some(items),
                ..
            } => {
                let inner = Self::from_schema(&name, required, items, schemas, warnings)?;

                Some(Self {
                    name,
                    field_name,
                    description,
                    required,
                    nullable: false,
                    deprecated: schema.deprecated,
                    r#type: PropertyType::Array(Box::new(inner.r#type)),
                })
            }
            OpenApiType {
                r#type: Some(_), ..
            } => {
                let prim = match (schema.r#type, schema.format) {
                    (Some("integer"), Some("int32")) => PrimitiveType::I32,
                    (Some("integer"), Some("int64")) => PrimitiveType::I64,
                    (Some("number"), /* Some("float") */ _) | (_, Some("float")) => {
                        PrimitiveType::Float
                    }
                    (Some("string"), None) => PrimitiveType::String,
                    (Some("string"), Some("date")) => PrimitiveType::DateTime,
                    (Some("boolean"), None) => PrimitiveType::Bool,
                    _ => return None,
                };

                Some(Self {
                    name,
                    field_name,
                    description,
                    required,
                    nullable: false,
                    deprecated: schema.deprecated,
                    r#type: PropertyType::Primitive(prim),
                })
            }
            _ => {
                warnings.push("Could not resolve property type");
                None
            }
        }
    }

    pub fn codegen(
        &self,
        namespace: &mut ObjectNamespace,
        resolved: &ResolvedSchema,
    ) -> Option<TokenStream> {
        let desc = self.description.as_ref().map(|d| quote! { #[doc = #d]});

        let name = &self.name;
        let (name, serde_attr) = match name.as_str() {
            // https://doc.rust-lang.org/reference/keywords.html#r-lex.keywords
            "as" => (format_ident!("r#as"), None),
            "break" => (format_ident!("r#break"), None),
            "const" => (format_ident!("r#const"), None),
            "continue" => (format_ident!("r#continue"), None),
            "crate" => (format_ident!("r#crate"), None),
            "else" => (format_ident!("r#else"), None),
            "enum" => (format_ident!("r#enum"), None),
            "extern" => (format_ident!("r#extern"), None),
            "false" => (format_ident!("r#false"), None),
            "fn" => (format_ident!("r#fn"), None),
            "for" => (format_ident!("r#for"), None),
            "if" => (format_ident!("r#if"), None),
            "impl" => (format_ident!("r#impl"), None),
            "in" => (format_ident!("r#in"), None),
            "let" => (format_ident!("r#let"), None),
            "loop" => (format_ident!("r#loop"), None),
            "match" => (format_ident!("r#match"), None),
            "mod" => (format_ident!("r#mod"), None),
            "move" => (format_ident!("r#move"), None),
            "mut" => (format_ident!("r#mut"), None),
            "pub" => (format_ident!("r#pub"), None),
            "ref" => (format_ident!("r#ref"), None),
            "return" => (format_ident!("r#return"), None),
            "self" => (format_ident!("r#self"), None),
            "Self" => (format_ident!("r#Self"), None),
            "static" => (format_ident!("r#static"), None),
            "struct" => (format_ident!("r#struct"), None),
            "super" => (format_ident!("r#super"), None),
            "trait" => (format_ident!("r#trait"), None),
            "true" => (format_ident!("r#true"), None),
            "type" => (format_ident!("r#type"), None),
            "unsafe" => (format_ident!("r#unsafe"), None),
            "use" => (format_ident!("r#use"), None),
            "where" => (format_ident!("r#where"), None),
            "while" => (format_ident!("r#while"), None),
            "async" => (format_ident!("r#async"), None),
            "await" => (format_ident!("r#await"), None),
            "dyn" => (format_ident!("r#dyn"), None),
            "abstract" => (format_ident!("r#abstract"), None),
            "become" => (format_ident!("r#become"), None),
            "box" => (format_ident!("r#box"), None),
            "do" => (format_ident!("r#do"), None),
            "final" => (format_ident!("r#final"), None),
            "macro" => (format_ident!("r#macro"), None),
            "override" => (format_ident!("r#override"), None),
            "priv" => (format_ident!("r#priv"), None),
            "typeof" => (format_ident!("r#typeof"), None),
            "unsized" => (format_ident!("r#unsized"), None),
            "virtual" => (format_ident!("r#virtual"), None),
            "yield" => (format_ident!("r#yield"), None),
            "try" => (format_ident!("r#try"), None),
            "gen" => (format_ident!("r#gen"), None),

            name if name != self.field_name => (
                format_ident!("{}", self.field_name),
                Some(quote! { #[serde(rename = #name)]}),
            ),
            _ => (format_ident!("{}", self.field_name), None),
        };

        let ty_inner = self.r#type.codegen(namespace, resolved)?;

        let ty = if !self.required || self.nullable {
            quote! { Option<#ty_inner> }
        } else {
            ty_inner
        };

        let deprecated = self.deprecated.then(|| {
            let note = self.description.as_ref().map(|d| quote! { note = #d });

            quote! {
                #[deprecated(#note)]
            }
        });

        Some(quote! {
            #desc
            #deprecated
            #serde_attr
            pub #name: #ty
        })
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub struct Object {
    pub name: String,
    pub description: Option<String>,
    pub properties: IndexMap<String, Property>,
}

impl Object {
    pub fn from_schema_object(
        name: &str,
        schema: &OpenApiType,
        schemas: &IndexMap<&str, OpenApiType>,
        warnings: WarningReporter,
    ) -> Self {
        let mut result = Object {
            name: name.to_owned(),
            description: schema.description.as_deref().map(ToOwned::to_owned),
            ..Default::default()
        };

        let Some(props) = &schema.properties else {
            warnings.push("Missing properties");
            return result;
        };

        let required = schema.required.clone().unwrap_or_default();

        for (prop_name, prop) in props {
            let Some(prop) = Property::from_schema(
                prop_name,
                required.contains(prop_name),
                prop,
                schemas,
                warnings.child(prop_name),
            ) else {
                continue;
            };

            let field_name = prop.field_name.clone();

            let entry = result.properties.entry(field_name.clone());
            if let Entry::Occupied(mut entry) = entry {
                let other_name = entry.get().name.clone();
                warnings.push(format!(
                    "Property name collision: {other_name} and {field_name}"
                ));
                // deprioritise kebab and camelcase
                if other_name.contains('-')
                    || other_name
                        .chars()
                        .filter(|c| c.is_alphabetic())
                        .any(|c| c.is_ascii_uppercase())
                {
                    entry.insert(prop);
                }
            } else {
                entry.insert_entry(prop);
            }
        }

        result
    }

    pub fn from_all_of(
        name: &str,
        types: &[OpenApiType],
        schemas: &IndexMap<&str, OpenApiType>,
        warnings: WarningReporter,
    ) -> Self {
        let mut result = Self {
            name: name.to_owned(),
            ..Default::default()
        };

        for r#type in types {
            let r#type = if let OpenApiType {
                ref_path: Some(ref_path),
                ..
            } = r#type
            {
                let Some(name) = ref_path.strip_prefix("#/components/schemas/") else {
                    warnings.push(format!("Malformed ref {ref_path}"));
                    continue;
                };
                let Some(schema) = schemas.get(name) else {
                    warnings.push(format!("Missing schema for ref {name}"));
                    continue;
                };
                schema
            } else {
                r#type
            };
            let obj = Self::from_schema_object(name, r#type, schemas, warnings.child("variant"));

            result.description = result.description.or(obj.description);
            result.properties.extend(obj.properties);
        }

        result
    }

    pub fn codegen(&self, resolved: &ResolvedSchema) -> Option<TokenStream> {
        let doc = self.description.as_ref().map(|d| {
            quote! {
                #[doc = #d]
            }
        });

        let mut namespace = ObjectNamespace {
            object: self,
            ident: None,
            elements: Vec::default(),
        };

        let mut props = Vec::with_capacity(self.properties.len());
        for (_, prop) in &self.properties {
            props.push(prop.codegen(&mut namespace, resolved)?);
        }

        let name = format_ident!("{}", self.name);
        let ns = namespace.codegen();

        Some(quote! {
            #ns

            #doc
            #[derive(Debug, Clone, PartialEq, serde::Deserialize)]
            pub struct #name {
                #(#props),*
            }
        })
    }
}

pub struct ObjectNamespace<'o> {
    object: &'o Object,
    ident: Option<Ident>,
    elements: Vec<TokenStream>,
}

impl ObjectNamespace<'_> {
    pub fn get_ident(&mut self) -> Ident {
        self.ident
            .get_or_insert_with(|| {
                let name = self.object.name.to_snake_case();
                format_ident!("{name}")
            })
            .clone()
    }

    pub fn push_element(&mut self, el: TokenStream) {
        self.elements.push(el);
    }

    pub fn codegen(mut self) -> Option<TokenStream> {
        if self.elements.is_empty() {
            None
        } else {
            let ident = self.get_ident();
            let elements = self.elements;
            Some(quote! {
                pub mod #ident {
                    #(#elements)*
                }
            })
        }
    }
}

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

    use crate::openapi::schema::test::get_schema;

    #[test]
    fn resolve_objects() {
        let schema = get_schema();

        let mut objects = 0;
        let mut unresolved = vec![];

        for (name, desc) in &schema.components.schemas {
            if desc.r#type == Some("object") {
                objects += 1;
                let reporter = WarningReporter::new();
                Object::from_schema_object(
                    name,
                    desc,
                    &schema.components.schemas,
                    reporter.clone(),
                );
                if !reporter.is_empty() {
                    unresolved.push(name);
                }
            }
        }

        if !unresolved.is_empty() {
            panic!(
                "Failed to resolve {}/{} objects. Could not resolve [{}]",
                unresolved.len(),
                objects,
                unresolved
                    .into_iter()
                    .map(|u| format!("`{u}`"))
                    .collect::<Vec<_>>()
                    .join(", ")
            )
        }
    }
}