#include "../subcommand/tag_subcommand.hpp"

#include <git2.h>

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

{

auto* sub = app.add_subcommand("tag", "Create, list, delete or verify tags");

sub->add_flag("-l,--list", m_list_flag, "List tags. With optional <pattern>.");

sub->add_flag("-f,--force", m_force_flag, "Replace an existing tag with the given name (instead of failing)");

sub->add_option("-d,--delete", m_delete, "Delete existing tags with the given names.");

sub->add_option(

"-n",

m_num_lines,

"<num> specifies how many lines from the annotation, if any, are printed when using -l. Implies --list."

);

sub->add_flag("-a,--annotate", m_annotate_flag, "Make an annotated tag.");

sub->add_option("-m,--message", m_message, "Tag message for annotated tags");

sub->add_option("<tagname>", m_tag_name, "Tag name");

sub->add_option("<commit>", m_target, "Target commit (defaults to HEAD)");

sub->callback(

[this]()

{

this->run();

}

);

}

// Tag listing: Print individual message lines

void print_list_lines(const std::string& message, int num_lines)

{

if (message.empty())

{

return;

}

auto lines = split_input_at_newlines(message);

// header

std::cout << lines[0];

// other lines

if (num_lines <= 1 || lines.size() <= 2)

{

std::cout << std::endl;

}

else

{

for (size_t i = 1; i < lines.size(); i++)

{

if (i < num_lines)

{

std::cout << "\n\t\t" << lines[i];

}

}

}

}

// Tag listing: Print an actual tag object

void print_tag(git_tag* tag, int num_lines)

{

std::cout << std::left << std::setw(16) << git_tag_name(tag);

if (num_lines)

{

std::string msg = git_tag_message(tag);

if (!msg.empty())

{

print_list_lines(msg, num_lines);

}

else

{

std::cout << std::endl;

}

}

else

{

std::cout << std::endl;

}

}

// Tag listing: Print a commit (target of a lightweight tag)

void print_commit(git_commit* commit, std::string name, int num_lines)

{

std::cout << std::left << std::setw(16) << name;

if (num_lines)

{

std::string msg = git_commit_message(commit);

if (!msg.empty())

{

print_list_lines(msg, num_lines);

}

else

{

std::cout << std::endl;

}

}

else

{

std::cout << std::endl;

}

}

// Tag listing: Lookup tags based on ref name and dispatch to print

void each_tag(repository_wrapper& repo, const std::string& name, int num_lines)

{

auto obj = repo.revparse_single(name);

if (obj.has_value())

{

switch (git_object_type(obj.value()))

{

case GIT_OBJECT_TAG:

print_tag(obj.value(), num_lines);

break;

case GIT_OBJECT_COMMIT:

print_commit(obj.value(), name, num_lines);

break;

default:

std::cout << name << std::endl;

}

}

else

{

std::cout << name << std::endl;

}

}

void tag_subcommand::list_tags(repository_wrapper& repo)

{

std::string pattern = m_tag_name.empty() ? "*" : m_tag_name;

auto tag_names = repo.tag_list_match(pattern);

for (const auto& tag_name : tag_names)

{

each_tag(repo, tag_name, m_num_lines);

}

}

void tag_subcommand::delete_tag(repository_wrapper& repo)

{

if (m_delete.empty())

{

throw git_exception("Name required for tag deletion.", git2cpp_error_code::GENERIC_ERROR);

}

auto obj = repo.revparse_single(m_delete);

if (!obj.has_value())

{

throw git_exception("error: tag '" + m_delete + "' not found.", git2cpp_error_code::GENERIC_ERROR);

}

git_buf abbrev_oid = GIT_BUF_INIT;

throw_if_error(git_object_short_id(&abbrev_oid, obj.value()));

std::string oid_str(abbrev_oid.ptr);

git_buf_dispose(&abbrev_oid);

throw_if_error(git_tag_delete(repo, m_delete.c_str()));

std::cout << "Deleted tag '" << m_delete << "' (was " << oid_str << ")" << std::endl;

}

std::optional<object_wrapper> tag_subcommand::get_target_obj(repository_wrapper& repo)

{

if (m_tag_name.empty())

{

throw git_exception("Tag name required", git2cpp_error_code::GENERIC_ERROR);

}

std::string target = m_target.empty() ? "HEAD" : m_target;

auto target_obj = repo.revparse_single(target);

if (!target_obj.has_value())

{

throw git_exception("Unable to resolve target: " + target, git2cpp_error_code::GENERIC_ERROR);

}

return target_obj;

}

void tag_subcommand::handle_error(int error)

{

if (error < 0)

{

if (error == GIT_EEXISTS)

{

throw git_exception("tag '" + m_tag_name + "' already exists", git2cpp_error_code::FILESYSTEM_ERROR);

}

throw git_exception("Unable to create annotated tag", error);

}

}

void tag_subcommand::create_lightweight_tag(repository_wrapper& repo)

{

auto target_obj = tag_subcommand::get_target_obj(repo);

git_oid oid;

size_t force = m_force_flag ? 1 : 0;

int error = git_tag_create_lightweight(&oid, repo, m_tag_name.c_str(), target_obj.value(), force);

handle_error(error);

}

void tag_subcommand::create_tag(repository_wrapper& repo)

{

auto target_obj = tag_subcommand::get_target_obj(repo);

auto tagger = signature_wrapper::get_default_signature_from_env(repo);

git_oid oid;

size_t force = m_force_flag ? 1 : 0;

int error = git_tag_create(

&oid,

repo,

m_tag_name.c_str(),

target_obj.value(),

tagger.first,

m_message.c_str(),

force

);

handle_error(error);

}

void tag_subcommand::run()

{

auto directory = get_current_git_path();

auto repo = repository_wrapper::open(directory);

if (!m_delete.empty())

{

delete_tag(repo);

}

else if (m_list_flag || (m_tag_name.empty() && m_message.empty() && !m_annotate_flag))

{

list_tags(repo);

}

else if (m_annotate_flag)

{

if (m_message.empty())

{

throw git_exception("error: -a/--annotate requires -m/--message", git2cpp_error_code::BAD_ARGUMENT);

}

create_tag(repo);

}

else if (!m_message.empty())

{

create_tag(repo);

}

else if (!m_tag_name.empty())

{

create_lightweight_tag(repo);

}

else

{

list_tags(repo);

}

}