use crate::schema;
use microrm::prelude::*;
use serde::{Deserialize, Serialize};

fn default_auth_token_expiry() -> u64 {
    600
}

#[derive(Serialize, Deserialize)]
pub struct ServerConfig {
    pub base_url: String,

    #[serde(default = "default_auth_token_expiry")]
    pub auth_token_expiry: u64,
}

impl ServerConfig {
    pub fn build_from(qi: &microrm::QueryInterface, cfile: Option<&str>) -> Self {
        let mut config_map = std::collections::HashMap::<String, String>::new();
        // load config keys from query interface
        let db_pcs = qi
            .get::<schema::PersistentConfig>()
            .all()
            .expect("couldn't get config keys from database");
        config_map.extend(db_pcs.into_iter().map(|pc| {
            let pc = pc.wrapped();
            (pc.key, pc.value)
        }));

        if let Some(path) = cfile {
            match std::fs::read(&path) {
                Ok(data) => {
                    log::info!("Loading config from {path}...");
                    let toml_table: toml::Table = toml::from_str(
                        std::str::from_utf8(data.as_slice())
                            .expect("couldn't read config file contents as utf-8"),
                    )
                    .expect("couldn't parse config toml");
                }
                Err(e) => {
                    log::error!("Could not open {path} for reading: {e}");
                }
            }
        }

        let mut deser = ConfigDeserializer {
            config_map: &config_map,
            prefix: "".to_string(),
        };

        let config = ServerConfig::deserialize(&mut deser).expect("couldn't load configuration");

        config
    }
}

struct ConfigDeserializer<'de> {
    config_map: &'de std::collections::HashMap<String, String>,
    prefix: String,
}

#[derive(Debug)]
enum ConfigError {
    Missing(String),
    InvalidType(String),
    CustomError(String),
}

impl std::fmt::Display for ConfigError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Missing(what) => f.write_fmt(format_args!(
                "Missing required config entry: {}",
                what.as_str()
            )),
            Self::InvalidType(what) => f.write_fmt(format_args!(
                "Could not parse config entry '{}'",
                what.as_str()
            )),
            Self::CustomError(what) => {
                f.write_fmt(format_args!("Custom error '{}'", what.as_str()))
            }
        }
    }
}

impl std::error::Error for ConfigError {}

impl serde::de::Error for ConfigError {
    fn custom<T>(msg: T) -> Self
    where
        T: std::fmt::Display,
    {
        Self::CustomError(msg.to_string())
    }

    fn invalid_type(_unexp: serde::de::Unexpected, _exp: &dyn serde::de::Expected) -> Self {
        Self::InvalidType("".into())
    }

    fn missing_field(field: &'static str) -> Self {
        Self::Missing(field.into())
    }
}

impl<'de> serde::Deserializer<'de> for &'de mut ConfigDeserializer<'de> {
    type Error = ConfigError;

    fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        unreachable!("deserialize_any needs context")
    }

    fn deserialize_struct<V>(
        self,
        _name: &'static str,
        _fields: &'static [&'static str],
        visitor: V,
    ) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        self.deserialize_map(visitor)
    }

    fn deserialize_seq<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        todo!("deserialize_seq")
    }

    fn deserialize_map<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        let mut map_access = ConfigDeserializerIterator {
            it: self
                .config_map
                .iter()
                .filter(|e| {
                    e.0.starts_with(&self.prefix) && !e.0[self.prefix.len()..].contains(".")
                })
                .peekable(),
        };

        visitor.visit_map(&mut map_access)
    }

    fn deserialize_enum<V>(
        self,
        _name: &'static str,
        _variants: &'static [&'static str],
        _visitor: V,
    ) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        todo!("deserialize_enum")
    }

    fn deserialize_tuple<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        todo!("deserialize_tuple")
    }

    fn deserialize_tuple_struct<V>(
        self,
        _name: &'static str,
        _len: usize,
        _visitor: V,
    ) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        todo!("deserialize_tuple_struct")
    }

    serde::forward_to_deserialize_any!(
        i8 u8 i16 u16 i32 u32 i64 u64 i128 u128 str string bytes
        bool f32 f64 char byte_buf option unit unit_struct
        newtype_struct identifier ignored_any
    );
}

struct AtomicForwarder<'de> {
    to_fwd: &'de str,
}

impl<'de> serde::Deserializer<'de> for AtomicForwarder<'de> {
    type Error = ConfigError;
    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        unreachable!()
    }

    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        visitor.visit_str(self.to_fwd)
    }

    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        visitor.visit_str(self.to_fwd)
    }

    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        visitor.visit_str(self.to_fwd)
    }

    serde::forward_to_deserialize_any!(
        i8 u8 i16 u16 i32 u32 i64 u64 i128 u128 bytes
        bool f32 f64 char byte_buf unit unit_struct option
        newtype_struct ignored_any struct tuple tuple_struct
        seq map enum
    );
}

struct ConfigDeserializerIterator<'de, I: Iterator<Item = (&'de String, &'de String)>> {
    it: std::iter::Peekable<I>,
}

impl<'de, I: Iterator<Item = (&'de String, &'de String)>> serde::de::MapAccess<'de>
    for ConfigDeserializerIterator<'de, I>
{
    type Error = ConfigError;

    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
    where
        K: serde::de::DeserializeSeed<'de>,
    {
        if let Some(e) = self.it.peek() {
            let de = AtomicForwarder {
                to_fwd: e.0.as_str(),
            };
            Ok(seed.deserialize(de).ok())
        } else {
            Ok(None)
        }
    }

    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::DeserializeSeed<'de>,
    {
        let value = self.it.next().unwrap();

        let de = AtomicForwarder {
            to_fwd: value.1.as_str(),
        };

        seed.deserialize(de)
            .map_err(|e| ConfigError::InvalidType(e.to_string()))
    }
}