/*
 * Copyright (C) 2025 Jonni Liljamo <jonni@liljamo.com>
 *
 * This file is licensed under AGPL-3.0-or-later, see NOTICE and LICENSE for
 * more information.
 */

use std::{collections::HashMap, net::IpAddr, str::FromStr};

use serde::Deserialize;
use tokio::{fs::File, io::AsyncReadExt};

#[derive(Debug)]
pub enum ConfigError {
    InvalidInterface,
    NonExistentService(String),
}

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

impl std::fmt::Display for ConfigError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::InvalidInterface => write!(f, "invalid interface"),
            Self::NonExistentService(s) => write!(f, "service '{}' does not exist", s),
        }
    }
}

#[typetag::serde(tag = "type")]
pub trait ServiceConfig {
    fn as_any(&self) -> &dyn std::any::Any;
}

pub fn deserialize_token<'de, D>(deserializer: D) -> Result<String, D::Error>
where
    D: serde::Deserializer<'de>,
{
    let token_or_path: String = serde::de::Deserialize::deserialize(deserializer)?;
    // If the value exists as a path and we can read it, read the file.
    let path = std::path::Path::new(&token_or_path);
    if path.exists() {
        match std::fs::read_to_string(path) {
            Ok(token) => return Ok(token.trim().into()),
            Err(err) => {
                tracing::warn!(msg="token exists as a filesystem path, but could not be read, assuming raw token", %err)
            }
        }
    }
    // Assume raw token.
    Ok(token_or_path)
}

#[derive(Clone, Deserialize)]
pub struct NotifierConfig {
    #[serde(deserialize_with = "deserialize_token")]
    pub token: String,
    pub services: Vec<String>,
}

#[derive(Deserialize)]
pub struct Config {
    pub interface: String,
    pub port: u16,
    pub services: HashMap<String, Box<dyn ServiceConfig>>,
    pub notifiers: HashMap<String, NotifierConfig>,
}

impl Config {
    pub async fn from_str(s: &str) -> Result<Self, Box<dyn std::error::Error>> {
        let config: Config = toml::from_str(s)?;

        // Verify interface.
        if IpAddr::from_str(&config.interface).is_err() {
            return Err(Box::new(ConfigError::InvalidInterface));
        }

        // Verify notifiers target services that exist.
        for notifier in config.notifiers.values() {
            for service in &notifier.services {
                if !config.services.contains_key(service) {
                    return Err(Box::new(ConfigError::NonExistentService(service.into())));
                }
            }
        }

        Ok(config)
    }

    pub async fn from_path(path: &str) -> Result<Self, Box<dyn std::error::Error>> {
        let mut content: String = String::new();
        File::open(path).await?.read_to_string(&mut content).await?;
        Self::from_str(&content).await
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[tokio::test]
    async fn basic_ok() {
        assert!(
            Config::from_str(
                r#"
            interface = "0.0.0.0"
            port = 8080

            [services.m]
            type = "matrix"
            instance = ""
            token = ""
            room = ""

            [notifiers.a]
            token = "42"
            services = ["m"]
        "#
            )
            .await
            .is_ok()
        );
    }

    #[tokio::test]
    async fn invalid_interface() {
        assert!(
            Config::from_str(
                r#"
            interface = "0.0.0.a"
            port = 8080
        "#
            )
            .await
            .is_err()
        );
    }
}