use std::env;

pub const TEMP_PATH: &str = "/tmp/senator_sperma";

#[derive(Debug, Clone)]
pub struct Config {
    pub token: String,
    pub status_channel_id: Option<u64>,
    pub assistant_keyword: String,
    pub copyparty_url: String,
    pub copyparty_url_upload: String,
    pub copyparty_password: Option<String>,
    pub openrouter_api_key: Option<String>,
    pub openrouter_model: Option<String>,
    pub database_path: String,
}

struct EnvVar {
    name: &'static str,
    required: bool,
    default: Option<&'static str>,
    description: &'static str,
}

const ENV_VARS: &[EnvVar] = &[
    EnvVar {
        name: "TOKEN",
        required: true,
        default: None,
        description: "Discord bot token",
    },
    EnvVar {
        name: "STATUS_CHANNEL_ID",
        required: false,
        default: None,
        description: "status channel ID",
    },
    EnvVar {
        name: "ASSISTANT_KEYWORD",
        required: false,
        default: Some("jarvis"),
        description: "keyword for AI assistant",
    },
    EnvVar {
        name: "COPYPARTY_URL",
        required: false,
        default: Some("http://localhost:3939"),
        description: "Copyparty base URL",
    },
    EnvVar {
        name: "COPYPARTY_URL_UPLOAD",
        required: false,
        default: Some("http://localhost:3939"),
        description: "Copyparty upload URL",
    },
    EnvVar {
        name: "COPYPARTY_PASSWORD",
        required: false,
        default: None,
        description: "Copyparty auth password",
    },
    EnvVar {
        name: "OPENROUTER_API_KEY",
        required: false,
        default: None,
        description: "OpenRouter API key (disables AI if missing)",
    },
    EnvVar {
        name: "OPENROUTER_MODEL",
        required: false,
        default: Some("cognitivecomputations/dolphin-mistral-24b-venice-edition:free"),
        description: "OpenRouter model",
    },
    EnvVar {
        name: "SENATOR_DB_PATH",
        required: false,
        default: Some("data/senator.db"),
        description: "SQLite database path",
    },
    EnvVar {
        name: "RUST_LOG",
        required: false,
        default: Some("info"),
        description: "tracing/logging level filter",
    },
];

pub fn check_env_vars() {
    let mut missing_required = Vec::new();
    let mut missing_optional = Vec::new();

    for var in ENV_VARS {
        match env::var(var.name) {
            Ok(_) => continue,
            Err(_) => {
                if var.required {
                    tracing::error!("MISSING REQUIRED: {} ({})", var.name, var.description);
                    missing_required.push(var.name);
                } else {
                    match var.default {
                        Some(default) => {
                            tracing::warn!("{} not set, using default: {}", var.name, default)
                        }
                        None => tracing::warn!("{} not set ({})", var.name, var.description),
                    }
                    missing_optional.push(var.name);
                }
            }
        }
    }

    if !missing_required.is_empty() {
        tracing::error!(
            "Missing required environment variables: {}. The application will not function correctly.",
            missing_required.join(", ")
        );
    }

    if !missing_optional.is_empty() {
        tracing::warn!(
            "Missing optional environment variables: {}. Some features will be disabled or use defaults.",
            missing_optional.join(", ")
        );
    }
}

impl Config {
    pub fn from_env() -> Self {
        Self {
            token: env::var("TOKEN").expect("Missing TOKEN"),
            status_channel_id: env::var("STATUS_CHANNEL_ID")
                .ok()
                .and_then(|v| v.parse().ok()),
            assistant_keyword: env::var("ASSISTANT_KEYWORD").unwrap_or_else(|_| "jarvis".into()),
            copyparty_url: env::var("COPYPARTY_URL")
                .unwrap_or_else(|_| "http://localhost:3939".into()),
            copyparty_url_upload: env::var("COPYPARTY_URL_UPLOAD")
                .unwrap_or_else(|_| "http://localhost:3939".into()),
            copyparty_password: env::var("COPYPARTY_PASSWORD").ok(),
            openrouter_api_key: env::var("OPENROUTER_API_KEY").ok(),
            openrouter_model: env::var("OPENROUTER_MODEL").ok(),
            database_path: env::var("SENATOR_DB_PATH").unwrap_or_else(|_| "data/senator.db".into()),
        }
    }
}