version = "1.0.6"

checksum = "8901269c6307e8d93993578286ac0edf7f195079ffff5ebdeea6a59ffb7e36bc"

const COMMANDS: &[Help] = &[

    crate::commands::auth::HELP,

    crate::commands::block::HELP,

    crate::commands::checkout::HELP,

    crate::commands::clone::HELP,

    crate::commands::config::HELP,

    crate::commands::fork::HELP,

    crate::commands::help::HELP,

    crate::commands::id::HELP,

    crate::commands::init::HELP,

    crate::commands::inbox::HELP,

    crate::commands::inspect::HELP,

    crate::commands::issue::HELP,

    crate::commands::ls::HELP,

    crate::commands::node::HELP,

    crate::commands::patch::HELP,

    crate::commands::path::HELP,

    crate::commands::clean::HELP,

    crate::commands::rad_self::HELP,

    crate::commands::seed::HELP,

    crate::commands::follow::HELP,

    crate::commands::unblock::HELP,

    crate::commands::unfollow::HELP,

    crate::commands::unseed::HELP,

    crate::commands::remote::HELP,

    crate::commands::stats::HELP,

    crate::commands::sync::HELP,

            term::format::bold(format!("{:-12}", help.name)),

            term::format::dim(help.description)

use std::collections::BTreeSet;

use std::ffi::OsString;

use std::str::FromStr;

use anyhow::{anyhow, Context as _};

use radicle::cob::common::{Label, Reaction};

use radicle::cob::{issue, thread, Title};

use radicle::git::Oid;

use radicle::prelude::{Did, RepoId};

use radicle::storage::{ReadRepository, WriteRepository, WriteStorage};

use crate::terminal::args::{Args, Error, Help};

use crate::terminal::patch::Message;

pub const HELP: Help = Help {

    name: "issue",

    description: "Manage issues",

    version: env!("RADICLE_VERSION"),

    usage: r#"

Usage

    rad issue [<option>...]

    rad issue delete <issue-id> [<option>...]

    rad issue edit <issue-id> [--title <title>] [--description <text>] [<option>...]

    rad issue list [--assigned <did>] [--all | --closed | --open | --solved] [<option>...]

    rad issue open [--title <title>] [--description <text>] [--label <label>] [<option>...]

    rad issue react <issue-id> [--emoji <char>] [--to <comment>] [<option>...]

    rad issue assign <issue-id> [--add <did>] [--delete <did>] [<option>...]

    rad issue label <issue-id> [--add <label>] [--delete <label>] [<option>...]

    rad issue comment <issue-id> [--message <message>] [--reply-to <comment-id>] [--edit <comment-id>] [<option>...]

    rad issue show <issue-id> [<option>...]

    rad issue state <issue-id> [--closed | --open | --solved] [<option>...]

    rad issue cache [<issue-id>] [--storage] [<option>...]

Assign options

    -a, --add    <did>     Add an assignee to the issue (may be specified multiple times).

    -d, --delete <did>     Delete an assignee from the issue (may be specified multiple times).

    Note: --add takes precedence over --delete

Label options

    -a, --add    <label>   Add a label to the issue (may be specified multiple times).

    -d, --delete <label>   Delete a label from the issue (may be specified multiple times).

    Note: --add takes precedence over --delete

Show options

    -v, --verbose          Show additional information about the issue

Options

        --repo <rid>       Operate on the given repository (default: cwd)

        --no-announce      Don't announce issue to peers

        --header           Show only the issue header, hiding the comments

    -q, --quiet            Don't print anything

        --help             Print help

"#,

};

#[derive(Default, Debug, PartialEq, Eq)]

pub enum OperationName {

    Assign,

    Edit,

    Open,

    Comment,

    Delete,

    Label,

    #[default]

    List,

    React,

    Show,

    State,

    Cache,

}

/// Command line Peer argument.

#[derive(Default, Debug, PartialEq, Eq)]

pub enum Assigned {

    #[default]

    Me,

    Peer(Did),

}

#[derive(Debug, PartialEq, Eq)]

pub enum Operation {

    Edit {

        id: Rev,

        title: Option<Title>,

        description: Option<String>,

    },

    Open {

        title: Option<Title>,

        description: Option<String>,

        labels: Vec<Label>,

        assignees: Vec<Did>,

    },

    Show {

        id: Rev,

        format: Format,

        verbose: bool,

    },

    CommentEdit {

        id: Rev,

        comment_id: Rev,

        message: Message,

    },

    Comment {

        id: Rev,

        message: Message,

        reply_to: Option<Rev>,

    },

    State {

        id: Rev,

        state: State,

    },

    Delete {

        id: Rev,

    },

    React {

        id: Rev,

        reaction: Option<Reaction>,

        comment_id: Option<thread::CommentId>,

    },

    Assign {

        id: Rev,

        opts: AssignOptions,

    },

    Label {

        id: Rev,

        opts: LabelOptions,

    },

    List {

        assigned: Option<Assigned>,

        state: Option<State>,

    },

    Cache {

        id: Option<Rev>,

        storage: bool,

    },

}

#[derive(Debug, Default, PartialEq, Eq)]

pub struct AssignOptions {

    pub add: BTreeSet<Did>,

    pub delete: BTreeSet<Did>,

}

#[derive(Debug, Default, PartialEq, Eq)]

pub struct LabelOptions {

    pub add: BTreeSet<Label>,

    pub delete: BTreeSet<Label>,

}

#[derive(Debug)]

pub struct Options {

    pub op: Operation,

    pub repo: Option<RepoId>,

    pub announce: bool,

    pub quiet: bool,

}

impl Args for Options {

    fn from_args(args: Vec<OsString>) -> anyhow::Result<(Self, Vec<OsString>)> {

        use lexopt::prelude::*;

        let mut parser = lexopt::Parser::from_args(args);

        let mut op: Option<OperationName> = None;

        let mut id: Option<Rev> = None;

        let mut assigned: Option<Assigned> = None;

        let mut title: Option<Title> = None;

        let mut reaction: Option<Reaction> = None;

        let mut comment_id: Option<thread::CommentId> = None;

        let mut description: Option<String> = None;

        let mut state: Option<State> = Some(State::Open);

        let mut labels = Vec::new();

        let mut assignees = Vec::new();

        let mut format = Format::default();

        let mut message = Message::default();

        let mut reply_to = None;

        let mut edit_comment = None;

        let mut announce = true;

        let mut quiet = false;

        let mut verbose = false;

        let mut assign_opts = AssignOptions::default();

        let mut label_opts = LabelOptions::default();

        let mut repo = None;

        let mut cache_storage = false;

        while let Some(arg) = parser.next()? {

            match arg {

                Long("help") | Short('h') => {

                    return Err(Error::Help.into());

                }

                // List options.

                Long("all") if op.is_none() || op == Some(OperationName::List) => {

                    state = None;

                }

                Long("closed") if op.is_none() || op == Some(OperationName::List) => {

                    state = Some(State::Closed {

                        reason: CloseReason::Other,

                    });

                }

                Long("open") if op.is_none() || op == Some(OperationName::List) => {

                    state = Some(State::Open);

                }

                Long("solved") if op.is_none() || op == Some(OperationName::List) => {

                    state = Some(State::Closed {

                        reason: CloseReason::Solved,

                    });

                }

                // Open/Edit options.

                Long("title")

                    if op == Some(OperationName::Open) || op == Some(OperationName::Edit) =>

                {

                    let val = parser.value()?;

                    title = Some(term::args::string(&val).try_into()?);

                }

                Long("description")

                    if op == Some(OperationName::Open) || op == Some(OperationName::Edit) =>

                {

                    description = Some(parser.value()?.to_string_lossy().into());

                }

                Short('l') | Long("label") if matches!(op, Some(OperationName::Open)) => {

                    let val = parser.value()?;

                    let name = term::args::string(&val);

                    let label = Label::new(name)?;

                    labels.push(label);

                }

                Long("assign") if op == Some(OperationName::Open) => {

                    let val = parser.value()?;

                    let did = term::args::did(&val)?;

                    assignees.push(did);

                }

                // State options.

                Long("closed") if op == Some(OperationName::State) => {

                    state = Some(State::Closed {

                        reason: CloseReason::Other,

                    });

                }

                Long("open") if op == Some(OperationName::State) => {

                    state = Some(State::Open);

                }

                Long("solved") if op == Some(OperationName::State) => {

                    state = Some(State::Closed {

                        reason: CloseReason::Solved,

                    });

                }

                // React options.

                Long("emoji") if op == Some(OperationName::React) => {

                    if let Some(emoji) = parser.value()?.to_str() {

                        reaction =

                            Some(Reaction::from_str(emoji).map_err(|_| anyhow!("invalid emoji"))?);

                    }

                }

                Long("to") if op == Some(OperationName::React) => {

                    let oid: String = parser.value()?.to_string_lossy().into();

                    comment_id = Some(oid.parse()?);

                }

                // Show options.

                Long("format") if op == Some(OperationName::Show) => {

                    let val = parser.value()?;

                    let val = term::args::string(&val);

                    match val.as_str() {

                        "header" => format = Format::Header,

                        "full" => format = Format::Full,

                        _ => anyhow::bail!("unknown format '{val}'"),

                    }

                }

                Long("verbose") | Short('v') if op == Some(OperationName::Show) => {

                    verbose = true;

                }

                // Comment options.

                Long("message") | Short('m') if op == Some(OperationName::Comment) => {

                    let val = parser.value()?;

                    let txt = term::args::string(&val);

                    message.append(&txt);

                }

                Long("reply-to") if op == Some(OperationName::Comment) => {

                    let val = parser.value()?;

                    let rev = term::args::rev(&val)?;

                    reply_to = Some(rev);

                }

                Long("edit") if op == Some(OperationName::Comment) => {

                    let val = parser.value()?;

                    let rev = term::args::rev(&val)?;

                    edit_comment = Some(rev);

                }

                // Assign options

                Short('a') | Long("add") if op == Some(OperationName::Assign) => {

                    assign_opts.add.insert(term::args::did(&parser.value()?)?);

                }

                Short('d') | Long("delete") if op == Some(OperationName::Assign) => {

                    assign_opts

                        .delete

                        .insert(term::args::did(&parser.value()?)?);

                }

                Long("assigned") | Short('a') if assigned.is_none() => {

                    if let Ok(val) = parser.value() {

                        let peer = term::args::did(&val)?;

                        assigned = Some(Assigned::Peer(peer));

                    } else {

                        assigned = Some(Assigned::Me);

                    }

                }

                // Label options

                Short('a') | Long("add") if matches!(op, Some(OperationName::Label)) => {

                    let val = parser.value()?;

                    let name = term::args::string(&val);

                    let label = Label::new(name)?;

                    label_opts.add.insert(label);

                }

                Short('d') | Long("delete") if matches!(op, Some(OperationName::Label)) => {

                    let val = parser.value()?;

                    let name = term::args::string(&val);

                    let label = Label::new(name)?;

                    label_opts.delete.insert(label);

                }

                // Cache options.

                Long("storage") if matches!(op, Some(OperationName::Cache)) => {

                    cache_storage = true;

                }

                // Options.

                Long("no-announce") => {

                    announce = false;

                }

                Long("quiet") | Short('q') => {

                    quiet = true;

                }

                Long("repo") => {

                    let val = parser.value()?;

                    let rid = term::args::rid(&val)?;

                    repo = Some(rid);

                }

                Value(val) if op.is_none() => match val.to_string_lossy().as_ref() {

                    "c" | "comment" => op = Some(OperationName::Comment),

                    "w" | "show" => op = Some(OperationName::Show),

                    "d" | "delete" => op = Some(OperationName::Delete),

                    "e" | "edit" => op = Some(OperationName::Edit),

                    "l" | "list" => op = Some(OperationName::List),

                    "o" | "open" => op = Some(OperationName::Open),

                    "r" | "react" => op = Some(OperationName::React),

                    "s" | "state" => op = Some(OperationName::State),

                    "assign" => op = Some(OperationName::Assign),

                    "label" => op = Some(OperationName::Label),

                    "cache" => op = Some(OperationName::Cache),

                    unknown => anyhow::bail!("unknown operation '{}'", unknown),

                },

                Value(val) if op.is_some() => {

                    let val = term::args::rev(&val)?;

                    id = Some(val);

                }

                _ => {

                    return Err(anyhow!(arg.unexpected()));

                }

            }

        }

        let op = match op.unwrap_or_default() {

            OperationName::Edit => Operation::Edit {

                id: id.ok_or_else(|| anyhow!("an issue must be provided"))?,

                title,

                description,

            },

            OperationName::Open => Operation::Open {

                title,

                description,

                labels,

                assignees,

            },

            OperationName::Comment => match (reply_to, edit_comment) {

                (None, None) => Operation::Comment {

                    id: id.ok_or_else(|| anyhow!("an issue must be provided"))?,

                    message,

                    reply_to: None,

                },

                (None, Some(comment_id)) => Operation::CommentEdit {

                    id: id.ok_or_else(|| anyhow!("an issue must be provided"))?,

                    comment_id,

                    message,

                },

                (reply_to @ Some(_), None) => Operation::Comment {

                    id: id.ok_or_else(|| anyhow!("an issue must be provided"))?,

                    message,

                    reply_to,

                },

                (Some(_), Some(_)) => anyhow::bail!("you cannot use --reply-to with --edit"),

            },

            OperationName::Show => Operation::Show {

                id: id.ok_or_else(|| anyhow!("an issue must be provided"))?,

                format,

                verbose,

            },

            OperationName::State => Operation::State {

                id: id.ok_or_else(|| anyhow!("an issue must be provided"))?,

                state: state.ok_or_else(|| anyhow!("a state operation must be provided"))?,

            },

            OperationName::React => Operation::React {

                id: id.ok_or_else(|| anyhow!("an issue must be provided"))?,

                reaction,

                comment_id,

            },

            OperationName::Delete => Operation::Delete {

                id: id.ok_or_else(|| anyhow!("an issue to remove must be provided"))?,

            },

            OperationName::Assign => Operation::Assign {

                id: id.ok_or_else(|| anyhow!("an issue to label must be provided"))?,

                opts: assign_opts,

            },

            OperationName::Label => Operation::Label {

                id: id.ok_or_else(|| anyhow!("an issue to label must be provided"))?,

                opts: label_opts,

            },

            OperationName::List => Operation::List { assigned, state },

            OperationName::Cache => Operation::Cache {

                id,

                storage: cache_storage,

            },

        };

        Ok((

            Options {

                op,

                repo,

                announce,

                quiet,

            },

            vec![],

        ))

    }

}

pub fn run(options: Options, ctx: impl term::Context) -> anyhow::Result<()> {

    let rid = if let Some(rid) = options.repo {

    let announce = options.announce

        && matches!(

            &options.op,

            Operation::Open { .. }

                | Operation::React { .. }

                | Operation::State { .. }

                | Operation::Delete { .. }

                | Operation::Assign { .. }

                | Operation::Label { .. }

                | Operation::Edit { .. }

                | Operation::Comment { .. }

        );

    match options.op {

        Operation::Edit {

            if !options.quiet {

                term::issue::show(&issue, issue.id(), Format::Header, false, &profile)?;

        Operation::Open {

            title: Some(title),

            description: Some(description),

            labels,

            assignees,

            let issue = issues.create(title, description, &labels, &assignees, [], &signer)?;

            if !options.quiet {

                term::issue::show(&issue, issue.id(), Format::Header, false, &profile)?;

            }

        Operation::Comment {

            id,

            message,

            reply_to,

        } => {

            let reply_to = reply_to

                .map(|rev| rev.resolve::<radicle::git::Oid>(repo.raw()))

                .transpose()?;

            let signer = term::signer(&profile)?;

            let issue_id = id.resolve::<cob::ObjectId>(&repo.backend)?;

            let mut issue = issues.get_mut(&issue_id)?;

            let (root_comment_id, _) = issue.root();

            let body = prompt_comment(message, issue.thread(), reply_to, None)?;

            let comment_id =

                issue.comment(body, reply_to.unwrap_or(*root_comment_id), vec![], &signer)?;

            if options.quiet {

                term::print(comment_id);

            } else {

                let comment = issue.thread().comment(&comment_id).unwrap();

                term::comment::widget(&comment_id, comment, &profile).print();

        }

        Operation::CommentEdit {

            id,

            comment_id,

            message,

        } => {

            let signer = term::signer(&profile)?;

            let issue_id = id.resolve::<cob::ObjectId>(&repo.backend)?;

            let comment_id = comment_id.resolve(&repo.backend)?;

            let mut issue = issues.get_mut(&issue_id)?;

            let comment = issue

                .thread()

                .comment(&comment_id)

                .ok_or(anyhow::anyhow!("comment '{comment_id}' not found"))?;

            let body = prompt_comment(

                issue.thread(),

                comment.reply_to(),

                Some(comment.body()),

            )?;

            issue.edit_comment(comment_id, body, vec![], &signer)?;

            if options.quiet {

                term::print(comment_id);

                let comment = issue.thread().comment(&comment_id).unwrap();

                term::comment::widget(&comment_id, comment, &profile).print();

            }

        }

        Operation::Show {

            id,

            format,

            verbose,

        } => {

            term::issue::show(&issue, &id, format, verbose, &profile)?;

        Operation::State { id, state } => {

            let signer = term::signer(&profile)?;

            if !options.quiet {

        Operation::React {

                    Some(cid) => cid,

        Operation::Open {

            ref title,

            ref description,

            ref labels,

            ref assignees,

        } => {

            let signer = term::signer(&profile)?;

            open(

                title.clone(),

                description.clone(),

                labels.to_vec(),

                assignees.to_vec(),

                &options,

                &mut issues,

                &signer,

                &profile,

            )?;

        }

        Operation::Assign {

            id,

            opts: AssignOptions { add, delete },

        } => {

        Operation::Label {

            id,

            opts: LabelOptions { add, delete },

        } => {

            let signer = term::signer(&profile)?;

        Operation::List { assigned, state } => {

            list(issues, &assigned, &state, &profile)?;

        Operation::Delete { id } => {

            let signer = term::signer(&profile)?;

        Operation::Cache { id, storage } => {

                let (alias, _) = Author::new(did.as_key(), profile, false).labels();

        let (alias, did) = Author::new(&author, profile, false).labels();

    options: &Options,

    R: ReadRepository + WriteRepository + cob::Store<Namespace = NodeId>,

    if !options.quiet {

        term::issue::show(&issue, issue.id(), Format::Header, false, profile)?;

    R: WriteRepository + ReadRepository + cob::Store<Namespace = NodeId>,

/// Get a comment from the user, by prompting.

pub fn prompt_comment(

    message: Message,

    thread: &thread::Thread,

    mut reply_to: Option<Oid>,

    edit: Option<&str>,

) -> anyhow::Result<String> {

    let (chase, missing) = {

        let mut chase = Vec::with_capacity(thread.len());

        let mut missing = None;

        while let Some(id) = reply_to {

            if let Some(comment) = thread.comment(&id) {

                chase.push(comment);

                reply_to = comment.reply_to();

            } else {

                missing = reply_to;

                break;

            }

        }

        (chase, missing)

    };

    let quotes = if chase.is_empty() {

        ""

    } else {

        "Quotes (lines starting with '>') will be preserved. Please remove those that you do not intend to keep.\n"

    };

    let mut buffer = term::format::html::commented(format!("HTML comments, such as this one, are deleted before posting.\n{quotes}Saving an empty file aborts the operation.").as_str());

    buffer.push('\n');

    for comment in chase.iter().rev() {

        buffer.reserve(2);

        buffer.push('\n');

        comment_quoted(comment, &mut buffer);

    }

    if let Some(id) = missing {

        buffer.push('\n');

        buffer.push_str(

            term::format::html::commented(

                format!("The comment with ID {id} that was replied to could not be found.")

                    .as_str(),

            )

            .as_str(),

        );

    }

    if let Some(edit) = edit {

        if !chase.is_empty() {

            buffer.push_str(

                "\n<!-- The contents of the comment you are editing follow below this line. -->\n",

            );

        }

        buffer.reserve(2 + edit.len());

        buffer.push('\n');

        buffer.push_str(edit);

    }

    let body = message.get(&buffer)?;

    if body.is_empty() {

        anyhow::bail!("aborting operation due to empty comment");

    }

    Ok(body)

}

fn comment_quoted(comment: &thread::Comment, buffer: &mut String) {

    let body = comment.body();

    let lines = body.lines();

    let hint = {

        let (lower, upper) = lines.size_hint();

        upper.unwrap_or(lower)

    };

    buffer.push_str(format!("{} wrote:\n", comment.author()).as_str());

    buffer.reserve(body.len() + hint * 2);

    for line in lines {

        buffer.push('>');

        if !line.is_empty() {

            buffer.push(' ');

        }

        buffer.push_str(line);

        buffer.push('\n');

    }

}