mod comment;

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

use args::{Assigned, Command, CommentAction, StateArg};

    let announce = should_announce && command.should_announce_for();

        Command::Comment(c) => match CommentAction::from(c) {

            CommentAction::Comment { id, message } => {

                comment::comment(&profile, &repo, &mut issues, id, message, None, args.quiet)?;

            CommentAction::Reply {

                id,

                reply_to,

            } => comment::comment(

                &profile,

                &repo,

                &mut issues,

                id,

                message,

                Some(reply_to),

                args.quiet,

            )?,

            CommentAction::Edit {

                id,

                message,

                to_edit,

            } => comment::edit(

                &profile,

                &repo,

                &mut issues,

                id,

                message,

                to_edit,

                args.quiet,

            )?,

        },

    /// Announce issue changes to the network

    /// Resolve the `--announce` and `--no-announce` flags. If both flags are

    /// equal then `true` is returned, since it is the default.

    ///

    /// Note that `clap` should make it impossible to have both flags set to

    /// `true.`

    pub(crate) fn should_announce(&self) -> bool {

    Comment(CommentArgs),

impl Command {

    /// Returns `true` if the changes made by the command should announce to the

    /// network.

    pub(crate) fn should_announce_for(&self) -> bool {

        match self {

            Command::Open { .. }

            | Command::React { .. }

            | Command::State { .. }

            | Command::Delete { .. }

            | Command::Assign { .. }

            | Command::Label { .. }

            | Command::Edit { .. } => true,

            // TODO(erikli): Remove special handling for `--edit` and

            // make it also announce.

            Command::Comment(args) => !args.is_edit(),

            _ => false,

        }

    }

}

/// Arguments for the [`Command::Comment`] subcommand.

#[derive(Parser, Debug)]

pub(crate) struct CommentArgs {

    /// ID of the issue

    id: Rev,

    /// The body of the comment

    #[arg(long, short)]

    #[arg(value_name = "MESSAGE")]

    message: Message,

    /// Optionally, the comment to reply to. If not specified, the comment

    /// will be in reply to the issue itself

    #[arg(long, value_name = "COMMENT_ID")]

    #[arg(conflicts_with = "edit")]

    reply_to: Option<Rev>,

    /// Edit a comment by specifying its ID

    #[arg(long, value_name = "COMMENT_ID")]

    #[arg(conflicts_with = "reply_to")]

    edit: Option<Rev>,

}

impl CommentArgs {

    // TODO(finto): this is only needed to avoid announcing edits for the time

    // being

    /// If the comment is editing an existing comment

    pub(crate) fn is_edit(&self) -> bool {

        self.edit.is_some()

    }

}

/// The action that should be performed based on the supplied [`CommentArgs`].

pub(crate) enum CommentAction {

    /// Comment to the main issue thread.

    Comment {

        /// The issue ID

        id: Rev,

        /// The message of the comment.

        message: Message,

    },

    /// Reply to a specific comment in the issue.

    Reply {

        /// The issue ID

        id: Rev,

        /// The message that is being used to reply to the comment.

        message: Message,

        /// The comment ID that is being replied to.

        reply_to: Rev,

    },

    /// Edit a specific comment in the issue.

    Edit {

        /// The issue ID

        id: Rev,

        /// The message that is being used to edit the comment.

        message: Message,

        /// The comment ID that is being edited.

        to_edit: Rev,

    },

}

impl From<CommentArgs> for CommentAction {

    fn from(

        CommentArgs {

            id,

            message,

            reply_to,

            edit,

        }: CommentArgs,

    ) -> Self {

        match (reply_to, edit) {

            (Some(_), Some(_)) => {

                unreachable!("the argument '--reply-to' cannot be used with '--edit'")

            }

            (Some(reply_to), None) => Self::Reply {

                id,

                message,

                reply_to,

            },

            (None, Some(to_edit)) => Self::Edit {

                id,

                message,

                to_edit,

            },

            (None, None) => Self::Comment { id, message },

        }

    }

}

use radicle::cob::thread;

use radicle::storage::WriteRepository;

use radicle::Profile;

use radicle::{cob, git, issue, storage};

use crate::git::Rev;

use crate::terminal as term;

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

use crate::terminal::Element as _;

pub(super) fn comment(

    profile: &Profile,

    repo: &storage::git::Repository,

    issues: &mut issue::Cache<

        issue::Issues<'_, storage::git::Repository>,

        cob::cache::Store<cob::cache::Write>,

    >,

    id: Rev,

    message: Message,

    reply_to: Option<Rev>,

    quiet: bool,

) -> Result<(), anyhow::Error> {

    let reply_to = reply_to

        .map(|rev| rev.resolve::<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 quiet {

        term::print(comment_id);

    } else {

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

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

    }

    Ok(())

}

pub(super) fn edit(

    profile: &Profile,

    repo: &storage::git::Repository,

    issues: &mut issue::Cache<

        issue::Issues<'_, storage::git::Repository>,

        cob::cache::Store<cob::cache::Write>,

    >,

    id: Rev,

    message: Message,

    comment_id: Rev,

    quiet: bool,

) -> Result<(), anyhow::Error> {

    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(

        message,

        issue.thread(),

        comment.reply_to(),

        Some(comment.body()),

    )?;

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

    if quiet {

        term::print(comment_id);

    } else {

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

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

    }

    Ok(())

}

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

fn prompt_comment(

    message: Message,

    thread: &thread::Thread,

    mut reply_to: Option<git::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');

    }

}