//! `oh`: OxygenHub from the command line, as `gh` is for GitHub. It talks

//! to the hub's JSON API (hub spec §12) as the checkout's remote does:

//! same hub, same token, same CA.

mod client;

mod target;

mod ui;

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

use clap::{Parser, Subcommand};

use client::Client;

use hub_api::{FlowLogLine, FlowRun, Issue, IssueStateChange, NewComment, NewIssue, NewProposal, NewRelease, Proposal, Release};

use std::time::Duration;

use target::{Choice, Config, Host, Target};

#[derive(Parser)]

#[command(name = "oh", version = env!("OXY_VERSION_LONG"), about = "OxygenHub from the command line: issues, proposals, Flow runs and releases")]

struct Cli {

    /// The repository, when not inside an Oxygen checkout

    #[arg(long, short = 'R', global = true, value_name = "OWNER/NAME")]

    repo: Option<String>,

    /// The hub, with --repo or outside a checkout (default: OH_HUB or the one `oh auth login` saved)

    #[arg(long, global = true, value_name = "URL")]

    hub: Option<String>,

    /// Which of the checkout's remotes to use (default: origin, or the only one)

    #[arg(long, global = true)]

    remote: Option<String>,

    /// Machine-readable output: the API's JSON, unchanged

    #[arg(long, global = true)]

    json: bool,

    /// Plain output: no colour or glyphs (also NO_COLOR, or when not a terminal)

    #[arg(long, global = true)]

    plain: bool,

    #[command(subcommand)]

    cmd: Cmd,

}

#[derive(Subcommand)]

enum Cmd {

    /// Sign in to a hub, or show who you are signed in as

    Auth {

        #[command(subcommand)]

        cmd: AuthCmd,

    },

    /// The repository

    Repo {

        #[command(subcommand)]

        cmd: RepoCmd,

    },

    /// Issues

    Issue {

        #[command(subcommand)]

        cmd: IssueCmd,

    },

    /// Proposals (pull requests)

    Proposal {

        #[command(subcommand)]

        cmd: ProposalCmd,

    },

    /// OxygenFlow runs

    Run {

        #[command(subcommand)]

        cmd: RunCmd,

    },

    /// Releases

    Release {

        #[command(subcommand)]

        cmd: ReleaseCmd,

    },

    /// Call the API directly: `oh api /repos/OWNER/NAME/issues`

    Api {

        /// A path under /api/v1

        path: String,

        /// The method

        #[arg(long, short = 'X', default_value = "GET")]

        method: String,

        /// A JSON body

        #[arg(long, short = 'd')]

        data: Option<String>,

    },

}

#[derive(Subcommand)]

enum AuthCmd {

    /// Sign in to a hub and make it the default: approve a code on the web

    /// (device sign-in), or give a token

    Login {

        /// The hub, e.g. https://oxygenhub.io

        #[arg(long = "with-hub", value_name = "URL")]

        url: String,

        /// An API token from the hub's Settings → Tokens, instead of

        /// approving a code ("-" reads it from stdin)

        #[arg(long)]

        token: Option<String>,

        /// The hub's CA certificate, when self-signed

        #[arg(long)]

        ca: Option<std::path::PathBuf>,

    },

    /// Who the token in use belongs to

    Status,

}

#[derive(Subcommand)]

enum RepoCmd {

    /// Name, description, visibility and default bookmark

    View,

}

#[derive(Subcommand)]

enum IssueCmd {

    /// Open issues (or --state closed|all)

    List {

        #[arg(long, default_value = "open")]

        state: String,

    },

    /// One issue with its comments

    View { number: i64 },

    /// Open an issue

    Create {

        #[arg(long, short)]

        title: String,

        #[arg(long, short)]

        body: Option<String>,

        /// Read the body from a file ("-" for stdin)

        #[arg(long, short = 'F')]

        body_file: Option<String>,

        /// A label (repeatable)

        #[arg(long, short)]

        label: Vec<String>,

    },

    /// Close an issue

    Close {

        number: i64,

        /// `completed` or `not_planned`

        #[arg(long, default_value = "completed")]

        reason: String,

    },

    /// Reopen an issue

    Reopen { number: i64 },

    /// Comment on an issue

    Comment {

        number: i64,

        #[arg(long, short)]

        body: String,

    },

}

#[derive(Subcommand)]

