use crate::{traits::IntoFrcValue, FrcTimestampedValue, FrcValue};

impl From<f64> for FrcValue {
    fn from(v: f64) -> Self {
        FrcValue::Double(v)
    }
}
impl From<f32> for FrcValue {
    fn from(v: f32) -> Self {
        FrcValue::Float(v)
    }
}
impl From<i64> for FrcValue {
    fn from(v: i64) -> Self {
        FrcValue::Int(v)
    }
}
impl From<i32> for FrcValue {
    fn from(v: i32) -> Self {
        FrcValue::Int(v as i64)
    }
}
impl From<i16> for FrcValue {
    fn from(v: i16) -> Self {
        FrcValue::Int(v as i64)
    }
}
impl From<i8> for FrcValue {
    fn from(v: i8) -> Self {
        FrcValue::Int(v as i64)
    }
}
impl From<u64> for FrcValue {
    fn from(v: u64) -> Self {
        FrcValue::Int(v as i64)
    }
}
impl From<u32> for FrcValue {
    fn from(v: u32) -> Self {
        FrcValue::Int(v as i64)
    }
}
impl From<u16> for FrcValue {
    fn from(v: u16) -> Self {
        FrcValue::Int(v as i64)
    }
}
impl From<u8> for FrcValue {
    fn from(v: u8) -> Self {
        FrcValue::Int(v as i64)
    }
}
impl From<bool> for FrcValue {
    fn from(v: bool) -> Self {
        FrcValue::Boolean(v)
    }
}
impl From<String> for FrcValue {
    fn from(v: String) -> Self {
        FrcValue::String(v)
    }
}
impl From<&str> for FrcValue {
    fn from(v: &str) -> Self {
        FrcValue::String(v.to_string())
    }
}
impl From<Vec<bool>> for FrcValue {
    fn from(v: Vec<bool>) -> Self {
        FrcValue::BooleanArray(v)
    }
}
impl From<Vec<i64>> for FrcValue {
    fn from(v: Vec<i64>) -> Self {
        FrcValue::IntArray(v)
    }
}
impl From<Vec<i32>> for FrcValue {
    fn from(v: Vec<i32>) -> Self {
        FrcValue::IntArray(v.iter().map(|v| *v as i64).collect())
    }
}
impl From<Vec<u64>> for FrcValue {
    fn from(v: Vec<u64>) -> Self {
        FrcValue::IntArray(v.iter().map(|v| *v as i64).collect())
    }
}
impl From<Vec<u32>> for FrcValue {
    fn from(v: Vec<u32>) -> Self {
        FrcValue::IntArray(v.iter().map(|v| *v as i64).collect())
    }
}
impl From<Vec<f32>> for FrcValue {
    fn from(v: Vec<f32>) -> Self {
        FrcValue::FloatArray(v)
    }
}
impl From<Vec<f64>> for FrcValue {
    fn from(v: Vec<f64>) -> Self {
        FrcValue::DoubleArray(v)
    }
}
impl From<Vec<String>> for FrcValue {
    fn from(v: Vec<String>) -> Self {
        FrcValue::StringArray(v)
    }
}
impl From<Vec<&str>> for FrcValue {
    fn from(v: Vec<&str>) -> Self {
        FrcValue::StringArray(v.iter().map(|s| s.to_string()).collect())
    }
}

impl<T: Into<FrcValue>> IntoFrcValue for T {
    fn into_frc_value(self) -> FrcValue {
        self.into()
    }
}

impl IntoFrcValue for FrcTimestampedValue {
    fn into_frc_value(self) -> FrcValue {
        self.value
    }
}

#[cfg(feature = "rmpv-casting")]
use crate::FrcType;

#[cfg(feature = "rmpv-casting")]
impl From<rmpv::Value> for FrcValue {
    fn from(value: rmpv::Value) -> Self {
        match value {
            rmpv::Value::Boolean(b) => Self::Boolean(b),
            rmpv::Value::Integer(i) => Self::Int(i.as_i64().unwrap_or_default()),
            rmpv::Value::F32(f) => Self::Float(f),
            rmpv::Value::F64(f) => Self::Double(f),
            rmpv::Value::String(s) => Self::String(s.to_string()),
            rmpv::Value::Binary(b) => Self::Binary(crate::FrcBinaryFormats::MsgPack(b)),
            rmpv::Value::Array(a) => {
                let mut arr = Vec::with_capacity(a.len());
                for v in a {
                    arr.push(Self::from(v));
                }
                if arr.len() == 0 {
                    Self::empty()
                } else {
                    match arr[0].get_type() {
                        FrcType::Boolean => Self::BooleanArray(
                            arr.into_iter()
                                .map(|v| match v {
                                    Self::Boolean(b) => b,
                                    _ => false,
                                })
                                .collect(),
                        ),
                        FrcType::Double => Self::DoubleArray(
                            arr.into_iter()
                                .map(|v| match v {
                                    Self::Double(f) => f,
                                    _ => 0.0,
                                })
                                .collect(),
                        ),
                        FrcType::Int => Self::IntArray(
                            arr.into_iter()
                                .map(|v| match v {
                                    Self::Int(i) => i,
                                    _ => 0,
                                })
                                .collect(),
                        ),
                        FrcType::Float => Self::FloatArray(
                            arr.into_iter()
                                .map(|v| match v {
                                    Self::Float(f) => f,
                                    _ => 0.0,
                                })
                                .collect(),
                        ),
                        FrcType::String => Self::StringArray(
                            arr.into_iter()
                                .map(|v| match v {
                                    Self::String(s) => s,
                                    _ => String::new(),
                                })
                                .collect(),
                        ),
                        _ => Self::empty(),
                    }
                }
            }
            any => panic!("Unknown type: {}", any),
        }
    }
}

#[cfg(feature = "rmpv-casting")]
impl From<FrcValue> for rmpv::Value {
    fn from(value: FrcValue) -> Self {
        match value {
            FrcValue::Boolean(b) => Self::Boolean(b),
            FrcValue::Int(i) => Self::Integer(i.into()),
            FrcValue::Float(f) => Self::F32(f),
            FrcValue::Double(f) => Self::F64(f),
            FrcValue::String(s) => Self::String(s.into()),
            FrcValue::Binary(bf) => match bf {
                crate::FrcBinaryFormats::Raw(b) => Self::Binary(b),
                crate::FrcBinaryFormats::MsgPack(b) => Self::Binary(b),
                crate::FrcBinaryFormats::Protobuf(b) => Self::Binary(b),
            },
            FrcValue::BooleanArray(a) => Self::Array(
                a.into_iter()
                    .map(|v| Self::Boolean(v))
                    .collect::<Vec<Self>>()
                    .into(),
            ),
            FrcValue::IntArray(a) => Self::Array(
                a.into_iter()
                    .map(|v| Self::Integer(v.into()))
                    .collect::<Vec<Self>>()
                    .into(),
            ),
            FrcValue::FloatArray(a) => Self::Array(
                a.into_iter()
                    .map(|v| Self::F32(v))
                    .collect::<Vec<Self>>()
                    .into(),
            ),
            FrcValue::DoubleArray(a) => Self::Array(
                a.into_iter()
                    .map(|v| Self::F64(v))
                    .collect::<Vec<Self>>()
                    .into(),
            ),
            FrcValue::StringArray(a) => Self::Array(
                a.into_iter()
                    .map(|v| Self::String(v.into()))
                    .collect::<Vec<Self>>()
                    .into(),
            ),
        }
    }
}