//! Configuration loading, merging, and validation (loader).
//!
//! Precedence (highest to lowest):
//! - Kernel cmdline key `zosstorage.config=`
//! - CLI flags
//! - On-disk config file at /etc/zosstorage/config.yaml (if present)
//! - Built-in defaults
//!
//! See [docs/SCHEMA.md](../../docs/SCHEMA.md) for the schema details.
//
// REGION: API
// api: config::load_and_merge(cli: &crate::cli::Cli) -> crate::Result<crate::config::types::Config>
// api: config::validate(cfg: &crate::config::types::Config) -> crate::Result<()>
// REGION: API-END
//
// REGION: RESPONSIBILITIES
// - Load defaults, merge /etc config, optional CLI-referenced YAML, CLI flag overlays,
//   and kernel cmdline (zosstorage.config=) into a final Config.
// - Validate structural and semantic correctness early.
// Non-goals: device probing, partitioning, filesystem operations.
// REGION: RESPONSIBILITIES-END
//
// REGION: EXTENSION_POINTS
// ext: kernel cmdline URI schemes (e.g., http:, data:) can be added here.
// ext: alternate default config location via build-time feature or CLI.
// REGION: EXTENSION_POINTS-END
//
// REGION: SAFETY
// safety: precedence enforced (kernel > CLI flags > CLI --config > /etc file > defaults).
// safety: reserved GPT names and labels validated to avoid destructive operations later.
// REGION: SAFETY-END
//
// REGION: ERROR_MAPPING
// errmap: serde_yaml::Error -> Error::Config
// errmap: std::io::Error (file read) -> Error::Config
// errmap: serde_json::Error (merge/convert) -> Error::Other(anyhow)
// REGION: ERROR_MAPPING-END
//
// REGION: TODO
// todo: consider environment variable overlays if required.
// REGION: TODO-END

use std::fs;
use std::path::Path;

use crate::{cli::Cli, Error, Result};
use crate::types::*;
use serde_json::{Map, Value};
use base64::Engine as _;

/// Load defaults, merge on-disk config, overlay CLI, and finally kernel cmdline key.
/// Returns a validated Config on success.
///
/// Behavior:
/// - Starts from built-in defaults (documented in docs/SCHEMA.md)
/// - If /etc/zosstorage/config.yaml exists, merge it
/// - If CLI --config is provided, merge that (overrides file defaults)
/// - If kernel cmdline provides `zosstorage.config=...`, merge that last (highest precedence)
/// - Returns Error::Unimplemented when --force is used
pub fn load_and_merge(cli: &Cli) -> Result<Config> {
    if cli.force {
        return Err(Error::Unimplemented("--force flag is not implemented"));
    }

    // 1) Start with defaults
    let mut merged = to_value(default_config())?;

    // 2) Merge default on-disk config if present
    let default_cfg_path = "/etc/zosstorage/config.yaml";
    if Path::new(default_cfg_path).exists() {
        let v = load_yaml_value(default_cfg_path)?;
        merge_value(&mut merged, v);
    }

    // 3) Merge CLI referenced config (if any)
    if let Some(cfg_path) = &cli.config {
        let v = load_yaml_value(cfg_path)?;
        merge_value(&mut merged, v);
    }

    // 4) Overlay CLI flags (non-path flags)
    let cli_overlay = cli_overlay_value(cli);
    merge_value(&mut merged, cli_overlay);

    // 5) Merge kernel cmdline referenced config (if any)
    if let Some(src) = kernel_cmdline_config_source()? {
        match src {
            KernelConfigSource::Path(kpath) => {
                let v = load_yaml_value(&kpath)?;
                merge_value(&mut merged, v);
            }
            KernelConfigSource::Data(yaml) => {
                let v: serde_json::Value = serde_yaml::from_str(&yaml)
                    .map_err(|e| Error::Config(format!("failed to parse YAML from data: URL: {}", e)))?;
                merge_value(&mut merged, v);
            }
        }
    }

    // Finalize
    let cfg: Config = serde_json::from_value(merged).map_err(|e| Error::Other(e.into()))?;
    validate(&cfg)?;
    Ok(cfg)
}

