use std::time::Duration;

use kameleoon_core::config::KameleoonClientConfig;
use rustler::{Decoder, NifResult, Term};

use crate::client_ex::{
    client_id, client_secret, default_timeout_millis, environment, network_domain, proxy_host,
    refresh_interval_minutes, session_duration_minutes, top_level_domain, tracking_interval_millis,
};
use crate::utils_ex::{ensure_map, optional_field};

#[derive(Debug)]
pub(crate) struct KameloonClientConfigEx {
    pub(crate) client_id: Option<String>,
    pub(crate) client_secret: Option<String>,
    pub(crate) refresh_interval_minutes: Option<u64>,
    pub(crate) session_duration_minutes: Option<u64>,
    pub(crate) default_timeout_millis: Option<u64>,
    pub(crate) tracking_interval_millis: Option<u64>,
    pub(crate) proxy_host: Option<String>,
    pub(crate) environment: Option<String>,
    pub(crate) top_level_domain: Option<String>,
    pub(crate) network_domain: Option<String>,
}

impl<'a> Decoder<'a> for KameloonClientConfigEx {
    fn decode(term: Term<'a>) -> NifResult<Self> {
        ensure_map(term)?;

        Ok(Self {
            client_id: optional_field(term, client_id())?,
            client_secret: optional_field(term, client_secret())?,
            refresh_interval_minutes: optional_field(term, refresh_interval_minutes())?,
            session_duration_minutes: optional_field(term, session_duration_minutes())?,
            default_timeout_millis: optional_field(term, default_timeout_millis())?,
            tracking_interval_millis: optional_field(term, tracking_interval_millis())?,
            proxy_host: optional_field(term, proxy_host())?,
            environment: optional_field(term, environment())?,
            top_level_domain: optional_field(term, top_level_domain())?,
            network_domain: optional_field(term, network_domain())?,
        })
    }
}

impl From<KameloonClientConfigEx> for KameleoonClientConfig {
    fn from(value: KameloonClientConfigEx) -> Self {
        let default = KameleoonClientConfig::default();
        Self {
            client_id: value.client_id.unwrap_or_default(),
            client_secret: value.client_secret.unwrap_or_default(),
            proxy_host: value.proxy_host,
            environment: value.environment,
            top_level_domain: value.top_level_domain,
            network_domain: value.network_domain,
            refresh_interval: value
                .refresh_interval_minutes
                .map(Duration::from_mins)
                .unwrap_or(default.refresh_interval),
            session_duration: value
                .session_duration_minutes
                .map(Duration::from_mins)
                .unwrap_or(default.session_duration),
            default_timeout: value.default_timeout_millis.map(Duration::from_millis).unwrap_or(default.default_timeout),
            tracking_interval: value
                .tracking_interval_millis
                .map(Duration::from_millis)
                .unwrap_or(default.tracking_interval),
        }
    }
}