use std::collections::BTreeMap;

use std::fs;

use std::io::{self, Write};

use std::process::Command as ProcessCommand;

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

use clap::{Parser, Subcommand};

use cielago::app;

use cielago::model::Collection;

use cielago::openapi;

use cielago::store::{self, AppConfig};

const BANNER: &str = r#"

     c i e l a g o

        .-'"/'.       

     _-"   (   '-_     

 _.-'       )     "-._ 

         .-'          `

____________ _____  __

"#;

#[derive(Parser)]

#[command(

    name = "cielago",

    version,

    about = "Like Postman but it actually works",

    before_help = BANNER

)]

struct Cli {

    #[command(subcommand)]

    command: Option<Command>,

}

#[derive(Subcommand)]

enum Command {

    /// Import an OpenAPI 3.x spec (JSON/YAML, file path or URL) as a collection

    Import {

        /// File path or http(s) URL of the spec

        source: String,

        /// Collection name (defaults to the spec's info.title)

        #[arg(long)]

        name: Option<String>,

    },

    /// Create an empty collection and open it in the TUI

    New {

        /// Collection name

        name: String,

        /// Base URL to start with (becomes the active server)

        #[arg(long, short)]

        server: Option<String>,

    },

    /// List saved collections

    List {

        /// Show servers, request counts and file paths

        #[arg(short, long)]

        long: bool,

    },

    /// Open a collection in the TUI (defaults to the last opened one)

    Open { name: Option<String> },

    /// Delete a saved collection

    Delete {

        name: String,

        /// Skip the confirmation prompt

        #[arg(short, long)]

        force: bool,

    },

    /// Edit a collection's JSON in $EDITOR

    Edit { name: String },

    /// Rename a collection (renames its file too)

    Rename { name: String, new_name: String },

    /// Replace a collection's requests from a spec, keeping auth/vars/servers

    Update {

        /// Collection to update

        name: String,

        /// File path or http(s) URL of the spec to pull routes from

        source: String,

    },

    /// Show details about a collection

    Info { name: String },

    /// Print the path of a collection's JSON file

    Path { name: String },

}

#[tokio::main]

async fn main() -> Result<()> {

    let cli = Cli::parse();

    match cli.command {

        Some(Command::Import { source, name }) => cmd_import(&source, name).await,

        Some(Command::New { name, server }) => cmd_new(&name, server).await,

        Some(Command::List { long }) => cmd_list(long),

        Some(Command::Open { name }) => cmd_open(name).await,

        Some(Command::Delete { name, force }) => cmd_delete(&name, force),

        Some(Command::Edit { name }) => cmd_edit(&name),

        Some(Command::Rename { name, new_name }) => cmd_rename(&name, &new_name),

        Some(Command::Update { name, source }) => cmd_update(&name, &source).await,

        Some(Command::Info { name }) => cmd_info(&name),

        Some(Command::Path { name }) => cmd_path(&name),

        None => cmd_open(None).await,

    }

}

async fn cmd_import(source: &str, name: Option<String>) -> Result<()> {

    let doc = openapi::load_spec(source).await?;

    let name = name

        .or_else(|| {

            doc.pointer("/info/title")

                .and_then(|t| t.as_str())

                .map(String::from)

        })

        .unwrap_or_else(|| "imported".to_string());

    let collection = openapi::import_spec(&doc, &name, Some(source.to_string()));

    let path = store::save_collection(&collection)?;

    println!(

        "Imported collection \"{}\" -> {}",

        collection.name,

        path.display()

    );

    println!("  {} requests", collection.requests.len());

    if !collection.servers.is_empty() {

        println!("  servers: {}", collection.servers.join(", "));

    }

    if let Some(auth) = &collection.auth {

        println!(

            "  oauth2 client-credentials: {} (set client id/secret with A in the TUI)",

            auth.token_url

        );

    }

    Ok(())

}

/// Create an empty collection and drop straight into the TUI to fill it in.

/// The existence check is on the slug path rather than via

/// `store::resolve_collection`, which bails by contract on a name that doesn't

/// exist yet — and the path check also catches names that collide after

/// slugify, same as `cielago rename`.

