use std::sync::Arc;

use datatype::DataType;
use serde::ser::{SerializeMap, Serializer};
use serde::{Deserialize, Serialize};
use validation::Validation;

mod datatype;
mod validation;

#[derive(Clone, Debug)]
pub struct Parameter {
    name: Arc<str>,

    data_type: DataType,

    #[allow(dead_code)]
    is_array: bool,

    aliases: Vec<Arc<str>>,
    description: Option<Arc<str>>,
    help_message: Option<Arc<str>>,
    parameter_sets: Vec<ParameterSet>,
    validations: Vec<Validation>,
}

impl Serialize for Parameter {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut state = serializer.serialize_map(None)?;

        state.serialize_entry("name", &self.name)?;

        let mut type_str = format!("{}", self.data_type);
        if self.is_array {
            type_str.push_str("[]");
        }
        state.serialize_entry("type", &type_str)?;

        state.serialize_entry("aliases", &self.aliases)?;

        if let Some(desc) = &self.description {
            state.serialize_entry("description", desc)?;
        }

        if let Some(help) = &self.help_message {
            state.serialize_entry("helpMessage", help)?;
        }

        state.serialize_entry("parameterSets", &self.parameter_sets)?;
        state.serialize_entry("validations", &self.validations)?;

        state.end()
    }
}

impl<'de> Deserialize<'de> for Parameter {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[derive(Deserialize)]
        #[serde(rename_all = "camelCase")]
        struct RawParameter {
            name: Arc<str>,
            #[serde(rename = "type")]
            data_type: String,
            aliases: Vec<Arc<str>>,
            description: Option<Arc<str>>,
            help_message: Option<Arc<str>>,
            parameter_sets: Vec<ParameterSet>,
            validations: Vec<Validation>,
        }

        let raw = RawParameter::deserialize(deserializer)?;

        let is_array = raw.data_type.ends_with("[]");
        let type_str = raw.data_type.trim_end_matches("[]");

        let data_type: DataType =
            serde_json::from_str(&format!("\"{}\"", type_str)).map_err(serde::de::Error::custom)?;

        Ok(Parameter {
            name: raw.name,
            data_type,
            is_array,
            aliases: raw.aliases,
            description: raw.description,
            help_message: raw.help_message,
            parameter_sets: raw.parameter_sets,
            validations: raw.validations,
        })
    }
}

#[derive(Deserialize, Serialize, Clone, PartialEq, Eq, Default, Debug)]
pub struct ParameterSet {
    name: Arc<str>,
    mandatory: bool,
    position: Option<u8>,
    value_from_pipeline: Option<bool>,
    value_from_pipeline_by_property_name: Option<bool>,
}