//! 服务端配置

use anyhow::Result;
use serde::{Deserialize, Serialize};

/// 默认 STUN 端口
pub const DEFAULT_STUN_PORT: u16 = 3478;
/// 默认 TURN 端口
pub const DEFAULT_TURN_PORT: u16 = 3479;
/// 默认 TURN 用户名
pub const DEFAULT_TURN_USERNAME: &str = "easyremote";
/// 默认 TURN 密码
pub const DEFAULT_TURN_PASSWORD: &str = "easyremote123";

#[derive(Debug, Clone, Deserialize)]
pub struct Config {
    /// 服务器主机
    pub host: String,
    /// 服务器端口
    pub port: u16,
    /// STUN 服务器端口
    pub stun_port: u16,
    /// TURN 服务器端口
    pub turn_port: u16,
    /// 公网 IP（用于生成 STUN/TURN URL）
    pub public_ip: Option<String>,
    /// 数据库URL
    pub database_url: String,
    /// JWT密钥
    pub jwt_secret: String,
    /// JWT过期时间(秒)
    pub jwt_expiry: i64,
    /// STUN服务器地址列表
    pub stun_servers: Vec<String>,
    /// 是否启用本地 STUN 服务
    pub enable_local_stun: bool,
    /// 是否启用本地 TURN 服务
    pub enable_local_turn: bool,
    /// TURN服务器地址（如果不使用本地）
    pub turn_server: Option<String>,
    /// TURN用户名
    pub turn_username: String,
    /// TURN密码
    pub turn_password: String,
    /// TURN Realm
    pub turn_realm: String,
}

/// ICE 服务器配置（返回给客户端）
#[derive(Debug, Clone, Serialize)]
pub struct IceServersConfig {
    pub stun_servers: Vec<String>,
    pub turn_server: Option<TurnConfig>,
}

#[derive(Debug, Clone, Serialize)]
pub struct TurnConfig {
    pub url: String,
    pub username: String,
    pub credential: String,
}

impl Config {
    pub fn from_env() -> Result<Self> {
        let enable_local_stun = std::env::var("ENABLE_LOCAL_STUN")
            .unwrap_or_else(|_| "true".to_string())
            .parse()
            .unwrap_or(true);

        let enable_local_turn = std::env::var("ENABLE_LOCAL_TURN")
            .unwrap_or_else(|_| "true".to_string())
            .parse()
            .unwrap_or(true);

        let stun_port: u16 = std::env::var("STUN_PORT")
            .unwrap_or_else(|_| DEFAULT_STUN_PORT.to_string())
            .parse()
            .unwrap_or(DEFAULT_STUN_PORT);

        let turn_port: u16 = std::env::var("TURN_PORT")
            .unwrap_or_else(|_| DEFAULT_TURN_PORT.to_string())
            .parse()
            .unwrap_or(DEFAULT_TURN_PORT);

        let public_ip = std::env::var("PUBLIC_IP").ok();

        let turn_username = std::env::var("TURN_USERNAME")
            .unwrap_or_else(|_| DEFAULT_TURN_USERNAME.to_string());
        let turn_password = std::env::var("TURN_PASSWORD")
            .unwrap_or_else(|_| DEFAULT_TURN_PASSWORD.to_string());
        let turn_realm = std::env::var("TURN_REALM")
            .unwrap_or_else(|_| "easyremote".to_string());

        // 构建 STUN 服务器列表
        let mut stun_servers: Vec<String> = Vec::new();
        
        // 如果启用本地 STUN，总是添加到列表最前面
        if enable_local_stun {
            let host = public_ip.as_deref().unwrap_or("localhost");
            stun_servers.push(format!("stun:{}:{}", host, stun_port));
        }
        
        // 如果设置了额外的 STUN 服务器，添加到列表
        if let Ok(extra_stun) = std::env::var("STUN_SERVERS") {
            for server in extra_stun.split(',') {
                let s = server.trim().to_string();
                if !s.is_empty() && !stun_servers.contains(&s) {
                    stun_servers.push(s);
                }
            }
        }
        
        // 如果列表为空，添加 Google STUN 作为备用
        if stun_servers.is_empty() {
            stun_servers.push("stun:stun.l.google.com:19302".to_string());
            stun_servers.push("stun:stun1.l.google.com:19302".to_string());
        }

        // TURN 服务器配置
        let turn_server = if enable_local_turn {
            None // 使用本地 TURN，URL 在 get_ice_servers 中动态生成
        } else {
            std::env::var("TURN_SERVER").ok()
        };

        Ok(Self {
            host: std::env::var("HOST").unwrap_or_else(|_| "0.0.0.0".to_string()),
            port: std::env::var("PORT")
                .unwrap_or_else(|_| "9099".to_string())
                .parse()?,
            stun_port,
            turn_port,
            public_ip,
            database_url: std::env::var("DATABASE_URL")
                .unwrap_or_else(|_| "sqlite:easyremote.db?mode=rwc".to_string()),
            jwt_secret: std::env::var("JWT_SECRET")
                .unwrap_or_else(|_| "your-super-secret-jwt-key-change-in-production".to_string()),
            jwt_expiry: std::env::var("JWT_EXPIRY")
                .unwrap_or_else(|_| "86400".to_string())
                .parse()?,
            stun_servers,
            enable_local_stun,
            enable_local_turn,
            turn_server,
            turn_username,
            turn_password,
            turn_realm,
        })
    }

    /// 获取 ICE 服务器配置
    pub fn get_ice_servers(&self) -> IceServersConfig {
        let turn_server = if self.enable_local_turn {
            // 使用本地 TURN 服务器
            let host = self.public_ip.as_deref().unwrap_or("localhost");
            Some(TurnConfig {
                url: format!("turn:{}:{}", host, self.turn_port),
                username: self.turn_username.clone(),
                credential: self.turn_password.clone(),
            })
        } else if let Some(url) = &self.turn_server {
            // 使用外部 TURN 服务器
            Some(TurnConfig {
                url: url.clone(),
                username: self.turn_username.clone(),
                credential: self.turn_password.clone(),
            })
        } else {
            None
        };

        IceServersConfig {
            stun_servers: self.stun_servers.clone(),
            turn_server,
        }
    }
}