/// Validate semantic correctness of the configuration.
pub fn validate(cfg: &Config) -> Result<()> {
    // Logging
    match cfg.logging.level.as_str() {
        "error" | "warn" | "info" | "debug" => {}
        other => return Err(Error::Validation(format!("invalid logging.level: {other}"))),
    }

    // Device selection
    if cfg.device_selection.include_patterns.is_empty() {
        return Err(Error::Validation(
            "device_selection.include_patterns must not be empty".into(),
        ));
    }
    if cfg.device_selection.min_size_gib == 0 {
        return Err(Error::Validation(
            "device_selection.min_size_gib must be >= 1".into(),
        ));
    }

    // Partitioning
    if cfg.partitioning.alignment_mib < 1 {
        return Err(Error::Validation(
            "partitioning.alignment_mib must be >= 1".into(),
        ));
    }
    if cfg.partitioning.bios_boot.enabled && cfg.partitioning.bios_boot.size_mib < 1 {
        return Err(Error::Validation(
            "partitioning.bios_boot.size_mib must be >= 1 when enabled".into(),
        ));
    }
    if cfg.partitioning.esp.size_mib < 1 {
        return Err(Error::Validation(
            "partitioning.esp.size_mib must be >= 1".into(),
        ));
    }

    // Reserved GPT names
    if cfg.partitioning.esp.gpt_name != "zosboot" {
        return Err(Error::Validation(
            "partitioning.esp.gpt_name must be 'zosboot'".into(),
        ));
    }
    if cfg.partitioning.data.gpt_name != "zosdata" {
        return Err(Error::Validation(
            "partitioning.data.gpt_name must be 'zosdata'".into(),
        ));
    }
    if cfg.partitioning.cache.gpt_name != "zoscache" {
        return Err(Error::Validation(
            "partitioning.cache.gpt_name must be 'zoscache'".into(),
        ));
    }
    // BIOS boot name is also 'zosboot' per current assumption
    if cfg.partitioning.bios_boot.gpt_name != "zosboot" {
        return Err(Error::Validation(
            "partitioning.bios_boot.gpt_name must be 'zosboot'".into(),
        ));
    }

    // Reserved filesystem labels
    if cfg.filesystem.vfat.label != "ZOSBOOT" {
        return Err(Error::Validation(
            "filesystem.vfat.label must be 'ZOSBOOT'".into(),
        ));
    }
    if cfg.filesystem.btrfs.label != "ZOSDATA" {
        return Err(Error::Validation(
            "filesystem.btrfs.label must be 'ZOSDATA'".into(),
        ));
    }
    if cfg.filesystem.bcachefs.label != "ZOSDATA" {
        return Err(Error::Validation(
            "filesystem.bcachefs.label must be 'ZOSDATA'".into(),
        ));
    }

    // Mount scheme
    if cfg.mount.base_dir.trim().is_empty() {
        return Err(Error::Validation("mount.base_dir must not be empty".into()));
    }

    // Topology-specific quick checks (basic for now)
    match cfg.topology {
        Topology::BtrfsSingle => {} // nothing special
        Topology::BcachefsSingle => {}
        Topology::DualIndependent => {}
        Topology::SsdHddBcachefs => {}
        Topology::Bcachefs2Copy => {}
        Topology::BtrfsRaid1 => {
            // No enforced requirement here beyond presence of two disks at runtime.
            if cfg.filesystem.btrfs.raid_profile != "raid1" && cfg.filesystem.btrfs.raid_profile != "none" {
                return Err(Error::Validation(
                    "filesystem.btrfs.raid_profile must be 'none' or 'raid1'".into(),
                ));
            }
        }
    }

    // Report path
    if cfg.report.path.trim().is_empty() {
        return Err(Error::Validation("report.path must not be empty".into()));
    }

    Ok(())
}

// ----------------------- helpers -----------------------

fn to_value<T: serde::Serialize>(t: T) -> Result<Value> {
    serde_json::to_value(t).map_err(|e| Error::Other(e.into()))
}

fn load_yaml_value(path: &str) -> Result<Value> {
    let s = fs::read_to_string(path)
        .map_err(|e| Error::Config(format!("failed to read config file {}: {}", path, e)))?;
    // Load as generic serde_json::Value for merging flexibility
    let v: serde_json::Value = serde_yaml::from_str(&s)
        .map_err(|e| Error::Config(format!("failed to parse YAML {}: {}", path, e)))?;
    Ok(v)
}

/// Merge b into a in-place:
/// - Objects are merged key-by-key (recursively)
/// - Arrays and scalars replace
fn merge_value(a: &mut Value, b: Value) {
    match (a, b) {
        (Value::Object(a_map), Value::Object(b_map)) => {
            for (k, v) in b_map {
                match a_map.get_mut(&k) {
                    Some(a_sub) => merge_value(a_sub, v),
                    None => {
                        a_map.insert(k, v);
                    }
                }
            }
        }
        (a_slot, b_other) => {
            *a_slot = b_other;
        }
    }
}

/// Produce a JSON overlay from CLI flags.
/// Only sets fields that should override defaults when present.
fn cli_overlay_value(cli: &Cli) -> Value {
    let mut root = Map::new();

    // logging overrides (always overlay CLI values for determinism)
    let mut logging = Map::new();
    logging.insert("level".into(), Value::String(cli.log_level.to_string()));
    logging.insert("to_file".into(), Value::Bool(cli.log_to_file));
    root.insert("logging".into(), Value::Object(logging));

    // mount.fstab_enabled via --fstab
    if cli.fstab {
        let mut mount = Map::new();
        mount.insert("fstab_enabled".into(), Value::Bool(true));
        root.insert("mount".into(), Value::Object(mount));
    }

    // device_selection.allow_removable via --allow-removable
    if cli.allow_removable {
        let mut device_selection = Map::new();
        device_selection.insert("allow_removable".into(), Value::Bool(true));
        root.insert("device_selection".into(), Value::Object(device_selection));
    }

    // topology override via --topology (avoid moving out of borrowed field)
    if let Some(t) = cli.topology.as_ref() {
        root.insert("topology".into(), Value::String(t.to_string()));
    }
 
    Value::Object(root)
}

