colonizer 0.1.0

use clap::{Parser, Subcommand, ValueEnum};
use colonizer::{ColClient, Error, Rank};
use indicatif::{ProgressBar, ProgressStyle};
use serde_json::json;
use std::fs::File;
use std::io::{Read, Write};
use std::path::PathBuf;
use unicode_normalization::UnicodeNormalization;

#[derive(Parser, Debug)]
#[command(name = "colonizer", version, about = "Catalogue of Life helper CLI")]
struct Cli {
    /// Override the dataset key (defaults to latest CoL release)
    #[arg(long)]
    dataset: Option<i32>,

    /// Output JSON instead of tab-separated text
    #[arg(long)]
    json: bool,

    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand, Debug)]
enum Commands {
    /// Print the latest CoL release dataset key
    Latest,
    /// Resolve COL id for a scientific name
    Id {
        /// Scientific name to match (exact)
        name: String,
        /// Optional rank to disambiguate (e.g. SPECIES, GENUS)
        #[arg(long)]
        rank: Option<Rank>,
    },
    /// Download a full CoL package from the static download server
    Download {
        /// Package format: dwca, coldp, or txtree
        #[arg(value_enum)]
        format: DlFormat,
        /// Use latest package instead of matching the selected dataset's month
        #[arg(long)]
        latest: bool,
        /// Specific monthly date (YYYY-MM-DD) to fetch
        #[arg(long)]
        date: Option<String>,
        /// Output file path (defaults to filename from URL)
        #[arg(long)]
        output: Option<PathBuf>,
    },
    /// List usages at a given rank (beware: can be huge!)
    ListRank {
        /// Rank to list (e.g. SPECIES, GENUS, FAMILY)
        rank: Rank,
        /// Maximum number of results to print (default 50)
        #[arg(long, default_value_t = 50)]
        max: usize,
    },
    /// List roots of the tree (e.g., domains)
    Roots {
        /// Maximum number of results to print (default 50)
        #[arg(long, default_value_t = 50)]
        max: usize,
    },
    /// List direct children of a taxon (by id or name)
    Children {
        /// Taxon usage id or exact scientific name
        target: String,
        /// Treat target as an id; otherwise try exact-name resolution
        #[arg(long)]
        by_id: bool,
        /// Optional rank to disambiguate names (e.g., GENUS)
        #[arg(long)]
        rank: Option<Rank>,
        /// Maximum number of results to print (default 50)
        #[arg(long, default_value_t = 50)]
        max: usize,
    },
    /// Show the classification chain for a taxon
    Classify {
        /// Taxon usage id or exact scientific name
        target: String,
        /// Treat target as an id; otherwise try exact-name resolution
        #[arg(long)]
        by_id: bool,
        /// Optional rank to disambiguate names (e.g., SPECIES, GENUS)
        #[arg(long)]
        rank: Option<Rank>,
    },
    /// Suggest name usages for a text query
    Suggest {
        /// Free-text query
        q: String,
        /// Maximum number of suggestions
        #[arg(long, default_value_t = 10)]
        limit: usize,
    },
    /// List vernacular (common) names for a taxon
    Vernacular {
        /// Taxon usage id or exact scientific name
        target: String,
        /// Treat target as an id; otherwise try exact-name resolution
        #[arg(long)]
        by_id: bool,
        /// Optional rank to disambiguate names
        #[arg(long)]
        rank: Option<Rank>,
    },
    /// Pick a random vernacular name for a language via API
    Inspire {
        /// Language code to filter (e.g., fra)
        #[arg(long, default_value = "fra")]
        lang: String,
        /// Only one-word names (no spaces)
        #[arg(long)]
        one_word: bool,
    },
}

