use std::path::Path;
use std::sync::LazyLock;

use color_eyre::eyre::Context as _;
use prost_reflect::DescriptorPool;

#[allow(unused, reason = "for prost-reflect-build")]
static DESCRIPTOR_POOL: LazyLock<DescriptorPool> = LazyLock::new(|| {
    DescriptorPool::decode(
        include_bytes!(concat!(env!("OUT_DIR"), "/file_descriptor_set.bin")).as_ref(),
    )
    .unwrap()
});

pub mod format {
    include!(concat!(env!("OUT_DIR"), "/config.format.rs"));

    impl From<&Pingora> for pingora::server::configuration::ServerConf {
        fn from(raw: &Pingora) -> Self {
            let default = pingora::server::configuration::ServerConf::default();
            Self {
                version: raw.version.map(|v| v as usize).unwrap_or(default.version),
                daemon: raw.daemon.unwrap_or(default.daemon),
                error_log: raw.error_log.clone(),
                pid_file: raw.pid_file.clone().unwrap_or(default.pid_file),
                upgrade_sock: raw.upgrade_sock.clone().unwrap_or(default.upgrade_sock),
                user: raw.user.clone(),
                group: raw.group.clone(),
                threads: raw.threads.map(|t| t as usize).unwrap_or(default.threads),
                listener_tasks_per_fd: raw
                    .listener_tasks_per_fd
                    .map(|t| t as usize)
                    .unwrap_or(default.listener_tasks_per_fd),
                work_stealing: raw.work_stealing.unwrap_or(default.work_stealing),
                ca_file: raw.ca_file.clone(),
                grace_period_seconds: raw.grace_period_seconds,
                graceful_shutdown_timeout_seconds: raw.graceful_shutdown_timeout_seconds,
                client_bind_to_ipv4: raw.client_bind_to_ipv4.clone(),
                client_bind_to_ipv6: raw.client_bind_to_ipv6.clone(),
                upstream_keepalive_pool_size: raw
                    .upstream_keepalive_pool_size
                    .map(|s| s as usize)
                    .unwrap_or(default.upstream_keepalive_pool_size),
                upstream_connect_offload_threadpools: raw
                    .upstream_connect_offload_threadpools
                    .map(|x| x as usize),
                upstream_connect_offload_thread_per_pool: raw
                    .upstream_connect_offload_thread_per_pool
                    .map(|x| x as usize),
                upstream_debug_ssl_keylog: raw
                    .upstream_debug_ssl_keylog
                    .unwrap_or(default.upstream_debug_ssl_keylog),
                max_retries: raw
                    .max_retries
                    .map(|r| r as usize)
                    .unwrap_or(default.max_retries),
                upgrade_sock_connect_accept_max_retries: raw
                    .upgrade_sock_connect_accept_max_retries
                    .map(|x| x as usize),
            }
        }
    }
}

/// load the config from the given file
pub fn load(src: impl AsRef<Path>) -> color_eyre::Result<format::Config> {
    use prost_reflect::{DynamicMessage, ReflectMessage as _};

    let dynamic = DynamicMessage::parse_text_format(
        format::Config::default().descriptor(),
        &std::fs::read_to_string(src).context("reading config file")?,
    )
    .context("parsing config")?;

    dynamic.transcode_to().context("validating config")
}