use std::sync::Arc;

use anyhow::anyhow;
use futures::channel::mpsc;
use futures::{SinkExt as _, StreamExt as _};
use git::{
    repository::{GitRepository, RepoPath},
    status::{GitSummary, TrackedSummary},
};
use gpui::{AppContext, SharedString};
use settings::WorktreeId;
use worktree::RepositoryEntry;

pub struct GitState {
    /// The current commit message being composed.
    pub commit_message: SharedString,

    /// When a git repository is selected, this is used to track which repository's changes
    /// are currently being viewed or modified in the UI.
    pub active_repository: Option<(WorktreeId, RepositoryEntry, Arc<dyn GitRepository>)>,

    update_sender: mpsc::UnboundedSender<(Message, mpsc::Sender<anyhow::Error>)>,
}

enum Message {
    StageAndCommit(Arc<dyn GitRepository>, SharedString, Vec<RepoPath>),
    Commit(Arc<dyn GitRepository>, SharedString),
    Stage(Arc<dyn GitRepository>, Vec<RepoPath>),
    Unstage(Arc<dyn GitRepository>, Vec<RepoPath>),
}

impl GitState {
    pub fn new(cx: &AppContext) -> Self {
        let (update_sender, mut update_receiver) =
            mpsc::unbounded::<(Message, mpsc::Sender<anyhow::Error>)>();
        cx.spawn(|cx| async move {
            while let Some((msg, mut err_sender)) = update_receiver.next().await {
                let result = cx
                    .background_executor()
                    .spawn(async move {
                        match msg {
                            Message::StageAndCommit(repo, message, paths) => {
                                repo.stage_paths(&paths)?;
                                repo.commit(&message)?;
                                Ok(())
                            }
                            Message::Stage(repo, paths) => repo.stage_paths(&paths),
                            Message::Unstage(repo, paths) => repo.unstage_paths(&paths),
                            Message::Commit(repo, message) => repo.commit(&message),
                        }
                    })
                    .await;
                if let Err(e) = result {
                    err_sender.send(e).await.ok();
                }
            }
        })
        .detach();
        GitState {
            commit_message: SharedString::default(),
            active_repository: None,
            update_sender,
        }
    }

    pub fn activate_repository(
        &mut self,
        worktree_id: WorktreeId,
        active_repository: RepositoryEntry,
        git_repo: Arc<dyn GitRepository>,
    ) {
        self.active_repository = Some((worktree_id, active_repository, git_repo));
    }

    pub fn active_repository(
        &self,
    ) -> Option<&(WorktreeId, RepositoryEntry, Arc<dyn GitRepository>)> {
        self.active_repository.as_ref()
    }

    pub fn stage_entries(
        &self,
        entries: Vec<RepoPath>,
        err_sender: mpsc::Sender<anyhow::Error>,
    ) -> anyhow::Result<()> {
        if entries.is_empty() {
            return Ok(());
        }
        let Some((_, _, git_repo)) = self.active_repository.as_ref() else {
            return Err(anyhow!("No active repository"));
        };
        self.update_sender
            .unbounded_send((Message::Stage(git_repo.clone(), entries), err_sender))
            .map_err(|_| anyhow!("Failed to submit stage operation"))?;
        Ok(())
    }

    pub fn unstage_entries(
        &self,
        entries: Vec<RepoPath>,
        err_sender: mpsc::Sender<anyhow::Error>,
    ) -> anyhow::Result<()> {
        if entries.is_empty() {
            return Ok(());
        }
        let Some((_, _, git_repo)) = self.active_repository.as_ref() else {
            return Err(anyhow!("No active repository"));
        };
        self.update_sender
            .unbounded_send((Message::Unstage(git_repo.clone(), entries), err_sender))
            .map_err(|_| anyhow!("Failed to submit unstage operation"))?;
        Ok(())
    }

    pub fn stage_all(&self, err_sender: mpsc::Sender<anyhow::Error>) -> anyhow::Result<()> {
        let Some((_, entry, _)) = self.active_repository.as_ref() else {
            return Err(anyhow!("No active repository"));
        };
        let to_stage = entry
            .status()
            .filter(|entry| !entry.status.is_staged().unwrap_or(false))
            .map(|entry| entry.repo_path.clone())
            .collect();
        self.stage_entries(to_stage, err_sender)?;
        Ok(())
    }

    pub fn unstage_all(&self, err_sender: mpsc::Sender<anyhow::Error>) -> anyhow::Result<()> {
        let Some((_, entry, _)) = self.active_repository.as_ref() else {
            return Err(anyhow!("No active repository"));
        };
        let to_unstage = entry
            .status()
            .filter(|entry| entry.status.is_staged().unwrap_or(true))
            .map(|entry| entry.repo_path.clone())
            .collect();
        self.unstage_entries(to_unstage, err_sender)?;
        Ok(())
    }

    /// Get a count of all entries in the active repository, including
    /// untracked files.
    pub fn entry_count(&self) -> usize {
        self.active_repository
            .as_ref()
            .map_or(0, |(_, entry, _)| entry.status_len())
    }

    fn have_changes(&self) -> bool {
        let Some((_, entry, _)) = self.active_repository.as_ref() else {
            return false;
        };
        entry.status_summary() != GitSummary::UNCHANGED
    }

    fn have_staged_changes(&self) -> bool {
        let Some((_, entry, _)) = self.active_repository.as_ref() else {
            return false;
        };
        entry.status_summary().index != TrackedSummary::UNCHANGED
    }

    pub fn can_commit(&self, commit_all: bool) -> bool {
        return !self.commit_message.trim().is_empty()
            && self.have_changes()
            && (commit_all || self.have_staged_changes());
    }

    pub fn commit(&mut self, err_sender: mpsc::Sender<anyhow::Error>) -> anyhow::Result<()> {
        if !self.can_commit(false) {
            return Err(anyhow!("Unable to commit"));
        }
        let Some((_, _, git_repo)) = self.active_repository() else {
            return Err(anyhow!("No active repository"));
        };
        let git_repo = git_repo.clone();
        let message = std::mem::take(&mut self.commit_message);
        self.update_sender
            .unbounded_send((Message::Commit(git_repo, message), err_sender))
            .map_err(|_| anyhow!("Failed to submit commit operation"))?;
        Ok(())
    }

    pub fn commit_all(&mut self, err_sender: mpsc::Sender<anyhow::Error>) -> anyhow::Result<()> {
        if !self.can_commit(true) {
            return Err(anyhow!("Unable to commit"));
        }
        let Some((_, entry, git_repo)) = self.active_repository.as_ref() else {
            return Err(anyhow!("No active repository"));
        };
        let to_stage = entry
            .status()
            .filter(|entry| !entry.status.is_staged().unwrap_or(false))
            .map(|entry| entry.repo_path.clone())
            .collect::<Vec<_>>();
        let message = std::mem::take(&mut self.commit_message);
        self.update_sender
            .unbounded_send((
                Message::StageAndCommit(git_repo.clone(), message, to_stage),
                err_sender,
            ))
            .map_err(|_| anyhow!("Failed to submit commit operation"))?;
        Ok(())
    }
}