enum ProposalCmd {

    /// Open proposals (or --state draft|landed|closed|all)

    List {

        #[arg(long, default_value = "open")]

        state: String,

    },

    /// One proposal: its changes, approvals and whether it can land

    View { number: i64 },

    /// Propose a bookmark's changes for another bookmark

    Create {

        #[arg(long, short)]

        title: String,

        #[arg(long, short)]

        body: Option<String>,

        /// The bookmark with the changes (or OWNER/NAME:BOOKMARK of a fork)

        #[arg(long)]

        from: String,

        /// The bookmark to land them on (default: the repository's default bookmark)

        #[arg(long)]

        into: Option<String>,

        #[arg(long)]

        draft: bool,

    },

    /// The checks on a proposal's projected state

    Checks { number: i64 },

    /// Land a proposal on its target, as the page's Land button does

    Land { number: i64 },

}

#[derive(Subcommand)]

enum RunCmd {

    /// Recent runs, newest first

    List {

        #[arg(long, default_value_t = 20)]

        limit: i64,

    },

    /// A run and its jobs

    View { number: i64 },

    /// Run the pipeline without a push: a bookmark's current state (default: the default bookmark), or one change's

    Start {

        #[arg(long)]

        bookmark: Option<String>,

        /// A change's full hash

        #[arg(long, conflicts_with = "bookmark")]

        change: Option<String>,

        /// Wait for the run and exit 1 unless it passes

        #[arg(long)]

        watch: bool,

    },

    /// Follow a run until it finishes; exit 1 unless it passes

    Watch { number: i64 },

    /// A job's log

    Log { number: i64, job: String },

    /// Run a finished run's state again

    Rerun { number: i64 },

}

#[derive(Subcommand)]

enum ReleaseCmd {

    /// Releases, newest first

    List,

    /// Create a release on an existing tag

    Create {

        tag: String,

        #[arg(long, short)]

        title: Option<String>,

        /// Notes in Markdown (default: generated from the changes since the previous release)

        #[arg(long, short)]

        notes: Option<String>,

        #[arg(long)]

        prerelease: bool,

    },

    /// Attach files to a release

    Upload { tag: String, files: Vec<std::path::PathBuf> },

    /// The release's trust report: signatures, builds, receipts and audit

    Trust { tag: String },

}

fn main() {

    let cli = Cli::parse();

    ui::init(cli.plain);

    match run(cli) {

        Ok(code) => std::process::exit(code),

        Err(e) => {

            eprintln!("{} {e:#}", ui::bad("error:"));

            std::process::exit(2);

        }

    }

}

fn enc(s: &str) -> String {

    let mut out = String::new();

    for b in s.bytes() {

        if b.is_ascii_alphanumeric() || b"-._~".contains(&b) {

            out.push(b as char);

        } else {

            out.push_str(&format!("%{b:02X}"));

        }

    }

    out

}

fn run(cli: Cli) -> Result<i32> {

    let cfg = Config::load()?;

    if let Cmd::Auth { cmd: AuthCmd::Login { url, token, ca } } = &cli.cmd {

        return login(cfg, url, token.clone(), ca.clone());

    }

    let here = std::env::current_dir()?;

    let t = target::resolve(&Choice { repo: cli.repo.as_deref(), hub: cli.hub.as_deref(), remote: cli.remote.as_deref() }, &here, &cfg)?;

    let c = Client::new(&t)?;

    let json = cli.json;

    match cli.cmd {

        Cmd::Auth { cmd: AuthCmd::Status } => {

            let me: serde_json::Value = c.get("/user")?;

            if json {

                println!("{me}");

            } else {

                println!("{} signed in to {} as {}", ui::ok("✔"), t.hub, ui::strong(me["username"].as_str().unwrap_or("?")));

            }

            Ok(0)

        }

        Cmd::Auth { .. } => unreachable!(),

        Cmd::Api { path, method, data } => {

            let path = if path.starts_with('/') { path } else { format!("/{path}") };

            let text = match data {

                Some(d) => c.send_text(

                    &method.to_uppercase(),

                    &path,

                    &serde_json::from_str::<serde_json::Value>(&d).context("--data is not JSON")?,

                )?,

                None => c.get_text(&path)?,

            };

            println!("{text}");

            Ok(0)

        }

        Cmd::Repo { cmd: RepoCmd::View } => {

            let path = t.repo_path()?;

            if json {

                println!("{}", c.get_text(&path)?);

                return Ok(0);

            }

            let r: serde_json::Value = c.get(&path)?;

            println!("{} {}", ui::strong(&format!("{}/{}", t.owner, t.name)), ui::dim(r["visibility"].as_str().unwrap_or("")));

            if let Some(d) = r["description"].as_str().filter(|d| !d.is_empty()) {

                println!("{d}");

            }

            println!("{}", ui::kv("default bookmark", r["default_bookmark"].as_str().unwrap_or("")));

            println!("{}", ui::kv("clone", &format!("oxy clone {}/{}/{}", t.hub, t.owner, t.name)));

            Ok(0)

        }

        Cmd::Issue { cmd } => issue(&c, &t, cmd, json),

        Cmd::Proposal { cmd } => proposal(&c, &t, cmd, json),

        Cmd::Run { cmd } => flow(&c, &t, cmd, json),

        Cmd::Release { cmd } => release(&c, &t, cmd, json),

    }

}