fn main() -> Result<(), Error> {
    let cli = Cli::parse();
    let client = match cli.dataset {
        Some(key) => ColClient::with_dataset_key(key)?,
        None => ColClient::from_latest()?,
    };

    match cli.command {
        Commands::Latest => {
            if cli.json {
                println!("{}", json!({"dataset_key": client.dataset_key}));
            } else {
                println!("{}", client.dataset_key);
            }
        }
        Commands::Id { name, rank } => match client.id_for_name(&name, rank)? {
            Some(id) => {
                if cli.json {
                    println!("{}", json!({"id": id}));
                } else {
                    println!("{}", id);
                }
            }
            None => {
                eprintln!("No match found");
                std::process::exit(1);
            }
        },
        Commands::ListRank { rank, max } => {
            let items = client.list_by_rank(rank, Some(max))?;
            if cli.json {
                println!("{}", serde_json::to_string(&items)?);
            } else {
                for it in items {
                    println!(
                        "{}\t{}\t{}",
                        it.id,
                        it.label,
                        it.rank.map(|r| r.to_string()).unwrap_or_default()
                    );
                }
            }
        }
        Commands::Roots { max } => {
            let items = client.roots(Some(max))?;
            if cli.json {
                println!("{}", serde_json::to_string(&items)?);
            } else {
                for it in items {
                    let label = it.name.unwrap_or_default();
                    let rank = it.rank.map(|r| r.to_string()).unwrap_or_default();
                    println!("{}\t{}\t{}", it.id, label, rank);
                }
            }
        }
        Commands::Download {
            format,
            latest,
            date,
            output,
        } => {
            let url = build_download_url(&client, format, latest, date.as_deref())?;
            let fname = output.unwrap_or_else(|| {
                let seg = url
                    .path_segments()
                    .and_then(|mut s| s.next_back())
                    .unwrap_or("col.zip");
                PathBuf::from(seg)
            });
            let http = reqwest::blocking::Client::builder().build()?;
            let mut resp = http.get(url.clone()).send()?.error_for_status()?;

            let total = resp.content_length();
            let pb = match total {
                Some(len) => {
                    let pb = ProgressBar::new(len);
                    pb.set_style(
                        ProgressStyle::with_template(
                            "{spinner:.green} [{elapsed_precise}] [{bar:40.cyan/blue}] {bytes}/{total_bytes} ({eta})",
                        )
                        .unwrap()
                        .progress_chars("#>-"),
                    );
                    pb
                }
                None => {
                    let pb = ProgressBar::new_spinner();
                    pb.set_style(
                        ProgressStyle::with_template(
                            "{spinner:.green} downloading... [{elapsed_precise}] {bytes}",
                        )
                        .unwrap(),
                    );
                    pb.enable_steady_tick(std::time::Duration::from_millis(100));
                    pb
                }
            };

            let mut file = File::create(&fname)?;
            let mut downloaded: u64 = 0;
            let mut buf = vec![0u8; 64 * 1024];
            loop {
                let n = resp.read(&mut buf)?;
                if n == 0 {
                    break;
                }
                file.write_all(&buf[..n])?;
                downloaded += n as u64;
                pb.set_position(downloaded);
            }
            pb.finish_and_clear();

            if cli.json {
                println!(
                    "{}",
                    json!({"url": url.as_str(), "bytes": downloaded, "path": fname})
                );
            } else {
                eprintln!(
                    "Downloaded {} bytes from {} to {}",
                    downloaded,
                    url,
                    fname.display()
                );
            }
        }
        Commands::Children {
            target,
            by_id,
            rank,
            max,
        } => {
            let id = if by_id {
                target.clone()
            } else {
                resolve_id_or_with_rank(&client, &target, rank)?
            };
            let items = client.children_of(&id, Some(max))?;
            if cli.json {
                println!("{}", serde_json::to_string(&items)?);
            } else {
                for it in items {
                    let label = it.name.unwrap_or_default();
                    let rank = it.rank.map(|r| r.to_string()).unwrap_or_default();
                    println!("{}\t{}\t{}", it.id, label, rank);
                }
            }
        }
        Commands::Classify {
            target,
            by_id,
            rank,
        } => {
            let id = if by_id {
                target.clone()
            } else {
                resolve_id_or_with_rank(&client, &target, rank)?
            };
            let chain = client.classification_of(&id)?;
            if cli.json {
                println!("{}", serde_json::to_string(&chain)?);
            } else {
                for n in chain {
                    let name = n.label.unwrap_or(n.name);
                    println!(
                        "{}\t{}\t{}",
                        n.id,
                        name,
                        n.rank.map(|r| r.to_string()).unwrap_or_default()
                    );
                }
            }
        }
        Commands::Suggest { q, limit } => {
            let items = client.suggest(&q, limit)?;
            if cli.json {
                println!("{}", serde_json::to_string(&items)?);
            } else {
                for it in items {
                    let s = it.suggestion.unwrap_or(it.match_.clone());
                    let rank = it.rank.map(|r| r.to_string()).unwrap_or_default();
                    let status = it.status.unwrap_or_default();
                    println!("{}\t{}\t{}\t{}", it.usage_id, s, rank, status);
                }
            }
        }
        Commands::Vernacular {
            target,
            by_id,
            rank,
        } => {
            let id = if by_id {
                target.clone()
            } else {
                resolve_id_or_with_rank(&client, &target, rank)?
            };
            let names = client.vernacular_of(&id)?;
            if cli.json {
                println!("{}", serde_json::to_string(&names)?);
            } else {
                for v in names {
                    println!("{}\t{}", v.name, v.language.unwrap_or_default());
                }
            }
        }
        Commands::Inspire { lang, one_word } => {
            // Use API to find a random vernacular name for the language
            let tries = if one_word { 64 } else { 24 };
            match client.random_vernacular_by_language_filtered(&lang, one_word, tries)? {
                Some(v) => {
                    let usage = client.taxon(&v.taxon_id)?;
                    let sci = usage
                        .name
                        .and_then(|n| n.scientificName)
                        .unwrap_or_default();
                    let hyph = hyphenize_and_sanitize(&v.name);
                    let link = format!("https://www.catalogueoflife.org/data/taxon/{}", v.taxon_id);
                    let wiki_lang = wiki_lang_from_col(&lang);
                    let wiki = client.wikipedia_summary(&sci, wiki_lang).ok().flatten();
                    if cli.json {
                        let mut obj = serde_json::json!({
                            "lang": lang,
                            "vernacularName": v.name,
                            "vernacularHyphenized": hyph,
                            "taxonID": v.taxon_id,
                            "scientificName": sci,
                            "link": link,
                            "oneWord": one_word,
                        });
                        if let Some(info) = wiki {
                            let m = obj.as_object_mut().unwrap();
                            m.insert("wikipediaSummary".to_string(), serde_json::Value::String(info.extract));
                            m.insert("wikipediaLang".to_string(), serde_json::Value::String(info.lang));
                            if !info.wikipedia_url.is_empty() {
                                m.insert("wikipediaUrl".to_string(), serde_json::Value::String(info.wikipedia_url));
                            }
                            if let Some(url) = info.wikidata_url { m.insert("wikidataUrl".to_string(), serde_json::Value::String(url)); }
                        }
                        println!("{}", obj);
                    } else {
                        if let Some(info) = wiki {
                            if !info.wikipedia_url.is_empty() {
                                if let Some(wd) = info.wikidata_url {
                                    println!(
                                        "{}\t{}\t{}\t{}\n[{} wiki] {}\n{}\n{}",
                                        hyph, v.taxon_id, sci, link,
                                        info.lang, info.extract,
                                        info.wikipedia_url,
                                        wd
                                    );
                                } else {
                                    println!(
                                        "{}\t{}\t{}\t{}\n[{} wiki] {}\n{}",
                                        hyph, v.taxon_id, sci, link,
                                        info.lang, info.extract,
                                        info.wikipedia_url
                                    );
                                }
                            } else {
                                println!("{}\t{}\t{}\t{}\n[{} wiki] {}", hyph, v.taxon_id, sci, link, info.lang, info.extract);
                            }
                        } else {
                            println!("{}\t{}\t{}\t{}", hyph, v.taxon_id, sci, link);
                        }
                    }
                }
                None => {
                    eprintln!("No matching vernacular found (lang='{}', one_word={}).", lang, one_word);
                    std::process::exit(1);
                }
            }
        }
    }

    Ok(())
}

