use std::fs;

use std::path::PathBuf;

use anyhow::{Context, Result, anyhow, bail};

use serde::{Deserialize, Serialize};

use crate::model::Collection;

/// Root config directory: `~/.config/cielago` on every platform, matching the

/// documented storage layout (rather than e.g. `~/Library/Application Support`

/// on macOS).

pub fn config_dir() -> Result<PathBuf> {

    let home = dirs::home_dir().ok_or_else(|| anyhow!("could not determine home directory"))?;

    let dir = home.join(".config").join("cielago");

    migrate_legacy_dirs(&home.join(".config"), &dir);

    Ok(dir)

}

/// Names this project shipped under before `cielago`, newest first.

const LEGACY_DIR_NAMES: [&str; 3] = ["manpost", "stableman", "getman"];

/// Move a leftover directory from an earlier name onto the current one, so

/// existing collections survive the rename. No-op once `cielago` exists.

fn migrate_legacy_dirs(config_root: &std::path::Path, new: &PathBuf) {

    if new.exists() {

        return;

    }

    for legacy in LEGACY_DIR_NAMES {

        let old = config_root.join(legacy);

        if old.exists() && fs::rename(&old, new).is_ok() {

            return;

        }

    }

}

pub fn collections_dir() -> Result<PathBuf> {

    Ok(config_dir()?.join("collections"))

}

/// Filesystem-safe slug for a collection name.

pub fn slugify(name: &str) -> String {

    let mut slug = String::new();

    let mut last_dash = false;

    for c in name.chars() {

        if c.is_ascii_alphanumeric() {

            slug.push(c.to_ascii_lowercase());

            last_dash = false;

        } else if !last_dash && !slug.is_empty() {

            slug.push('-');

            last_dash = true;

        }

    }

    let slug = slug.trim_matches('-').to_string();

    if slug.is_empty() {

        "collection".into()

    } else {

        slug

    }

}

pub fn collection_path(name: &str) -> Result<PathBuf> {

    Ok(collections_dir()?.join(format!("{}.json", slugify(name))))

}

pub fn save_collection(collection: &Collection) -> Result<PathBuf> {

    let dir = collections_dir()?;

    fs::create_dir_all(&dir).context("creating collections directory")?;

    let path = collection_path(&collection.name)?;

    let json = serde_json::to_string_pretty(collection)?;

    fs::write(&path, json).with_context(|| format!("writing {}", path.display()))?;

    Ok(path)

}

pub fn load_collection(name: &str) -> Result<Collection> {

    let path = collection_path(name)?;

    load_collection_path(&path)

}

pub fn load_collection_path(path: &PathBuf) -> Result<Collection> {

    let text = fs::read_to_string(path).with_context(|| format!("reading {}", path.display()))?;

    let collection = serde_json::from_str(&text)

        .with_context(|| format!("parsing collection at {}", path.display()))?;

    Ok(collection)

}

/// Resolve a user-typed collection name onto a saved one. Exact matches win;

/// otherwise anything that slugifies the same does, so `cielago delete "some

/// api"` finds `Some API`.

pub fn resolve_collection(name: &str) -> Result<String> {

    let names = list_collections()?;

    if let Some(found) = match_name(&names, name) {

        return Ok(found);

    }

    if names.is_empty() {

        bail!(

            "No collections yet. Import one:\n\n  cielago import <spec.json|yaml|url>\n\nOr create an empty one:\n\n  cielago new <name>"

        )

    }

    bail!(

        "No collection named {name:?}.\n\nAvailable: {}",

        names.join(", ")

    )

}

/// Pick the saved name a user-typed one refers to: exact match first, then any

/// name with the same slug (which is what the file is named after anyway).

fn match_name(names: &[String], input: &str) -> Option<String> {

    if names.iter().any(|n| n == input) {

        return Some(input.to_string());

    }

    let slug = slugify(input);

    names.iter().find(|n| slugify(n) == slug).cloned()

}

/// Delete a saved collection. Returns the file that was removed.