fn login(mut cfg: Config, url: &str, token: Option<String>, ca: Option<std::path::PathBuf>) -> Result<i32> {

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

    let token = match token.as_deref() {

        Some("-") => {

            eprintln!("Paste a token from {hub}/settings/tokens, then press Enter:");

            let mut line = String::new();

            std::io::stdin().read_line(&mut line)?;

            line.trim().to_string()

        }

        Some(t) => t.to_string(),

        None => device_sign_in(&hub, ca.clone())?,

    };

    if token.is_empty() {

        bail!("no token given");

    }

    let t = Target { hub: hub.clone(), token: Some(token.clone()), ca: ca.clone(), owner: String::new(), name: String::new() };

    let me: serde_json::Value = Client::new(&t)?.get("/user").context("checking the token")?;

    cfg.hosts.insert(hub.clone(), Host { token, ca });

    cfg.default_hub = Some(hub.clone());

    cfg.save()?;

    println!("{} signed in to {hub} as {}", ui::ok("✔"), ui::strong(me["username"].as_str().unwrap_or("?")));

    Ok(0)

}

/// Device sign-in (oxygenhub#67): the hub gives a code, the user approves

/// it on the web, and the token arrives here.

fn device_sign_in(hub: &str, ca: Option<std::path::PathBuf>) -> Result<String> {

    let t = Target { hub: hub.to_string(), token: None, ca, owner: String::new(), name: String::new() };

    let c = Client::new(&t)?;

    let host = std::fs::read_to_string("/etc/hostname")

        .ok()

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

        .map(|h| h.trim().to_string())

        .filter(|h| !h.is_empty());

    let client = match host {

        Some(h) => format!("oh on {h}"),

        None => "oh".to_string(),

    };

    let scopes = ["repo:read", "repo:write", "proposals:write", "issues:write", "user:read"];

    let (code, body) = c.post_raw("/device/code", &serde_json::json!({ "client": client, "scopes": scopes }))?;

    let v: serde_json::Value = serde_json::from_str(&body).context("the hub's answer to a device code request")?;

    if code != 200 {

        bail!("{hub} cannot sign in a device: {}", v["error_description"].as_str().or(v["detail"].as_str()).unwrap_or(&body));

    }

    let device = v["device_code"].as_str().context("no device code")?.to_string();

    let user = v["user_code"].as_str().unwrap_or("?");

    let url = v["verification_uri_complete"].as_str().or(v["verification_uri"].as_str()).unwrap_or(hub);

    let mut interval = v["interval"].as_u64().unwrap_or(5).max(1);

    let deadline = std::time::Instant::now() + std::time::Duration::from_secs(v["expires_in"].as_u64().unwrap_or(900));

    eprintln!("Open {} and approve the code {}", ui::strong(url), ui::strong(user));

    eprintln!("{}", ui::dim("Waiting for approval (Ctrl-C to give up)…"));

    loop {

        std::thread::sleep(std::time::Duration::from_secs(interval));

        if std::time::Instant::now() > deadline {

            bail!("the code expired before it was approved; run oh auth login again");

        }

        let (code, body) = c.post_raw("/device/token", &serde_json::json!({ "device_code": device }))?;

        let v: serde_json::Value = serde_json::from_str(&body).unwrap_or_default();

        if code == 200 {

            return v["access_token"].as_str().map(String::from).context("no token in the hub's answer");

        }

        match v["error"].as_str() {

            Some("authorization_pending") => {}

            Some("slow_down") => interval += 5,

            Some("access_denied") => bail!("the sign-in was denied on the web"),

            Some("expired_token") => bail!("the code expired before it was approved; run oh auth login again"),

            _ => bail!("signing in: HTTP {code}: {body}"),

        }

    }

}