async fn cmd_new(name: &str, server: Option<String>) -> Result<()> {

    let path = store::collection_path(name)?;

    if path.exists() {

        bail!(

            "a collection already exists at {} — open it with `cielago open {name:?}` or pick another name",

            path.display()

        );

    }

    let mut collection = Collection::new(name);

    if let Some(url) = server {

        // Trailing slash trimmed to match imported servers, so pasting a URL in

        // the TUI later recognises this one instead of adding a duplicate.

        let url = url.trim().trim_end_matches('/').to_string();

        if !url.is_empty() {

            collection.servers.push(url);

        }

    }

    let path = store::save_collection(&collection)?;

    println!(

        "Created collection \"{}\" -> {}",

        collection.name,

        path.display()

    );

    let mut config = AppConfig::load();

    config.last_collection = Some(collection.name.clone());

    let _ = config.save();

    app::run(collection, path, config).await

}

fn cmd_list(long: bool) -> Result<()> {

    let names = store::list_collections()?;

    if names.is_empty() {

        println!(

            "No collections yet. Import one: cielago import <spec>\n\

             …or start from scratch:      cielago new <name>"

        );

        return Ok(());

    }

    let last = AppConfig::load().last_collection;

    for n in names {

        if !long {

            println!("{n}");

            continue;

        }

        let marker = if last.as_deref() == Some(n.as_str()) {

            "*"

        } else {

            " "

        };

        let path = store::collection_path(&n)?;

        match store::load_collection(&n) {

            Ok(c) => println!(

                "{marker} {n}\n    {} requests, {} server(s){}\n    {}",

                c.requests.len(),

                c.servers.len(),

                if c.auth.is_some() { ", oauth2" } else { "" },

                path.display()

            ),

            Err(e) => println!("{marker} {n}\n    unreadable: {e}\n    {}", path.display()),

        }

    }

    Ok(())

}

fn cmd_delete(name: &str, force: bool) -> Result<()> {

    let name = store::resolve_collection(name)?;

    let collection = store::load_collection(&name).ok();

    let path = store::collection_path(&name)?;

    if !force {

        let count = collection

            .as_ref()

            .map(|c| format!(" ({} requests)", c.requests.len()))

            .unwrap_or_default();

        print!("Delete collection \"{name}\"{count}? [y/N] ");

        io::stdout().flush()?;

        let mut answer = String::new();

        io::stdin().read_line(&mut answer)?;

        if !matches!(answer.trim(), "y" | "Y" | "yes" | "Yes") {

            println!("Aborted.");

            return Ok(());

        }

    }

    store::delete_collection(&name)?;

    let mut config = AppConfig::load();

    if config.last_collection.as_deref() == Some(name.as_str()) {

        config.last_collection = None;

        let _ = config.save();

    }

    println!("Deleted \"{name}\" ({})", path.display());

    Ok(())

}

/// Edit the collection JSON in `$EDITOR`. The edit happens on a temp copy so a

/// file that no longer parses never replaces the saved one; a `name` changed in

/// the editor moves the file, same as `cielago rename`.

fn cmd_edit(name: &str) -> Result<()> {

    let name = store::resolve_collection(name)?;

    let path = store::collection_path(&name)?;

    let original =

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

    let mut tmp = std::env::temp_dir();

    tmp.push(format!(

        "cielago-{}-{}.json",

        store::slugify(&name),

        std::process::id()

    ));

    fs::write(&tmp, &original)?;

    let editor = AppConfig::load().editor_cmd();

    let mut parts = editor.split_whitespace();

    let program = parts.next().unwrap_or("vi");

    let status = ProcessCommand::new(program)

        .args(parts)

        .arg(&tmp)

        .status()

        .with_context(|| format!("launching editor {editor:?}"))?;

    if !status.success() {

        let _ = fs::remove_file(&tmp);

        bail!("editor exited with {status}; collection left unchanged");

    }

    let edited = fs::read_to_string(&tmp)?;

    if edited == original {

        let _ = fs::remove_file(&tmp);

        println!("No changes.");

        return Ok(());

    }

    let collection: Collection = match serde_json::from_str(&edited) {

        Ok(c) => c,

        Err(e) => bail!(

            "edited JSON is not a valid collection: {e}\n\nYour edits are kept at {}; the saved collection is unchanged.",

            tmp.display()

        ),

    };

    let new_path = store::collection_path(&collection.name)?;

    if new_path != path && new_path.exists() {

        bail!(

            "renaming to {:?} would overwrite the collection at {}.\n\nYour edits are kept at {}; the saved collection is unchanged.",

            collection.name,

            new_path.display(),

            tmp.display()

        );

    }

    let _ = fs::remove_file(&tmp);

    store::save_collection(&collection)?;

    if new_path != path {

        fs::remove_file(&path).ok();

        update_last_collection(&name, &collection.name);

        println!(

            "Saved \"{}\" -> {} (was \"{name}\")",

            collection.name,

            new_path.display()

        );

    } else {

        println!("Saved \"{}\" -> {}", collection.name, new_path.display());

    }

    Ok(())

}

