#include "log_subcommand.hpp"

#include <format>

#include <sstream>

#include <string_view>

#include <vector>

#include <git2.h>

#include <git2/oid.h>

#include <git2/refs.h>

#include <git2/types.h>

#include <termcolor/termcolor.hpp>

#include "../utils/terminal_pager.hpp"

log_subcommand::log_subcommand(const libgit2_object&, CLI::App& app)

{

auto* sub = app.add_subcommand("log", "Shows commit logs");

sub->add_option(

"--format",

m_format_flag,

"Pretty-print the contents of the commit logs in a given format, where <format> can be one of full, fuller or oneline"

);

sub->add_option("-n,--max-count", m_max_count_flag, "Limit the output to <number> commits.");

sub->add_flag(

"--abbrev-commit",

m_abbrev_commit_flag,

"Instead of showing the full 40-byte hexadecimal commit object name, show a prefix that names the object uniquely. --abbrev=<n> (which also modifies diff output, if it is displayed) option can be used to specify the minimum length of the prefix."

);

sub->add_option(

"--abbrev",

m_abbrev,

"Instead of showing the full 40-byte hexadecimal object name in diff-raw format output and diff-tree header lines, show the shortest prefix that is at least <n> hexdigits long that uniquely refers the object."

);

sub->add_flag(

"--no-abbrev-commit",

m_no_abbrev_commit_flag,

"Show the full 40-byte hexadecimal commit object name. This negates --abbrev-commit, either explicit or implied by other options such as --oneline."

);

sub->add_flag(

"--oneline",

m_oneline_flag,

"This is a shorthand for --format=oneline --abbrev-commit used together."

);

sub->callback(

[this]()

{

this->run();

}

);

};

void print_time(git_time intime, std::string prefix)

{

char sign, out[32];

struct tm* intm;

int offset, hours, minutes;

time_t t;

offset = intime.offset;

if (offset < 0)

{

sign = '-';

offset = -offset;

}

else

{

sign = '+';

}

hours = offset / 60;

minutes = offset % 60;

t = (time_t) intime.time + (intime.offset * 60);

intm = gmtime(&t);

strftime(out, sizeof(out), "%a %b %e %T %Y", intm);

std::cout << prefix << out << " " << sign << std::format("{:02d}", hours)

<< std::format("{:02d}", minutes) << std::endl;

}

std::vector<std::string> get_tags_for_commit(repository_wrapper& repo, const git_oid& commit_oid)

{

std::vector<std::string> tags;

git_strarray tag_names = {0};

if (git_tag_list(&tag_names, repo) != 0)

{

return tags;

}

for (size_t i = 0; i < tag_names.count; i++)

{

std::string tag_name = tag_names.strings[i];

std::string ref_name = "refs/tags/" + std::string(tag_name);

reference_wrapper tag_ref = repo.find_reference(ref_name);

object_wrapper peeled = tag_ref.peel<object_wrapper>();

if (git_oid_equal(&peeled.oid(), &commit_oid))

{

tags.push_back(std::string(tag_name));

}

}

git_strarray_dispose(&tag_names); // TODO: refactor git_strarray_wrapper to use it here

return tags;

}

std::vector<std::string> get_branches_for_commit(

repository_wrapper& repo,

git_branch_t type,

const git_oid& commit_oid,

const std::string exclude_branch

)

{

std::vector<std::string> branches;

auto branch_iter = repo.iterate_branches(type);

while (auto branch = branch_iter.next())

{

const git_oid* branch_target = nullptr;

git_reference* ref = branch.value();

if (git_reference_type(ref) == GIT_REFERENCE_DIRECT)

{

branch_target = git_reference_target(ref);

}

else if (git_reference_type(ref) == GIT_REFERENCE_SYMBOLIC)

{

git_reference* resolved = nullptr;

if (git_reference_resolve(&resolved, ref) == 0)

{

branch_target = git_reference_target(resolved);

git_reference_free(resolved);

}

}

if (branch_target && git_oid_equal(branch_target, &commit_oid))

{

std::string branch_name(branch->name());

if (type == GIT_BRANCH_LOCAL)

{

if (branch_name != exclude_branch)

{

branches.push_back(branch_name);

}

}

else

{

branches.push_back(branch_name);

}

}

}

return branches;

}

struct commit_refs

{

std::string head_branch;

std::vector<std::string> tags;

std::vector<std::string> local_branches;

std::vector<std::string> remote_branches;

bool has_refs() const

{

return !head_branch.empty() || !tags.empty() || !local_branches.empty() || !remote_branches.empty();

}

};