enum KernelConfigSource {
    Path(String),
    /// Raw YAML from a data: URL payload after decoding (if base64-encoded).
    Data(String),
}

/// Resolve a config from kernel cmdline key `zosstorage.config=`.
/// Supports:
/// - absolute paths (e.g., /run/zos.yaml)
/// - file:/absolute/path
/// - data:application/x-yaml;base64,BASE64CONTENT
/// Returns Ok(None) when key absent.
fn kernel_cmdline_config_source() -> Result<Option<KernelConfigSource>> {
    let cmdline = fs::read_to_string("/proc/cmdline").unwrap_or_default();
    for token in cmdline.split_whitespace() {
        if let Some(rest) = token.strip_prefix("zosstorage.config=") {
            let mut val = rest.to_string();
            // Trim surrounding quotes if any
            if (val.starts_with('"') && val.ends_with('"')) || (val.starts_with('\'') && val.ends_with('\'')) {
                val = val[1..val.len() - 1].to_string();
            }
            if let Some(path) = val.strip_prefix("file:") {
                return Ok(Some(KernelConfigSource::Path(path.to_string())));
            }
            if let Some(data_url) = val.strip_prefix("data:") {
                // data:[<mediatype>][;base64],<data>
                // Find comma separating the header and payload
                if let Some(idx) = data_url.find(',') {
                    let (header, payload) = data_url.split_at(idx);
                    let payload = &payload[1..]; // skip the comma
                    let is_base64 = header.split(';').any(|seg| seg.eq_ignore_ascii_case("base64"));
                    let yaml = if is_base64 {
                        let decoded = base64::engine::general_purpose::STANDARD
                            .decode(payload.as_bytes())
                            .map_err(|e| Error::Config(format!("invalid base64 in data: URL: {}", e)))?;
                        String::from_utf8(decoded)
                            .map_err(|e| Error::Config(format!("data: URL payload not UTF-8: {}", e)))?
                    } else {
                        payload.to_string()
                    };
                    return Ok(Some(KernelConfigSource::Data(yaml)));
                } else {
                    return Err(Error::Config("malformed data: URL (missing comma)".into()));
                }
            }
            // Treat as direct path
            return Ok(Some(KernelConfigSource::Path(val)));
        }
    }
    Ok(None)
}

/// Built-in defaults for the entire configuration (schema version 1).
fn default_config() -> Config {
    Config {
        version: 1,
        logging: LoggingConfig {
            level: "info".into(),
            to_file: false,
        },
        device_selection: DeviceSelection {
            include_patterns: vec![
                String::from(r"^/dev/sd\w+$"),
                String::from(r"^/dev/nvme\w+n\d+$"),
                String::from(r"^/dev/vd\w+$"),
            ],
            exclude_patterns: vec![
                String::from(r"^/dev/ram\d+$"),
                String::from(r"^/dev/zram\d+$"),
                String::from(r"^/dev/loop\d+$"),
                String::from(r"^/dev/fd\d+$"),
            ],
            allow_removable: false,
            min_size_gib: 10,
        },
        topology: Topology::BtrfsSingle,
        partitioning: Partitioning {
            alignment_mib: 1,
            require_empty_disks: true,
            bios_boot: BiosBootSpec {
                enabled: true,
                size_mib: 1,
                gpt_name: "zosboot".into(),
            },
            esp: EspSpec {
                size_mib: 512,
                label: "ZOSBOOT".into(),
                gpt_name: "zosboot".into(),
            },
            data: DataSpec {
                gpt_name: "zosdata".into(),
            },
            cache: CacheSpec {
                gpt_name: "zoscache".into(),
            },
        },
        filesystem: FsOptions {
            btrfs: BtrfsOptions {
                label: "ZOSDATA".into(),
                compression: "zstd:3".into(),
                raid_profile: "none".into(),
            },
            bcachefs: BcachefsOptions {
                label: "ZOSDATA".into(),
                cache_mode: "promote".into(),
                compression: "zstd".into(),
                checksum: "crc32c".into(),
            },
            vfat: VfatOptions {
                label: "ZOSBOOT".into(),
            },
        },
        mount: MountScheme {
            base_dir: "/var/cache".into(),
            scheme: MountSchemeKind::PerUuid,
            fstab_enabled: false,
        },
        report: ReportOptions {
            path: "/run/zosstorage/state.json".into(),
        },
    }
}