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 {
            Self {
                version: raw.version as usize,
                daemon: raw.daemon,
                error_log: raw.error_log.clone(),
                pid_file: raw.pid_file.clone(),
                upgrade_sock: raw.upgrade_sock.clone(),
                user: raw.user.clone(),
                group: raw.group.clone(),
                threads: raw.threads as usize,
                listener_tasks_per_fd: raw.listener_tasks_per_fd as usize,
                work_stealing: raw.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 as usize,
                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,
                max_retries: raw.max_retries as usize,
                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")
}