#include "merge_subcommand.hpp"

#include <cassert>
#include <iostream>

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

#include "../wrapper/status_wrapper.hpp"

merge_subcommand::merge_subcommand(const libgit2_object&, CLI::App& app)
{
    auto* sub = app.add_subcommand("merge", "Join two or more development histories together");

    sub->add_option("<branch>", m_branches_to_merge, "Branch(es) to merge");
    // sub->add_flag("--no-ff", m_no_ff, "Create a merge commit in all cases, even when the merge could
    // instead be resolved as a fast-forward."); sub->add_flag("--commit", m_commit, "Perform the merge and
    // commit the result. This option can be used to override --no-commit.");
    sub->add_flag(
        "--no-commit",
        m_no_commit,
        "With --no-commit perform the merge and stop just before creating a merge commit, to give the user a chance to inspect and further tweak the merge result before committing. \nNote that fast-forward updates do not create a merge commit and therefore there is no way to stop those merges with --no-commit. Thus, if you want to ensure your branch is not changed or updated by the merge command, use --no-ff with --no-commit."
    );
    sub->add_flag(
        "--abort",
        m_abort,
        "Abort the current conflict resolution process, and try to reconstruct the pre-merge state. If an autostash entry is present, apply it to the worktree.\nIf there were uncommitted worktree changes present when the merge started, git merge --abort will in some cases be unable to reconstruct these changes. It is therefore recommended to always commit or stash your changes before running git merge.\ngit merge --abort is equivalent to git reset --merge when MERGE_HEAD is present unless MERGE_AUTOSTASH is also present in which case git merge --abort applies the stash entry to the worktree whereas git reset --merge will save the stashed changes in the stash list."
    );
    sub->add_flag(
        "--quit",
        m_quit,
        "Forget about the current merge in progress. Leave the index and the working tree as-is. If MERGE_AUTOSTASH is present, the stash entry will be saved to the stash list."
    );
    sub->add_flag(
        "--continue",
        m_continue,
        "After a git merge stops due to conflicts you can conclude the merge by running git merge --continue"
    );  //  (see "HOW TO RESOLVE CONFLICTS" section below).

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

annotated_commit_list_wrapper merge_subcommand::resolve_heads(const repository_wrapper& repo)
{
    std::vector<annotated_commit_wrapper> commits_to_merge;
    commits_to_merge.reserve(m_branches_to_merge.size());

    for (const auto branch_name : m_branches_to_merge)
    {
        std::optional<annotated_commit_wrapper> commit = repo.resolve_local_ref(branch_name);
        if (commit.has_value())
        {
            commits_to_merge.push_back(std::move(commit).value());
        }
    }
    return annotated_commit_list_wrapper(std::move(commits_to_merge));
}

annotated_commit_list_wrapper
resolve_mergeheads(const repository_wrapper& repo, const std::vector<git_oid>& oid_list)
{
    std::vector<annotated_commit_wrapper> commits_to_merge;
    commits_to_merge.reserve(oid_list.size());

    for (const auto& id : oid_list)
    {
        std::optional<annotated_commit_wrapper> commit = repo.find_annotated_commit(id);
        if (commit.has_value())
        {
            commits_to_merge.push_back(std::move(commit).value());
        }
    }
    return annotated_commit_list_wrapper(std::move(commits_to_merge));
}

void perform_fastforward(repository_wrapper& repo, const git_oid& target_oid, int is_unborn)
{
    const git_checkout_options ff_checkout_options = GIT_CHECKOUT_OPTIONS_INIT;

    auto lambda_get_target_ref = [](auto repo, auto is_unborn)
    {
        if (!is_unborn)
        {
            return repo->head();
        }
        else
        {
            return repo->find_reference("HEAD");
        }
    };
    reference_wrapper target_ref = lambda_get_target_ref(&repo, is_unborn);

    object_wrapper target = repo.find_object(target_oid, GIT_OBJECT_COMMIT);

    repo.checkout_tree(target, ff_checkout_options);

    target_ref.write_new_ref(target_oid);
}

void merge_subcommand::create_merge_commit(
    repository_wrapper& repo,
    const index_wrapper& index,
    const std::vector<std::string>& branches_to_merge,
    const annotated_commit_list_wrapper& commits_to_merge,
    size_t num_commits_to_merge
)
{
    auto head_ref = repo.head();
    auto merge_ref = repo.find_reference_dwim(branches_to_merge.front());
    auto merge_commit = repo.resolve_local_ref(branches_to_merge.front()).value();

    std::vector<commit_wrapper> parents_list;
    parents_list.reserve(num_commits_to_merge + 1);
    parents_list.push_back(std::move(head_ref.peel<commit_wrapper>()));
    for (size_t i = 0; i < num_commits_to_merge; ++i)
    {
        parents_list.push_back(repo.find_commit(commits_to_merge[i].oid()));
    }
    auto parents = commit_list_wrapper(std::move(parents_list));

    auto author_committer_sign = signature_wrapper::get_default_signature_from_env(repo);
    std::string author_name;
    author_name = author_committer_sign.first.name();
    std::string author_email;
    author_email = author_committer_sign.first.email();
    auto author_committer_sign_now = signature_wrapper::signature_now(
        author_name,
        author_email,
        author_name,
        author_email
    );

    // TODO: add a prompt to edit the merge message
    std::string msg_target = merge_ref ? merge_ref->short_name() : git_oid_tostr_s(&(merge_commit.oid()));
    msg_target = "\'" + msg_target + "\'";
    std::string msg = merge_ref ? "Merge branch " : "Merge commit ";
    msg.append(msg_target);

    repo.create_commit(author_committer_sign_now, msg, std::optional<commit_list_wrapper>(std::move(parents)));

    repo.state_cleanup();
}

// This function is used as a callback in git_repository_mergehead_foreach and therefore its type must be
// git_repository_mergehead_foreach_cb.
int populate_list(const git_oid* oid, void* payload)
{
    auto* l = reinterpret_cast<std::vector<git_oid>*>(payload);
    l->push_back(*oid);
    return 0;
}

void merge_subcommand::run()
{
    auto directory = get_current_git_path();
    auto repo = repository_wrapper::open(directory);
    auto state = repo.state();
    index_wrapper index = repo.make_index();
    stream_colour_fn yellow = termcolor::yellow;

    if (state == GIT_REPOSITORY_STATE_MERGE)
    {
        if (m_abort)
        {
            // git merge --abort is equivalent to git reset --merge when MERGE_HEAD is present
            // unless MERGE_AUTOSTASH is also present in which case git merge --abort applies
            // the stash entry to the worktree whereas git reset --merge will save the stashed
            // changes in the stash list.

            if (m_quit | m_continue)
            {
                std::cout << "fatal: --abort expects no arguments" << std::endl;  // TODO: add the help info
                return;
            }

            std::cout << "Warning: 'merge --abort' is not implemented yet. A 'reset --hard HEAD' will be executed."
                      << std::endl;
            std::cout << "Do you want to continue [y/N] ?" << std::endl;
            std::string answer;
            std::cin >> answer;
            if (answer == "y")
            {
                repo.state_cleanup();
                index.conflict_cleanup();

                git_checkout_options options;
                git_checkout_options_init(&options, GIT_CHECKOUT_OPTIONS_VERSION);
                auto head_ref = repo.head();
                repo.reset(head_ref.peel<object_wrapper>(), GIT_RESET_HARD, options);
            }
            else
            {
                std::cout << "Abort." << std::endl;  // maybe another message would be more clear?
            }
            return;
        }
        else if (m_quit)
        {
            // Forget about the current merge in progress. Leave the index and the working tree as-is.
            // If MERGE_AUTOSTASH is present, the stash entry will be saved to the stash list.
            //

            // if (m_continue)
            // {
            //     std::cout << "fatal: --abort expects no arguments" << std::endl;   // TODO: add the help
            //     info return;
            // }

            // problem: can't do a reset if the state is not cleaned up, but it shouldn't be.
            // Idem for the index and the conflicts.

            // repo.state_cleanup();
            // index.conflict_cleanup();

            // git_checkout_options options;
            // git_checkout_options_init(&options, GIT_CHECKOUT_OPTIONS_VERSION);
            // auto head_ref = repo.head();
            // repo.reset(head_ref.peel<object_wrapper>(), GIT_RESET_SOFT, options);

            std::cout << "merge --quit is not implemented yet." << std::endl;
            return;
        }
        else if (m_continue)
        {
            auto sl = status_list_wrapper::status_list(repo);
            if (!sl.has_unmerged_header())
            {
                // std::string commit_message = "Merge branch ";    // how to get the name of the branch the
                // merge was started on ? auto author_committer_signatures =
                // signature_wrapper::get_default_signature_from_env(repo);
                // repo.create_commit(author_committer_signatures, commit_message, std::nullopt);

                std::vector<git_oid> oid_list;
                git_repository_mergehead_foreach(repo, populate_list, &oid_list);

                annotated_commit_list_wrapper commits_to_merge = resolve_mergeheads(repo, oid_list);
                size_t num_commits_to_merge = commits_to_merge.size();

                std::vector<std::string> branches_to_merge_names;
                for (const auto& id : oid_list)
                {
                    git_reference_iterator* iter;
                    git_reference_iterator_new(&iter, repo);
                    git_reference* ref;
                    git_reference_next(&ref, iter);
                    if (git_oid_equal(git_reference_target(ref), &id))
                    {
                        auto name = git_reference_name(ref);
                        branches_to_merge_names.push_back(name);
                    }
                    git_reference_free(ref);
                }

                create_merge_commit(repo, index, branches_to_merge_names, commits_to_merge, num_commits_to_merge);
                std::cout << "Merge made" << std::endl;  // TODO: change the outpout to something like this:
                                                         // 3c22161 (HEAD -> master) Merge branch 'foregone'

                repo.state_cleanup();
                index.conflict_cleanup();
                return;
            }
            else
            {
                auto entry_status = get_status_msg(GIT_STATUS_CONFLICTED).short_mod;
                const auto& entry_list = sl.get_entry_list(GIT_STATUS_CONFLICTED);
                for (auto* entry : entry_list)
                {
                    git_diff_delta* diff_delta = entry->head_to_index;  // ou entry->index_to_workdir ???
                    const char* old_path = diff_delta->old_file.path;
                    std::cout << entry_status << "\t" << old_path << std::endl;
                }
                std::cout << "error: Committing is not possible because you have unmerged files." << std::endl;
            }
        }
        else
        {
            std::cout << "error: Merging is not possible because you have unmerged files." << std::endl;
        }
        std::cout << yellow << "hint: Fix them up in the work tree, and then use 'git add/rm <file>'"
                  << std::endl;
        std::cout << "hint: as appropriate to mark resolution and make a commit." << termcolor::reset
                  << std::endl;
        std::cout << "fatal: Exiting because of an unresolved conflict." << std::endl;
        return;
    }
    else
    {
        if (m_abort)
        {
            std::cout << "fatal: There is no merge to abort (MERGE_HEAD missing)." << std::endl;
            return;
        }
        if (m_continue)
        {
            std::cout << "fatal: There is no merge in progress (MERGE_HEAD missing)." << std::endl;
            return;
        }
    }

    if (state != GIT_REPOSITORY_STATE_NONE)  // Could this be a "else if before the "else" above ?
    {
        std::cout << "repository is in unexpected state " << state << std::endl;
    }

    git_merge_analysis_t analysis;
    git_merge_preference_t preference;
    annotated_commit_list_wrapper commits_to_merge = resolve_heads(repo);
    size_t num_commits_to_merge = commits_to_merge.size();
    git_annotated_commit** c_commits_to_merge = commits_to_merge;
    auto commits_to_merge_const = const_cast<const git_annotated_commit**>(c_commits_to_merge);

    throw_if_error(
        git_merge_analysis(&analysis, &preference, repo, commits_to_merge_const, num_commits_to_merge)
    );

    if (analysis & GIT_MERGE_ANALYSIS_UP_TO_DATE)
    {
        std::cout << "Already up-to-date" << std::endl;
        return;
    }
    else if (
        analysis & GIT_MERGE_ANALYSIS_UNBORN
        || (analysis & GIT_MERGE_ANALYSIS_FASTFORWARD && !(preference & GIT_MERGE_PREFERENCE_NO_FASTFORWARD))
    )
    {
        if (analysis & GIT_MERGE_ANALYSIS_UNBORN)
        {
            std::cout << "Unborn" << std::endl;
        }
        else
        {
            std::cout << "Fast-forward" << std::endl;
        }
        const annotated_commit_wrapper& commit = commits_to_merge.front();
        const git_oid target_oid = commit.oid();
        // Since this is a fast-forward, there can be only one merge head.
        assert(num_commits_to_merge == 1);
        perform_fastforward(repo, target_oid, (analysis & GIT_MERGE_ANALYSIS_UNBORN));
    }
    else if (analysis & GIT_MERGE_ANALYSIS_NORMAL)
    {
        git_merge_options merge_opts = GIT_MERGE_OPTIONS_INIT;
        git_checkout_options checkout_opts = GIT_CHECKOUT_OPTIONS_INIT;

        merge_opts.flags = 0;
        merge_opts.file_flags = GIT_MERGE_FILE_STYLE_DIFF3;

        checkout_opts.checkout_strategy = GIT_CHECKOUT_FORCE | GIT_CHECKOUT_ALLOW_CONFLICTS;

        if (preference & GIT_MERGE_PREFERENCE_FASTFORWARD_ONLY)
        {
            std::cout << "Fast-forward is preferred, but only a merge is possible\n" << std::endl;
        }

        throw_if_error(git_merge(
            repo,
            (const git_annotated_commit**) c_commits_to_merge,
            num_commits_to_merge,
            &merge_opts,
            &checkout_opts
        ));
    }

    if (index.has_conflict())
    {
        index.output_conflicts();
    }
    else if (!m_no_commit)
    {
        create_merge_commit(repo, index, m_branches_to_merge, commits_to_merge, num_commits_to_merge);
        std::cout << "Merge made" << std::endl;
    }
}