fn resolve_id_or_with_rank(
    client: &ColClient,
    target: &str,
    rank: Option<Rank>,
) -> Result<String, Error> {
    if let Some(id) = client.id_for_name(target, rank)? {
        return Ok(id);
    }
    Ok(target.to_string())
}

#[derive(Copy, Clone, Debug, ValueEnum)]
enum DlFormat {
    Dwca,
    Coldp,
    Txtree,
}

impl DlFormat {
    fn suffix(self) -> &'static str {
        match self {
            DlFormat::Dwca => "dwca",
            DlFormat::Coldp => "coldp",
            DlFormat::Txtree => "txtree",
        }
    }
}

fn build_download_url(
    client: &ColClient,
    fmt: DlFormat,
    latest: bool,
    date: Option<&str>,
) -> Result<reqwest::Url, Error> {
    let base = reqwest::Url::parse("https://download.checklistbank.org")?;
    let suffix = fmt.suffix();
    if let Some(d) = date {
        return Ok(base.join(&format!("/col/monthly/{}_{}.zip", d, suffix))?);
    }
    if latest {
        return Ok(base.join(&format!("/col/latest_{}.zip", suffix))?);
    }
    // Default: use the selected dataset's created date
    let ds = client.dataset_meta()?;
    let created = ds.created.unwrap_or_default();
    if created.len() >= 10 {
        let date = &created[..10];
        Ok(base.join(&format!("/col/monthly/{}_{}.zip", date, suffix))?)
    } else {
        // Fallback to latest if created is missing or malformed
        Ok(base.join(&format!("/col/latest_{}.zip", suffix))?)
    }
}