pub fn delete_collection(name: &str) -> Result<PathBuf> {

    let path = collection_path(name)?;

    fs::remove_file(&path).with_context(|| format!("removing {}", path.display()))?;

    Ok(path)

}

/// Names of all saved collections (derived from file names).

pub fn list_collections() -> Result<Vec<String>> {

    let dir = collections_dir()?;

    let mut names = Vec::new();

    if dir.exists() {

        for entry in fs::read_dir(&dir)? {

            let entry = entry?;

            let path = entry.path();

            if path.extension().and_then(|e| e.to_str()) == Some("json")

                && let Ok(c) = load_collection_path(&path)

            {

                names.push(c.name);

            }

        }

    }

    names.sort();

    Ok(names)

}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]

pub struct AppConfig {

    #[serde(default)]

    pub last_collection: Option<String>,

    #[serde(default)]

    pub editor: Option<String>,

}

impl AppConfig {

    fn path() -> Result<PathBuf> {

        Ok(config_dir()?.join("config.json"))

    }

    pub fn load() -> AppConfig {

        Self::path()

            .and_then(|p| Ok(fs::read_to_string(p)?))

            .and_then(|t| Ok(serde_json::from_str(&t)?))

            .unwrap_or_default()

    }

    pub fn save(&self) -> Result<()> {

        let dir = config_dir()?;

        fs::create_dir_all(&dir)?;

        fs::write(Self::path()?, serde_json::to_string_pretty(self)?)?;

        Ok(())

    }

    /// Editor to use for external body editing: config override, `$EDITOR`, else `vi`.

    pub fn editor_cmd(&self) -> String {

        self.editor

            .clone()

            .or_else(|| std::env::var("EDITOR").ok())

            .filter(|e| !e.is_empty())

            .unwrap_or_else(|| "vi".into())

    }

}

#[cfg(test)]

mod tests {

    use super::*;

    use crate::model::Method;

    #[test]

    fn slugify_basic() {

        assert_eq!(slugify("My Pet API"), "my-pet-api");

        assert_eq!(slugify("pets_v2 (internal)"), "pets-v2-internal");

        assert_eq!(slugify("!!!"), "collection");

        assert_eq!(slugify("a"), "a");

    }

    #[test]

    fn match_name_exact_then_slug() {

        let names = vec!["Some API".to_string(), "Other API".to_string()];

        assert_eq!(match_name(&names, "Some API").as_deref(), Some("Some API"));

        assert_eq!(match_name(&names, "some api").as_deref(), Some("Some API"));

        assert_eq!(match_name(&names, "some-api").as_deref(), Some("Some API"));

        assert_eq!(match_name(&names, "nope"), None);

    }

    #[test]

    fn collection_json_roundtrip() {

        let mut c = Collection::new("Test API");

        c.servers = vec![

            "https://a.example.com".into(),

            "https://b.example.com".into(),

        ];

        c.active_server = 1;

        c.variables

            .push(crate::model::KeyValueRow::new("tenant", "acme", true));

        c.auth = Some(crate::model::OAuthConfig {

            token_url: "https://auth.example.com/token".into(),

            client_id: "id".into(),

            client_secret: "secret".into(),

            scopes: vec!["read".into()],

            auth_style: crate::model::AuthStyle::Basic,

        });

        let mut r = crate::model::SavedRequest::blank("list pets");

        r.method = Method::Post;

        r.query

            .push(crate::model::KeyValueRow::new("limit", "10", false));

        r.body = Some("{\"a\":1}".into());

        c.requests.push(r);

        let json = serde_json::to_string_pretty(&c).unwrap();

        let back: Collection = serde_json::from_str(&json).unwrap();

        assert_eq!(back.name, "Test API");

        assert_eq!(back.base_url(), Some("https://b.example.com"));

        assert_eq!(back.variables[0].value, "acme");

        assert_eq!(back.auth.as_ref().unwrap().client_secret, "secret");

        assert_eq!(back.requests.len(), 1);

        assert_eq!(back.requests[0].method, Method::Post);

        assert!(!back.requests[0].query[0].enabled);

    }

}