#include "rebase_subcommand.hpp"

#include <iostream>

#include <git2.h>
#include <termcolor/termcolor.hpp>

#include "../utils/git_exception.hpp"
#include "../wrapper/index_wrapper.hpp"
#include "../wrapper/repository_wrapper.hpp"
#include "../wrapper/signature_wrapper.hpp"

rebase_subcommand::rebase_subcommand(const libgit2_object&, CLI::App& app)
{
    auto* sub = app.add_subcommand("rebase", "Reapply commits on top of another base tip");

    sub->add_option("upstream", m_upstream, "Upstream branch to rebase onto");
    sub->add_option("branch", m_branch, "Working branch; defaults to HEAD");
    sub->add_option("--onto", m_onto, "Starting point at which to create the new commits");

    sub->add_flag("--abort", m_abort, "Abort the rebase operation and reset HEAD to the original branch");
    sub->add_flag("--continue", m_continue, "Restart the rebasing process after having resolved a merge conflict");
    sub->add_flag("--skip", m_skip, "Restart the rebasing process by skipping the current patch");
    sub->add_flag("--quit", m_quit, "Abort the rebase operation but HEAD is not reset back to the original branch");

    sub->callback(
        [this]()
        {
            this->run();
        }
    );
}

void ensure_rebase_in_progress(git_repository_state_t state)
{
    if (state != GIT_REPOSITORY_STATE_REBASE_INTERACTIVE && state != GIT_REPOSITORY_STATE_REBASE_MERGE)
    {
        throw std::runtime_error("No rebase in progress");
    }
}

void rebase_subcommand::run()
{
    auto directory = get_current_git_path();
    auto repo = repository_wrapper::open(directory);

    git_repository_state_t state = repo.state();

    if (m_abort)
    {
        ensure_rebase_in_progress(state);
        run_abort(repo);
        return;
    }

    if (m_continue)
    {
        ensure_rebase_in_progress(state);
        run_continue(repo);
        return;
    }

    if (m_skip)
    {
        ensure_rebase_in_progress(state);
        run_skip(repo);
        return;
    }

    if (m_quit)
    {
        ensure_rebase_in_progress(state);
        run_quit(repo);
        return;
    }

    if (state == GIT_REPOSITORY_STATE_REBASE_INTERACTIVE || state == GIT_REPOSITORY_STATE_REBASE_MERGE)
    {
        throw std::runtime_error("A rebase is already in progress");
    }

    if (state != GIT_REPOSITORY_STATE_NONE)
    {
        throw std::runtime_error("Cannot rebase:  repository is in unexpected state");
    }

    run_rebase(repo);
}

annotated_commit_wrapper
rebase_subcommand::resolve_ref(const repository_wrapper& repo, const std::string& ref_name) const
{
    if (!ref_name.empty())
    {
        auto branch_commit = repo.resolve_local_ref(m_branch);
        if (!branch_commit)
        {
            throw std::runtime_error("error: could not resolve branch '" + m_branch + "'");
        }
        return std::move(branch_commit).value();
    }
    else
    {
        auto head = repo.head();
        auto branch_commit = repo.find_annotated_commit(head);
        return branch_commit;
    }
}