fn body_of(body: Option<String>, file: Option<String>) -> Result<String> {

    match (body, file) {

        (Some(b), _) => Ok(b),

        (None, Some(f)) if f == "-" => {

            let mut s = String::new();

            std::io::Read::read_to_string(&mut std::io::stdin(), &mut s)?;

            Ok(s)

        }

        (None, Some(f)) => std::fs::read_to_string(&f).with_context(|| format!("read {f}")),

        (None, None) => Ok(String::new()),

    }

}

fn issue_line(i: &Issue) -> String {

    let glyph = if i.state == "open" { ui::ok("●") } else { ui::dim("○") };

    let labels: Vec<String> = i.labels.iter().map(|l| format!("[{}]", l.name)).collect();

    format!(

        "{glyph} {} {}{}{}",

        ui::dim(&format!("#{}", i.number)),

        i.title,

        if labels.is_empty() { String::new() } else { format!(" {}", ui::dim(&labels.join(" "))) },

        ui::dim(&format!(" · {} · {}", i.author, ui::ago(i.updated_ms)))

    )

}

fn issue(c: &Client, t: &Target, cmd: IssueCmd, json: bool) -> Result<i32> {

    let base = t.repo_path()?;

    match cmd {

        IssueCmd::List { state } => {

            let path = format!("{base}/issues?state={}", enc(&state));

            if json {

                println!("{}", c.get_text(&path)?);

                return Ok(0);

            }

            let list: Vec<Issue> = c.get(&path)?;

            if list.is_empty() {

                println!("{}", ui::dim(&format!("No {state} issues.")));

            }

            for i in &list {

                println!("{}", issue_line(i));

            }

        }

        IssueCmd::View { number } => {

            let path = format!("{base}/issues/{number}");

            if json {

                println!("{}", c.get_text(&path)?);

                return Ok(0);

            }

            let i: Issue = c.get(&path)?;

            println!("{}", issue_line(&i));

            if !i.body.trim().is_empty() {

                println!("\n{}\n", i.body.trim_end());

            }

            let comments: Vec<hub_api::Comment> = c.get(&format!("{path}/comments"))?;

            for cm in comments {

                println!("{} {}\n{}\n", ui::strong(&cm.author), ui::dim(&ui::ago(cm.created_ms)), cm.body.trim_end());

            }

            println!("{}", ui::dim(&i.url));

        }

        IssueCmd::Create { title, body, body_file, label } => {

            let new = NewIssue { title, body: body_of(body, body_file)?, labels: label, assignees: vec![], milestone: None };

            let i: Issue = c.send("POST", &format!("{base}/issues"), &new)?;

            if json {

                println!("{}", serde_json::to_string(&i)?);

            } else {

                println!("{} opened #{} {}", ui::ok("✔"), i.number, ui::dim(&i.url));

            }

        }

        IssueCmd::Close { number, reason } => {

            let i: Issue = c.send("POST", &format!("{base}/issues/{number}"), &IssueStateChange { state: "closed".into(), reason })?;

            println!("{} closed #{} {}", ui::ok("✔"), i.number, i.title);

        }

        IssueCmd::Reopen { number } => {

            let i: Issue =

                c.send("POST", &format!("{base}/issues/{number}"), &IssueStateChange { state: "open".into(), reason: String::new() })?;

            println!("{} reopened #{} {}", ui::ok("✔"), i.number, i.title);

        }

        IssueCmd::Comment { number, body } => {

            c.send_text("POST", &format!("{base}/issues/{number}/comments"), &NewComment { body, path: None, line: None })?;

            println!("{} commented on #{number}", ui::ok("✔"));

        }

    }

    Ok(0)

}

fn source_name(s: &hub_api::ProposalSource) -> String {

    match s {

        hub_api::ProposalSource::Bookmark { bookmark } => bookmark.clone(),