use std::collections::{HashMap, HashSet};

use serde::{Deserialize, Serialize};

use crate::{
    error::ApiErrorItem,
    ty::{ApiModel, ApiTy},
};

// 请求参数
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
pub struct ApiRequest {
    // 路径参数
    pub path: Vec<ApiTy>,

    // 查询参数
    pub query: Vec<ApiTy>,

    // 请求头参数
    pub header: Vec<ApiTy>,

    // 内容类型
    pub content_type: Option<String>,

    // 请求体参数
    pub body: Option<ApiTy>,

    // 请求错误
    pub error: HashSet<ApiErrorItem>,
}

impl ApiRequest {
    pub fn add_param(&mut self, param_ty: ApiParamType) {
        match param_ty {
            ApiParamType::Param(param) => {
                for item in param {
                    match item {
                        ApiParamPart::Header(value) => {
                            self.header.push(value);
                        }
                        ApiParamPart::Path(value) => {
                            self.path.push(value);
                        }
                        ApiParamPart::Query(value) => {
                            self.query.push(value);
                        }
                        ApiParamPart::Body { content_type, ty } => {
                            self.body = Some(ty);
                            self.content_type = Some(content_type);
                        }
                    }
                }
            }
            ApiParamType::State => {}
        }
    }

    pub fn add_error(&mut self, errors: Vec<ApiErrorItem>) {
        self.error.extend(errors);
    }
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum ApiParamPart {
    Header(ApiTy),
    Path(ApiTy),
    Query(ApiTy),
    Body { content_type: String, ty: ApiTy },
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum ApiParamType {
    Param(Vec<ApiParamPart>),

    State,
}

pub trait ApiParamExtractor {
    fn api_param_kind(models: &mut HashMap<String, Option<ApiModel>>) -> ApiParamType;

    fn api_error() -> Vec<ApiErrorItem>;
}