fn cmd_rename(name: &str, new_name: &str) -> Result<()> {

    let name = store::resolve_collection(name)?;

    let mut collection = store::load_collection(&name)?;

    let old_path = store::collection_path(&name)?;

    let new_path = store::collection_path(new_name)?;

    if new_path != old_path && new_path.exists() {

        bail!(

            "a collection already exists at {} — pick another name",

            new_path.display()

        );

    }

    collection.name = new_name.to_string();

    store::save_collection(&collection)?;

    if new_path != old_path {

        fs::remove_file(&old_path).ok();

    }

    update_last_collection(&name, new_name);

    println!(

        "Renamed \"{name}\" -> \"{new_name}\" ({})",

        new_path.display()

    );

    Ok(())

}

/// Refresh a collection's routes from a spec without touching the rest of it.

/// Only `requests` is replaced (existing routes are overwritten); auth,

/// variables, servers, active server and view state stay as the user left

/// them. `last_request` is cleared because re-import mints new request ids, so

/// the old pointer would dangle.

async fn cmd_update(name: &str, source: &str) -> Result<()> {

    let name = store::resolve_collection(name)?;

    let mut collection = store::load_collection(&name)?;

    let doc = openapi::load_spec(source).await?;

    // Import under the collection's own name so the throwaway result matches;

    // only its `requests` are pulled across.

    let imported = openapi::import_spec(&doc, &collection.name, Some(source.to_string()));

    let before = collection.requests.len();

    let after = imported.requests.len();

    collection.replace_requests_from(imported);

    collection.spec_source = Some(source.to_string());

    let path = store::save_collection(&collection)?;

    println!(

        "Updated collection \"{}\" -> {}",

        collection.name,

        path.display()

    );

    println!("  {before} -> {after} requests");

    Ok(())

}

fn cmd_info(name: &str) -> Result<()> {

    let name = store::resolve_collection(name)?;

    let collection = store::load_collection(&name)?;

    let path = store::collection_path(&name)?;

    println!("{}", collection.name);

    println!("  file:      {}", path.display());

    if let Some(src) = &collection.spec_source {

        println!("  spec:      {src}");

    }

    if collection.servers.is_empty() {

        println!("  servers:   (none)");

    } else {

        for (i, s) in collection.servers.iter().enumerate() {

            let marker = if i == collection.active_server {

                "*"

            } else {

                " "

            };

            println!("  server{marker}   {s}");

        }

    }

    println!("  requests:  {}", collection.requests.len());

    println!("  variables: {}", collection.variables.len());

    match &collection.auth {

        Some(auth) => println!(

            "  auth:      oauth2 client-credentials, token url {} ({} client id)",

            auth.token_url,

            if auth.client_id.is_empty() {

                "no"

            } else {

                "has"

            }

        ),

        None => println!("  auth:      none"),

    }

    let mut groups: BTreeMap<&str, usize> = BTreeMap::new();

    for r in &collection.requests {

        *groups

            .entry(r.tags.first().map(String::as_str).unwrap_or("default"))

            .or_default() += 1;

    }

    if !groups.is_empty() {

        println!("  groups:");

        for (group, count) in groups {

            println!("    {group} ({count})");

        }

    }

    Ok(())

}

fn cmd_path(name: &str) -> Result<()> {

    let name = store::resolve_collection(name)?;

    println!("{}", store::collection_path(&name)?.display());

    Ok(())

}

/// Keep `config.last_collection` pointing at a collection that was renamed.

fn update_last_collection(old: &str, new: &str) {

    let mut config = AppConfig::load();

    if config.last_collection.as_deref() == Some(old) {

        config.last_collection = Some(new.to_string());

        let _ = config.save();

    }

}

async fn cmd_open(name: Option<String>) -> Result<()> {

    let mut config = AppConfig::load();

    let name = match name.or_else(|| config.last_collection.clone()) {

        Some(n) => n,

        None => {

            let names = store::list_collections()?;

            match names.as_slice() {

                [] => bail!(

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

                ),

                [only] => only.clone(),

                many => bail!(

                    "Multiple collections exist; choose one:\n\n  cielago open <name>\n\nAvailable: {}",

                    many.join(", ")

                ),

            }

        }

    };

    let collection =

        store::load_collection(&name).with_context(|| format!("loading collection {name:?}"))?;

    config.last_collection = Some(collection.name.clone());

    let _ = config.save();

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

    app::run(collection, path, config).await

}