use crate::generated::mxaccess_gateway::v1::mx_array::Values;
use crate::generated::mxaccess_gateway::v1::mx_value::Kind;
use crate::generated::mxaccess_gateway::v1::{
    BoolArray, DoubleArray, FloatArray, Int32Array, Int64Array, MxArray, MxDataType,
    MxStatusCategory, MxStatusProxy, MxStatusSource, MxValue as ProtoMxValue, RawArray,
    StringArray, TimestampArray,
};

#[derive(Clone, Debug, PartialEq)]
pub struct MxValue {
    raw: ProtoMxValue,
    projection: MxValueProjection,
}

impl MxValue {
    pub fn from_proto(raw: ProtoMxValue) -> Self {
        let projection = MxValueProjection::from_proto(&raw);
        Self { raw, projection }
    }

    pub fn bool(value: bool) -> Self {
        Self::from_proto(ProtoMxValue {
            data_type: MxDataType::Boolean as i32,
            variant_type: "VT_BOOL".to_owned(),
            kind: Some(Kind::BoolValue(value)),
            ..ProtoMxValue::default()
        })
    }

    pub fn int32(value: i32) -> Self {
        Self::from_proto(ProtoMxValue {
            data_type: MxDataType::Integer as i32,
            variant_type: "VT_I4".to_owned(),
            kind: Some(Kind::Int32Value(value)),
            ..ProtoMxValue::default()
        })
    }

    pub fn int64(value: i64) -> Self {
        Self::from_proto(ProtoMxValue {
            data_type: MxDataType::Integer as i32,
            variant_type: "VT_I8".to_owned(),
            kind: Some(Kind::Int64Value(value)),
            ..ProtoMxValue::default()
        })
    }

    pub fn float(value: f32) -> Self {
        Self::from_proto(ProtoMxValue {
            data_type: MxDataType::Float as i32,
            variant_type: "VT_R4".to_owned(),
            kind: Some(Kind::FloatValue(value)),
            ..ProtoMxValue::default()
        })
    }

    pub fn double(value: f64) -> Self {
        Self::from_proto(ProtoMxValue {
            data_type: MxDataType::Double as i32,
            variant_type: "VT_R8".to_owned(),
            kind: Some(Kind::DoubleValue(value)),
            ..ProtoMxValue::default()
        })
    }

    pub fn string(value: impl Into<String>) -> Self {
        Self::from_proto(ProtoMxValue {
            data_type: MxDataType::String as i32,
            variant_type: "VT_BSTR".to_owned(),
            kind: Some(Kind::StringValue(value.into())),
            ..ProtoMxValue::default()
        })
    }

    pub fn raw(&self) -> &ProtoMxValue {
        &self.raw
    }

    pub fn projection(&self) -> &MxValueProjection {
        &self.projection
    }

    pub fn into_proto(self) -> ProtoMxValue {
        self.raw
    }
}

impl From<MxValue> for ProtoMxValue {
    fn from(value: MxValue) -> Self {
        value.into_proto()
    }
}

impl From<ProtoMxValue> for MxValue {
    fn from(value: ProtoMxValue) -> Self {
        Self::from_proto(value)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub enum MxValueProjection {
    Unset,
    Null,
    Bool(bool),
    Int32(i32),
    Int64(i64),
    Float(f32),
    Double(f64),
    String(String),
    Timestamp(prost_types::Timestamp),
    Array(MxArrayValue),
    Raw(Vec<u8>),
}

impl MxValueProjection {
    fn from_proto(value: &ProtoMxValue) -> Self {
        if value.is_null {
            return Self::Null;
        }

        match value.kind.as_ref() {
            Some(Kind::BoolValue(value)) => Self::Bool(*value),
            Some(Kind::Int32Value(value)) => Self::Int32(*value),
            Some(Kind::Int64Value(value)) => Self::Int64(*value),
            Some(Kind::FloatValue(value)) => Self::Float(*value),
            Some(Kind::DoubleValue(value)) => Self::Double(*value),
            Some(Kind::StringValue(value)) => Self::String(value.clone()),
            Some(Kind::TimestampValue(value)) => Self::Timestamp(*value),
            Some(Kind::ArrayValue(value)) => Self::Array(MxArrayValue::from_proto(value.clone())),
            Some(Kind::RawValue(value)) => Self::Raw(value.clone()),
            None => Self::Unset,
        }
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct MxArrayValue {
    raw: MxArray,
    projection: MxArrayProjection,
}

impl MxArrayValue {
    pub fn from_proto(raw: MxArray) -> Self {
        let projection = MxArrayProjection::from_proto(&raw);
        Self { raw, projection }
    }

    pub fn string(values: Vec<String>) -> Self {
        Self::from_proto(MxArray {
            element_data_type: MxDataType::String as i32,
            variant_type: "VT_ARRAY|VT_BSTR".to_owned(),
            dimensions: vec![values.len() as u32],
            values: Some(Values::StringValues(StringArray { values })),
            ..MxArray::default()
        })
    }

    pub fn raw(&self) -> &MxArray {
        &self.raw
    }

    pub fn projection(&self) -> &MxArrayProjection {
        &self.projection
    }
}

#[derive(Clone, Debug, PartialEq)]
pub enum MxArrayProjection {
    Unset,
    Bool(Vec<bool>),
    Int32(Vec<i32>),
    Int64(Vec<i64>),
    Float(Vec<f32>),
    Double(Vec<f64>),
    String(Vec<String>),
    Timestamp(Vec<prost_types::Timestamp>),
    Raw(Vec<Vec<u8>>),
}

impl MxArrayProjection {
    fn from_proto(array: &MxArray) -> Self {
        match array.values.as_ref() {
            Some(Values::BoolValues(BoolArray { values })) => Self::Bool(values.clone()),
            Some(Values::Int32Values(Int32Array { values })) => Self::Int32(values.clone()),
            Some(Values::Int64Values(Int64Array { values })) => Self::Int64(values.clone()),
            Some(Values::FloatValues(FloatArray { values })) => Self::Float(values.clone()),
            Some(Values::DoubleValues(DoubleArray { values })) => Self::Double(values.clone()),
            Some(Values::StringValues(StringArray { values })) => Self::String(values.clone()),
            Some(Values::TimestampValues(TimestampArray { values })) => {
                Self::Timestamp(values.clone())
            }
            Some(Values::RawValues(RawArray { values })) => Self::Raw(values.clone()),
            None => Self::Unset,
        }
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct MxStatus {
    raw: MxStatusProxy,
}

impl MxStatus {
    pub fn from_proto(raw: MxStatusProxy) -> Self {
        Self { raw }
    }

    pub fn raw(&self) -> &MxStatusProxy {
        &self.raw
    }

    pub fn success(&self) -> i32 {
        self.raw.success
    }

    pub fn category(&self) -> Option<MxStatusCategory> {
        MxStatusCategory::try_from(self.raw.category).ok()
    }

    pub fn detected_by(&self) -> Option<MxStatusSource> {
        MxStatusSource::try_from(self.raw.detected_by).ok()
    }

    pub fn detail(&self) -> i32 {
        self.raw.detail
    }

    pub fn raw_category(&self) -> i32 {
        self.raw.raw_category
    }

    pub fn raw_detected_by(&self) -> i32 {
        self.raw.raw_detected_by
    }

    pub fn diagnostic_text(&self) -> &str {
        &self.raw.diagnostic_text
    }
}