fn hyphenize_and_sanitize(s: &str) -> String {
    let t = s.trim();
    if t.is_empty() {
        return String::new();
    }
    // Replace whitespace with hyphens and lowercase
    // Remove accents and non-alphanumeric characters except hyphens
    // e.g. "Éléphant d'Afrique" -> "elephant-d-afrique"
    t.split_whitespace()
        .collect::<Vec<_>>()
        .join("-")
        .to_lowercase()
        .nfd() // decompose accents
        .filter(|c| c.is_ascii_alphanumeric() || *c == '-') // keep only alnum and hyphen
        .collect()
}

fn wiki_lang_from_col(lang3: &str) -> &str {
    match lang3.to_ascii_lowercase().as_str() {
        "eng" => "en",
        "fra" | "fre" => "fr",
        "spa" => "es",
        "deu" | "ger" => "de",
        "ita" => "it",
        "por" => "pt",
        "nld" | "dut" => "nl",
        "rus" => "ru",
        "zho" | "chi" => "zh",
        "jpn" => "ja",
        "kor" => "ko",
        "pol" => "pl",
        "ara" => "ar",
        "heb" => "he",
        "ell" | "gre" => "el",
        "tur" => "tr",
        "ces" | "cze" => "cs",
        "ukr" => "uk",
        "swe" => "sv",
        "dan" => "da",
        "nor" => "no",
        "fin" => "fi",
        "ron" | "rum" => "ro",
        "hun" => "hu",
        "bul" => "bg",
        "slv" => "sl",
        "hrv" => "hr",
        "vie" => "vi",
        "tha" => "th",
        "ind" => "id",
        "msa" | "may" => "ms",
        "fas" | "per" => "fa",
        "urd" => "ur",
        "tam" => "ta",
        "tel" => "te",
        "mar" => "mr",
        "guj" => "gu",
        _ => "en",
    }
}