use std::path::PathBuf;

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AppConfig {
    #[serde(default = "default_library_path")]
    pub library_path: PathBuf,

    #[serde(default = "default_database_url")]
    pub database_url: String,

    #[serde(default = "default_download_path")]
    pub download_path: PathBuf,

    #[serde(default = "default_organization_format")]
    pub organization_format: String,

    /// Which secondary release group types to include. Empty = studio releases only.
    /// Options: "Compilation", "Live", "Soundtrack", "Remix", "DJ-mix", "Demo", etc.
    #[serde(default)]
    pub allowed_secondary_types: Vec<String>,

    #[serde(default)]
    pub web: WebConfig,

    #[serde(default)]
    pub tagging: TaggingConfig,

    #[serde(default)]
    pub download: DownloadConfig,

    #[serde(default)]
    pub indexing: IndexingConfig,

    #[serde(default)]
    pub metadata: MetadataConfig,

    #[serde(default)]
    pub scheduling: SchedulingConfig,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WebConfig {
    #[serde(default = "default_port")]
    pub port: u16,

    #[serde(default = "default_bind")]
    pub bind: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TaggingConfig {
    #[serde(default)]
    pub auto_tag: bool,

    #[serde(default = "default_true")]
    pub write_tags: bool,

    #[serde(default = "default_confidence")]
    pub confidence: f64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DownloadConfig {
    #[serde(default = "default_format")]
    pub format: String,

    #[serde(default = "default_search_source")]
    pub search_source: String,

    #[serde(default)]
    pub cookies_path: Option<PathBuf>,

    /// Requests per hour (unauthenticated). Actual YouTube limit is ~300.
    #[serde(default = "default_rate_limit")]
    pub rate_limit: u32,

    /// Requests per hour (with cookies). Actual YouTube limit is ~2000.
    #[serde(default = "default_rate_limit_auth")]
    pub rate_limit_auth: u32,

    /// Enable automatic cookie refresh via headless Firefox.
    #[serde(default)]
    pub cookie_refresh_enabled: bool,

    /// How often to refresh cookies (hours).
    #[serde(default = "default_cookie_refresh_hours")]
    pub cookie_refresh_hours: u32,

    /// Port for noVNC during interactive YouTube login.
    #[serde(default = "default_vnc_port")]
    pub vnc_port: u16,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct IndexingConfig {
    /// Number of concurrent file processors during library scan.
    #[serde(default = "default_concurrency")]
    pub concurrency: usize,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MetadataConfig {
    /// Source for structured metadata: "musicbrainz" (default).
    #[serde(default = "default_metadata_source")]
    pub metadata_source: String,

    /// Source for artist images: "wikipedia" (default).
    #[serde(default = "default_artist_image_source")]
    pub artist_image_source: String,

    /// Source for artist bios: "wikipedia" (default) or "lastfm".
    #[serde(default = "default_artist_bio_source")]
    pub artist_bio_source: String,

    /// Source for lyrics: "lrclib" (default).
    #[serde(default = "default_lyrics_source")]
    pub lyrics_source: String,

    /// Source for cover art: "coverartarchive" (default).
    #[serde(default = "default_cover_art_source")]
    pub cover_art_source: String,

    /// Last.fm API key for fetching artist bios. Set via SHANTY_LASTFM_API_KEY env var.
    /// Required if artist_bio_source is "lastfm".
    #[serde(skip)]
    pub lastfm_api_key: Option<String>,

    /// fanart.tv API key for artist images/banners. Set via SHANTY_FANART_API_KEY env var.
    /// Required if artist_image_source is "fanarttv".
    #[serde(skip)]
    pub fanart_api_key: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SchedulingConfig {
    /// Enable automatic pipeline runs.
    #[serde(default)]
    pub pipeline_enabled: bool,

    /// Hours between pipeline runs (after previous completion).
    #[serde(default = "default_pipeline_interval_hours")]
    pub pipeline_interval_hours: u32,

    /// Enable automatic new release checking for monitored artists.
    #[serde(default)]
    pub monitor_enabled: bool,

    /// Hours between monitor checks.
    #[serde(default = "default_monitor_interval_hours")]
    pub monitor_interval_hours: u32,
}

impl Default for SchedulingConfig {
    fn default() -> Self {
        Self {
            pipeline_enabled: true,
            pipeline_interval_hours: default_pipeline_interval_hours(),
            monitor_enabled: true,
            monitor_interval_hours: default_monitor_interval_hours(),
        }
    }
}

// --- Defaults ---

impl Default for AppConfig {
    fn default() -> Self {
        Self {
            library_path: default_library_path(),
            database_url: default_database_url(),
            download_path: default_download_path(),
            organization_format: default_organization_format(),
            allowed_secondary_types: vec![],
            web: WebConfig::default(),
            tagging: TaggingConfig::default(),
            download: DownloadConfig::default(),
            indexing: IndexingConfig::default(),
            metadata: MetadataConfig::default(),
            scheduling: SchedulingConfig::default(),
        }
    }
}

impl Default for WebConfig {
    fn default() -> Self {
        Self {
            port: default_port(),
            bind: default_bind(),
        }
    }
}

impl Default for TaggingConfig {
    fn default() -> Self {
        Self {
            auto_tag: false,
            write_tags: true,
            confidence: default_confidence(),
        }
    }
}

impl Default for DownloadConfig {
    fn default() -> Self {
        Self {
            format: default_format(),
            search_source: default_search_source(),
            cookies_path: None,
            rate_limit: default_rate_limit(),
            rate_limit_auth: default_rate_limit_auth(),
            cookie_refresh_enabled: false,
            cookie_refresh_hours: default_cookie_refresh_hours(),
            vnc_port: default_vnc_port(),
        }
    }
}

impl Default for IndexingConfig {
    fn default() -> Self {
        Self {
            concurrency: default_concurrency(),
        }
    }
}

impl Default for MetadataConfig {
    fn default() -> Self {
        Self {
            metadata_source: default_metadata_source(),
            artist_image_source: default_artist_image_source(),
            artist_bio_source: default_artist_bio_source(),
            lyrics_source: default_lyrics_source(),
            cover_art_source: default_cover_art_source(),
            lastfm_api_key: None,
            fanart_api_key: None,
        }
    }
}

fn default_library_path() -> PathBuf {
    dirs::audio_dir().unwrap_or_else(|| PathBuf::from("~/Music"))
}

fn default_database_url() -> String {
    let data_dir = dirs::data_dir()
        .unwrap_or_else(|| PathBuf::from("."))
        .join("shanty");
    std::fs::create_dir_all(&data_dir).ok();
    format!("sqlite://{}?mode=rwc", data_dir.join("shanty.db").display())
}

fn default_download_path() -> PathBuf {
    let dir = dirs::data_dir()
        .unwrap_or_else(|| PathBuf::from("."))
        .join("shanty")
        .join("downloads");
    std::fs::create_dir_all(&dir).ok();
    dir
}

fn default_organization_format() -> String {
    "{artist}/{album}/{track_number} - {title}.{ext}".to_string()
}

fn default_port() -> u16 {
    8085
}
fn default_bind() -> String {
    "0.0.0.0".to_string()
}
fn default_confidence() -> f64 {
    0.8
}
fn default_format() -> String {
    "opus".to_string()
}
fn default_search_source() -> String {
    "ytmusic".to_string()
}
fn default_true() -> bool {
    true
}
fn default_rate_limit() -> u32 {
    250
}
fn default_rate_limit_auth() -> u32 {
    1800
}
fn default_concurrency() -> usize {
    4
}
fn default_metadata_source() -> String {
    "musicbrainz".to_string()
}
fn default_artist_image_source() -> String {
    "wikipedia".to_string()
}
fn default_artist_bio_source() -> String {
    "wikipedia".to_string()
}
fn default_lyrics_source() -> String {
    "lrclib".to_string()
}
fn default_cover_art_source() -> String {
    "coverartarchive".to_string()
}
fn default_pipeline_interval_hours() -> u32 {
    3
}
fn default_monitor_interval_hours() -> u32 {
    12
}
fn default_cookie_refresh_hours() -> u32 {
    6
}
fn default_vnc_port() -> u16 {
    6080
}

/// Return the application data directory (e.g. ~/.local/share/shanty).
pub fn data_dir() -> PathBuf {
    dirs::data_dir()
        .unwrap_or_else(|| PathBuf::from("."))
        .join("shanty")
}

// --- Loading and Saving ---

impl AppConfig {
    /// Resolve the config file path.
    pub fn config_path(override_path: Option<&str>) -> PathBuf {
        override_path
            .map(PathBuf::from)
            .or_else(|| std::env::var("SHANTY_CONFIG").ok().map(PathBuf::from))
            .unwrap_or_else(|| {
                dirs::config_dir()
                    .unwrap_or_else(|| PathBuf::from("."))
                    .join("shanty")
                    .join("config.yaml")
            })
    }

    /// Load config from file, falling back to defaults.
    pub fn load(path: Option<&str>) -> Self {
        let config_path = Self::config_path(path);

        if config_path.exists() {
            match std::fs::read_to_string(&config_path) {
                Ok(contents) => match serde_yaml::from_str(&contents) {
                    Ok(config) => {
                        tracing::info!(path = %config_path.display(), "loaded config");
                        return Self::apply_env_overrides(config);
                    }
                    Err(e) => {
                        tracing::warn!(path = %config_path.display(), error = %e, "failed to parse config, using defaults");
                    }
                },
                Err(e) => {
                    tracing::warn!(path = %config_path.display(), error = %e, "failed to read config, using defaults");
                }
            }
        } else {
            tracing::info!(path = %config_path.display(), "no config file found, using defaults");
        }

        Self::apply_env_overrides(AppConfig::default())
    }

    /// Save config to YAML file.
    pub fn save(&self, path: Option<&str>) -> Result<(), String> {
        let config_path = Self::config_path(path);
        if let Some(parent) = config_path.parent() {
            std::fs::create_dir_all(parent)
                .map_err(|e| format!("failed to create config directory: {e}"))?;
        }
        let yaml =
            serde_yaml::to_string(self).map_err(|e| format!("failed to serialize config: {e}"))?;
        std::fs::write(&config_path, yaml)
            .map_err(|e| format!("failed to write config to {}: {e}", config_path.display()))?;
        tracing::info!(path = %config_path.display(), "config saved");
        Ok(())
    }

    fn apply_env_overrides(mut config: Self) -> Self {
        if let Ok(v) = std::env::var("SHANTY_DATABASE_URL") {
            config.database_url = v;
        }
        if let Ok(v) = std::env::var("SHANTY_LIBRARY_PATH") {
            config.library_path = PathBuf::from(v);
        }
        if let Ok(v) = std::env::var("SHANTY_DOWNLOAD_PATH") {
            config.download_path = PathBuf::from(v);
        }
        if let Ok(v) = std::env::var("SHANTY_WEB_PORT")
            && let Ok(port) = v.parse()
        {
            config.web.port = port;
        }
        if let Ok(v) = std::env::var("SHANTY_WEB_BIND") {
            config.web.bind = v;
        }
        if let Ok(v) = std::env::var("SHANTY_LASTFM_API_KEY") {
            config.metadata.lastfm_api_key = Some(v);
        }
        if let Ok(v) = std::env::var("SHANTY_FANART_API_KEY") {
            config.metadata.fanart_api_key = Some(v);
        }
        config
    }
}