commit_refs get_refs_for_commit(repository_wrapper& repo, const git_oid& commit_oid)

{

commit_refs refs;

if (!repo.is_head_unborn())

{

auto head = repo.head();

auto head_taget = head.target();

if (git_oid_equal(head_taget, &commit_oid))

{

refs.head_branch = head.short_name();

}

}

refs.tags = get_tags_for_commit(repo, commit_oid);

refs.local_branches = get_branches_for_commit(repo, GIT_BRANCH_LOCAL, commit_oid, refs.head_branch);

refs.remote_branches = get_branches_for_commit(repo, GIT_BRANCH_REMOTE, commit_oid, "");

return refs;

}

void print_refs(const commit_refs& refs)

{

if (!refs.has_refs())

{

return;

}

std::cout << termcolor::yellow;

std::cout << " (";

bool first = true;

if (!refs.head_branch.empty())

{

std::cout << termcolor::bold << termcolor::cyan << "HEAD" << termcolor::reset << termcolor::yellow

<< " -> " << termcolor::reset << termcolor::bold << termcolor::green << refs.head_branch

<< termcolor::reset << termcolor::yellow;

first = false;

}

for (const auto& tag : refs.tags)

{

if (!first)

{

std::cout << ", ";

}

std::cout << termcolor::bold << "tag: " << tag << termcolor::reset << termcolor::yellow;

first = false;

}

for (const auto& remote : refs.remote_branches)

{

if (!first)

{

std::cout << ", ";

}

std::cout << termcolor::bold << termcolor::red << remote << termcolor::reset << termcolor::yellow;

first = false;

}

for (const auto& local : refs.local_branches)

{

if (!first)

{

std::cout << ", ";

}

std::cout << termcolor::bold << termcolor::green << local << termcolor::reset << termcolor::yellow;

first = false;

}

std::cout << ")" << termcolor::reset;

}

void log_subcommand::print_commit(repository_wrapper& repo, const commit_wrapper& commit)

{

const bool abbrev_commit = (m_abbrev_commit_flag || m_oneline_flag) && !m_no_abbrev_commit_flag;

const bool oneline = (m_format_flag == "oneline") || m_oneline_flag;

std::string sha = commit.commit_oid_tostr();

if (abbrev_commit && m_abbrev <= sha.size())

{

sha = sha.substr(0, m_abbrev);

}

commit_refs refs = get_refs_for_commit(repo, commit.oid());

std::string message = commit.message();

while (!message.empty() && message.back() == '\n')

{

message.pop_back();

}

if (oneline)

{

std::string subject;

{

std::istringstream s(message);

std::getline(s, subject);

}

std::cout << termcolor::yellow << sha << termcolor::reset;

print_refs(refs);

if (!subject.empty())

{

std::cout << " " << subject;

}

return;

}

signature_wrapper author = signature_wrapper::get_commit_author(commit);

signature_wrapper committer = signature_wrapper::get_commit_committer(commit);

stream_colour_fn colour = termcolor::yellow;

std::cout << colour << "commit " << sha << termcolor::reset;

print_refs(refs);

std::cout << termcolor::reset << std::endl;

if (m_format_flag == "fuller")

{

std::cout << "Author:\t " << author.name() << " " << author.email() << std::endl;

print_time(author.when(), "AuthorDate: ");

std::cout << "Commit:\t " << committer.name() << " " << committer.email() << std::endl;

print_time(committer.when(), "CommitDate: ");

}

else

{

std::cout << "Author:\t" << author.name() << " " << author.email() << std::endl;

if (m_format_flag == "full")

{

std::cout << "Commit:\t" << committer.name() << " " << committer.email() << std::endl;

}

else

{

print_time(author.when(), "Date:\t");

}

}

std::istringstream message_stream(message);

std::string line;

while (std::getline(message_stream, line))

{

std::cout << "\n " << line;

}

std::cout << std::endl;

}

void log_subcommand::run()

{

auto directory = get_current_git_path();

auto repo = repository_wrapper::open(directory);

// auto branch_name = repo.head().short_name();

if (repo.is_head_unborn())

{

std::cout << "fatal: your current branch 'main' does not have any commits yet" << std::endl;

return;

}

revwalk_wrapper walker = repo.new_walker();

walker.push_head();

terminal_pager pager;

std::size_t i = 0;

git_oid commit_oid;

while (!walker.next(commit_oid) && i < m_max_count_flag)

{

if (i != 0)

{

std::cout << std::endl;

}

commit_wrapper commit = repo.find_commit(commit_oid);

print_commit(repo, commit);

++i;

}

pager.show();

}