void rebase_subcommand::perform_rebase(repository_wrapper& repo, rebase_wrapper& rebase)
{
    auto signatures = signature_wrapper::get_default_signature_from_env(repo);

    size_t total_operations = rebase.operation_entry_count();
    std::cout << "Rebasing " << total_operations << " commit(s)..." << std::endl;

    while (rebase.next_operation())
    {
        size_t current_idx = rebase.current_operation_index();

        commit_wrapper original_commit = repo.find_commit(rebase.current_operation_id());
        std::string commit_summary = original_commit.summary();

        std::cout << "Applying:  " << commit_summary << " (" << (current_idx + 1) << "/" << total_operations
                  << ")" << std::endl;

        index_wrapper index = repo.make_index();
        if (index.has_conflict())
        {
            std::cout << termcolor::red << "Conflicts detected!" << termcolor::reset << std::endl;
            std::cout << "Resolve conflicts and run:" << std::endl;
            std::cout << "  git2cpp rebase --continue" << std::endl;
            std::cout << "or skip this commit with:" << std::endl;
            std::cout << "  git2cpp rebase --skip" << std::endl;
            std::cout << "or abort the rebase with:" << std::endl;
            std::cout << "  git2cpp rebase --abort" << std::endl;
            return;
        }

        int commit_result = rebase.commit(signatures.first, signatures.second);

        if (commit_result == GIT_EAPPLIED)
        {
            std::cout << termcolor::yellow << "Skipping commit (already applied)" << termcolor::reset
                      << std::endl;
        }
        else
        {
            throw_if_error(commit_result);
        }
    }

    rebase.finish(signatures.second);

    std::cout << termcolor::green << "Successfully rebased and updated HEAD." << termcolor::reset << std::endl;
}

void rebase_subcommand::run_rebase(repository_wrapper& repo)
{
    if (m_upstream.empty())
    {
        throw std::runtime_error("upstream is required for rebase");
    }

    annotated_commit_wrapper branch = resolve_ref(repo, m_branch);
    std::optional<annotated_commit_wrapper> upstream = repo.resolve_local_ref(m_upstream);
    if (!upstream)
    {
        throw std::runtime_error("error: could not resolve upstream '" + m_upstream + "'");
    }

    std::unique_ptr<annotated_commit_wrapper> onto_ptr = nullptr;
    if (!m_onto.empty())
    {
        onto_ptr = std::make_unique<annotated_commit_wrapper>(resolve_ref(repo, m_onto));
    }
    git_rebase_options rebase_opts;
    throw_if_error(git_rebase_options_init(&rebase_opts, GIT_REBASE_OPTIONS_VERSION));

    auto rebase = rebase_wrapper::init(repo, branch, upstream.value(), onto_ptr.get(), rebase_opts);
    perform_rebase(repo, rebase);
}

void rebase_subcommand::run_abort(repository_wrapper& repo)
{
    git_rebase_options rebase_opts;
    throw_if_error(git_rebase_options_init(&rebase_opts, GIT_REBASE_OPTIONS_VERSION));
    auto rebase = rebase_wrapper::open(repo, rebase_opts);
    rebase.abort();
    std::cout << "Rebase aborted" << std::endl;
}

void rebase_subcommand::run_continue(repository_wrapper& repo)
{
    // Check if there are still conflicts
    index_wrapper index = repo.make_index();
    if (index.has_conflict())
    {
        throw std::runtime_error("You must resolve conflicts before continuing the rebase");
    }
    git_rebase_options rebase_opts;
    throw_if_error(git_rebase_options_init(&rebase_opts, GIT_REBASE_OPTIONS_VERSION));
    auto rebase = rebase_wrapper::open(repo, rebase_opts);

    // Get signature for commits
    auto signatures = signature_wrapper::get_default_signature_from_env(repo);

    int commit_result = rebase.commit(signatures.first, signatures.second);

    if (commit_result == GIT_EAPPLIED)
    {
        std::cout << termcolor::yellow << "Skipping commit (already applied)" << termcolor::reset << std::endl;
    }
    else
    {
        throw_if_error(commit_result);
    }

    perform_rebase(repo, rebase);
}

void rebase_subcommand::run_skip(repository_wrapper& repo)
{
    git_rebase_options rebase_opts;
    throw_if_error(git_rebase_options_init(&rebase_opts, GIT_REBASE_OPTIONS_VERSION));
    auto rebase = rebase_wrapper::open(repo, rebase_opts);

    std::cout << "Skipping current commit..." << std::endl;

    perform_rebase(repo, rebase);
}

void rebase_subcommand::run_quit(repository_wrapper& repo)
{
    repo.state_cleanup();
    std::cout << "Rebase state cleaned up (HEAD not reset)" << std::endl;
}