signer,

use std::path::PathBuf;

use radicle::crypto::Signer;

use radicle::storage::git::Repository;

use radicle::storage::{ReadStorage, WriteRepository};

use crate::git::{HunkDiff, HunkState};

use super::review::builder::DiffUtil;

use self::builder::{Brain, FileReviewBuilder, Hunks};

    pub signer: Box<dyn Signer>,

    #[allow(clippy::too_many_arguments)]

        signer: Box<dyn Signer>,

            signer,

            self.signer,

    Discard,

    rid: RepoId,

            rid,

    pub fn update_hunk_list(&mut self, hunks: TableState) {

    pub fn hunk_states(&self) -> &Vec<HunkState> {

        &self.hunks.1

    pub fn hunk_states_mut(&mut self) -> &mut Vec<HunkState> {

        &mut self.hunks.1

    /// The nodes' storage.

    storage: Storage,

    /// Signer of all writes to the storage or repo.

    signer: Arc<Mutex<Box<dyn Signer>>>,

    /// Title of the patch this patch this review belongs to.

    /// Revision this review belongs to.

    revision: Revision,

            tui.signer,

        signer: Box<dyn Signer>,

        let states = hunks.iter().map(|_| HunkState::Unknown).collect::<Vec<_>>();

        let mut app = App {

            storage,

            signer: Arc::new(Mutex::new(signer)),

            revision,

        };

        app.reload_states()?;

        Ok(app)

    #[allow(clippy::borrowed_box)]

    pub fn accept_current_hunk(&self) -> Result<()> {

        let repo = self.storage.repository(self.state.rid).unwrap();

        let signer: &Box<dyn Signer> = &self.signer.lock().unwrap();

        if let Some(selected) = self.selected_hunk_idx() {

            let items = &self.hunks.lock().unwrap();

            let mut brain =

                Brain::load_or_new(self.state.patch, &self.revision, repo.raw(), signer)?;

            let mut last_path: Option<&PathBuf> = None;

            let mut file: Option<FileReviewBuilder> = None;

            for (idx, item) in items.iter().enumerate() {

                // Get file path.

                let path = match &item.diff {

                    HunkDiff::Added { path, .. } => path,

                    HunkDiff::Deleted { path, .. } => path,

                    HunkDiff::Modified { path, .. } => path,

                    HunkDiff::Copied { copied } => &copied.new_path,

                    HunkDiff::Moved { moved } => &moved.new_path,

                    HunkDiff::EofChanged { path, .. } => path,

                    HunkDiff::ModeChanged { path, .. } => path,

                };

                // Set new review builder if hunk belongs to new file.

                if last_path.is_none() || last_path.unwrap() != path {

                    last_path = Some(path);

                    file = Some(FileReviewBuilder::new(&item.diff));

                }

                if let Some(file) = file.as_mut() {

                    file.set_item(&item.diff);

                    if idx == selected {

                        let diff = file.item_diff(&item.diff)?;

                        brain.accept(diff, repo.raw())?;

                    } else {

                        file.ignore_item(&item.diff)

                    }

                }

            }

    #[allow(clippy::borrowed_box)]

    pub fn discard_accepted_hunks(&self) -> Result<()> {

        let repo = self.repo()?;

        let signer: &Box<dyn Signer> = &self.signer.lock().unwrap();

        let mut brain = Brain::load_or_new(self.state.patch, &self.revision, repo.raw(), signer)?;

        brain.discard_accepted(repo.raw())?;

        Ok(())

    }

    #[allow(clippy::borrowed_box)]

    pub fn reload_states(&mut self) -> anyhow::Result<()> {

        let repo = self.repo()?;

        let signer: &Box<dyn Signer> = &self.signer.lock().unwrap();

        let items = self.hunks.lock().unwrap();

        let brain = Brain::load_or_new(self.state.patch, &self.revision, repo.raw(), signer)?;

        let rejected_hunks =

            Hunks::new(DiffUtil::new(&repo).rejected_diffs(&brain, &self.revision)?);

        log::debug!("Reloaded hunk states..");

        log::debug!("Rejected hunks: {:?}", rejected_hunks);

        log::debug!("Requested to reload hunks: {:?}", items);

        for (idx, item) in items.iter().enumerate() {

            let new_state = if rejected_hunks.contains(&item.diff) {

                HunkState::Rejected

            } else {

                HunkState::Accepted

            };

            if let Some(state) = self.state.hunk_states_mut().get_mut(idx) {

                *state = new_state;

            }

        log::debug!("Reloaded hunks: {:?}", items);

    pub fn selected_hunk_idx(&self) -> Option<usize> {

    pub fn repo(&self) -> Result<Repository> {

        Ok(self.storage.repository(self.state.rid)?)

    }

                                ("d", "discard accepted"),

                        if ui.input_global(|key| key == Key::Char('d')) {

                            ui.send_message(Message::Discard);

                self.state.update_hunk_list(state);

                match self.accept_current_hunk() {

                    Ok(()) => log::info!("Hunk accepted."),

                let _ = self.reload_states();

            Message::Discard => {

                match self.discard_accepted_hunks() {

                    Ok(()) => log::info!("Discarded all hunks."),

                    Err(err) => log::info!("An error occured while discarding hunks: {}", err),

                let _ = self.reload_states();

                Box::new(node.signer.clone()),

        assert_eq!(app.selected_hunk_idx(), Some(0));

        assert_eq!(app.selected_hunk_idx(), Some(1));

    #[ignore]

use radicle::cob::patch::{PatchId, Revision};

    pub fn contains(&self, other: &HunkDiff) -> bool {

        for item in &self.hunks {

            if item.path() == other.path() && item.hunk() == other.hunk() {

                return true;

            }

        }

        false

    }

/// Builds a review for a single file.

/// Adjusts line deltas when a hunk is ignored.

#[derive(Debug)]

pub struct FileReviewBuilder {

    delta: i32,

    header: FileHeader,

}

impl FileReviewBuilder {

    pub fn new(item: &HunkDiff) -> Self {

        Self {

            delta: 0,

            header: item.file_header(),

        }

    }

    pub fn set_item(&mut self, item: &HunkDiff) -> &mut Self {

        let header = item.file_header();

        if self.header != header {

            self.header = header;

            self.delta = 0;

        }

        self

    }

    pub fn ignore_item(&mut self, item: &HunkDiff) {

        if let Some(h) = item.hunk_header() {

            self.delta += h.new_size as i32 - h.old_size as i32;

        }

    }

    pub fn item_diff(&mut self, item: &HunkDiff) -> Result<git::raw::Diff, Error> {

        let mut buf = Vec::new();

        let mut writer = unified_diff::Writer::new(&mut buf);

        writer.encode(&self.header)?;

        if let (Some(h), Some(mut header)) = (item.hunk(), item.hunk_header()) {

            header.old_line_no -= self.delta as u32;

            header.new_line_no -= self.delta as u32;

            let h = Hunk {

                header: header.to_unified_string()?.as_bytes().to_owned().into(),

                lines: h.lines.clone(),

                old: h.old.clone(),

                new: h.new.clone(),

            };

            writer.encode(&h)?;

        }

        drop(writer);

        log::debug!("Building item diff ({:?})", String::from_utf8(buf.clone()));

        git::raw::Diff::from_buffer(&buf).map_err(Error::from)

    }

}

/// Represents the reviewer's brain, ie. what they have seen or not seen in terms

/// of changes introduced by a patch.

#[derive(Clone, Debug)]

pub struct Brain<'a> {

    /// Where the review draft is being stored.

    refname: git::Namespaced<'a>,

    /// The merge base

    base: git::raw::Commit<'a>,

    /// The commit pointed to by the ref.

    head: git::raw::Commit<'a>,

    /// The tree of accepted changes pointed to by the head commit.

    accepted: git::raw::Tree<'a>,

}

impl<'a> Brain<'a> {

    /// Create a new brain in the repository.

    pub fn new(

        patch: PatchId,

        remote: &NodeId,

        base: git::raw::Commit<'a>,

        repo: &'a git::raw::Repository,

    ) -> Result<Self, git::raw::Error> {

        let refname = Self::refname(&patch, remote);

        let author = repo.signature()?;

        let oid = repo.commit(

            Some(refname.as_str()),

            &author,

            &author,

            &format!("Review for {patch}"),

            &base.tree()?,

            // TODO: Verify this is necessary, shouldn't matter.

            &[&base],

        )?;

        let head = repo.find_commit(oid)?;

        let tree = head.tree()?;

        Ok(Self {

            refname,

            base,

            head,

            accepted: tree,

        })

    }

    /// Load an existing brain from the repository.

    pub fn load(

        patch: PatchId,

        remote: &NodeId,

        base: git::raw::Commit<'a>,

        repo: &'a git::raw::Repository,

    ) -> Result<Self, git::raw::Error> {

        // TODO: Validate this leads to correct UX for potentially abandoned drafts on

        // past revisions.

        let refname = Self::refname(&patch, remote);

        let head = repo.find_reference(&refname)?.peel_to_commit()?;

        let tree = head.tree()?;

        Ok(Self {

            refname,

            base,

            head,

            accepted: tree,

        })

    }

    pub fn load_or_new<G: Signer>(

        patch: PatchId,

        revision: &Revision,

        repo: &'a git::raw::Repository,

        signer: &'a G,

    ) -> Result<Self, git::raw::Error> {

        let base = repo.find_commit((*revision.base()).into())?;

        let brain = if let Ok(b) = Brain::load(patch, signer.public_key(), base.clone(), repo) {

            log::info!(

                "Loaded existing brain {} for patch {}",

                b.head().id(),

                &patch

            );

            b

        } else {

            Brain::new(patch, signer.public_key(), base, repo)?

        };

        Ok(brain)

    }

    pub fn discard_accepted(

        &mut self,

        repo: &'a git::raw::Repository,

    ) -> Result<(), git::raw::Error> {

        // Reset brain

        let head = self.head.amend(

            Some(&self.refname),

            None,

            None,

            None,

            None,

            Some(&self.base.tree()?),

        )?;

        self.head = repo.find_commit(head)?;

        self.accepted = self.head.tree()?;

        Ok(())

    }

    /// Accept changes to the brain.

    pub fn accept(

        &mut self,

        diff: git::raw::Diff,

        repo: &'a git::raw::Repository,

    ) -> Result<(), git::raw::Error> {

        let mut index = repo.apply_to_tree(&self.accepted, &diff, None)?;

        let accepted = index.write_tree_to(repo)?;

        self.accepted = repo.find_tree(accepted)?;

        // Update review with new brain.

        let head = self.head.amend(

            Some(&self.refname),

            None,

            None,

            None,

            None,

            Some(&self.accepted),

        )?;

        self.head = repo.find_commit(head)?;

        Ok(())

    }

    /// Get the brain's refname given the patch and remote.

    pub fn refname(patch: &PatchId, remote: &NodeId) -> git::Namespaced<'a> {

        git::refs::storage::draft::review(remote, patch)

    }

    pub fn head(&self) -> &git::raw::Commit<'a> {

        &self.head

    }

    pub fn accepted(&self) -> &git::raw::Tree<'a> {

        &self.accepted

    }

}

    pub fn rejected_diffs(&self, brain: &Brain<'a>, revision: &Revision) -> anyhow::Result<Diff> {

        let repo = self.repo.raw();

        let revision = {

            let commit = repo.find_commit(revision.head().into())?;

            commit.tree()?

        };

        let mut opts = git::raw::DiffOptions::new();

        opts.patience(true).minimal(true).context_lines(3_u32);

        let rejected = self.diff(brain.accepted(), &revision, repo, &mut opts)?;

        Ok(rejected)

    }