package Gitprep::Git;

use Mojo::Base -base;

use Carp 'croak';

use Encode qw/encode decode/;

use Encode::Guess;

use Fcntl ':mode';

use File::Basename qw/basename dirname/;

use File::Copy 'move';

use File::Find 'find';

use File::Path qw/mkpath rmtree/;

use POSIX 'floor';

use Gitprep::Util;

# Attributes

has 'bin';

has default_encoding => 'UTF-8';

has text_exts => sub { ['txt'] };

has 'time_zone_second';

has 'app';

sub current_branch {

  my ($self, $rep_info) = @_;

  my @cmd = $self->cmd($rep_info, 'rev-parse',  '--abbrev-ref', 'HEAD');

  open my $fh, '-|', @cmd

    or croak "Can't get current branch: @cmd";

  my $current_branch = <$fh>;

  chomp $current_branch;

  return $current_branch;

}

sub branch_names {

  my ($self, $rep_info) = @_;

  # Branch names

  my @cmd = $self->cmd($rep_info, 'branch');

  open my $fh, '-|', @cmd or return;

  my @lines = <$fh>;

  my @branch_names;

  for my $branch_name (@lines) {

    chomp $branch_name;

    $branch_name =~ s/^\*//;

    $branch_name =~ s/^\s*//;

    $branch_name =~ s/\s*$//;

    push @branch_names, $branch_name;

  }

  return \@branch_names;

}

sub branch {

  my ($self, $rep_info, $branch_name) = @_;

  # Branch

  $branch_name =~ s/^\*//;

  $branch_name =~ s/^\s*//;

  $branch_name =~ s/\s*$//;

  my $branch = {};

  $branch->{name} = $branch_name;

  my $commit = $self->get_commit($rep_info, $branch_name);

  $branch->{commit} = $commit;

  return $branch;

}

sub branch_status {

  my ($self, $rep_info, $branch1, $branch2) = @_;

  # Branch status

  my $status = {ahead => 0, behind => 0};

  my @cmd = $self->cmd(

    $rep_info,

    'rev-list',

    '--left-right',

    "$branch1...$branch2"

  );

  open my $fh, '-|', @cmd

    or croak "Can't get branch status: @cmd";

  while (my $line = <$fh>) {

    if ($line =~ /^</) { $status->{behind}++ }

    elsif ($line =~ /^>/) { $status->{ahead}++ }

  }

  return $status;

}

sub no_merged_branch_h {

  my ($self, $rep_info) = @_;

  # No merged branches

  my $no_merged_branches_h = {};

  {

    my @cmd = $self->cmd($rep_info, 'branch', '--no-merged');

    open my $fh, '-|', @cmd or return;

    my @lines = <$fh>;

    for my $branch_name (@lines) {

      $branch_name = $self->_dec($branch_name);

      $branch_name =~ s/^\*//;

      $branch_name =~ s/^\s*//;

      $branch_name =~ s/\s*$//;

      $no_merged_branches_h->{$branch_name} = 1;

    }

  }

  return $no_merged_branches_h;

}

sub branches {

  my ($self, $rep_info) = @_;

  # Branches

  my @cmd = $self->cmd($rep_info, 'branch');

  open my $fh, '-|', @cmd or return;

  my $branches = [];

  my $start;

  my $no_merged_branches_h;

  my @lines = <$fh>;

  for my $branch_name (@lines) {

    $branch_name = $self->_dec($branch_name);

    $branch_name =~ s/^\*//;

    $branch_name =~ s/^\s*//;

    $branch_name =~ s/\s*$//;

    # No merged branch

    $no_merged_branches_h = $self->no_merged_branch_h($rep_info)

      unless $start++;

    # Branch

    my $branch = $self->branch($rep_info, $branch_name);

    $branch->{no_merged} = 1 if $no_merged_branches_h->{$branch_name};

    push @$branches, $branch;

  }

  @$branches = sort { $a->{commit}{age} <=> $b->{commit}{age} } @$branches;

  return $branches;

}

sub branches_count {

  my ($self, $rep_info) = @_;

  # Branches count

  my @cmd = $self->cmd($rep_info, 'branch');

  open my $fh, '-|', @cmd or return;

  my @branches = <$fh>;

  my $branches_count = @branches;

  return $branches_count;

}

sub cmd {

  my ($self, $rep_info, @command) = @_;

  my $git_dir = $rep_info->{git_dir};

  my $work_tree = $rep_info->{work_tree};

  my @command_all = ($self->bin);

  if (defined $git_dir) {

    push @command_all, "--git-dir=$git_dir";

  }

  if (defined $work_tree) {

    push @command_all, "--work-tree=$work_tree";

  }

  push @command_all, @command;

  return @command_all;

}

sub authors {

  my ($self, $rep_info, $rev, $file) = @_;

  # Authors

  my @cmd = $self->cmd(

    $rep_info,

    'log',

    '--format=%an',

    $rev,

    '--',

    $file

  );

  open my $fh, "-|", @cmd

    or croak 500, "Open git-cat-file failed";

  my $authors = {};

  my @lines = <$fh>;

  for my $line (@lines) {

    $line = $self->_dec($line);

    $line =~ s/[\r\n]//g;

    $authors->{$line} = 1;

  }

  return [sort keys %$authors];

}

sub blame {

  my ($self, $rep_info, $rev, $file) = @_;

  # Git blame

  my @cmd = $self->cmd(

    $rep_info,

    'blame',

    '--line-porcelain',

    $rev,

    '--',

    $file

  );

  open my $fh, '-|', @cmd

    or croak "Can't git blame --line-porcelain";

  # Format lines

  my $blame_lines = [];

  my $blame_line;

  my $max_author_time;

  my $min_author_time;

  my @lines = <$fh>;

  my $enc = $self->decide_encoding($rep_info, \@lines);

  for my $line (@lines) {

    $line = decode($enc, $line);

    chomp $line;

    if ($blame_line) {

      if ($line =~ /^author +(.+)/) {

        $blame_line->{author} = $1;

      }

      elsif ($line =~ /^author-mail +(.+)/) {

        $blame_line->{author_email} = $1;

      }

      elsif ($line =~ /^author-time +(.+)/) {

        my $author_time = $1;

        $blame_line->{author_time} = $author_time;

        $max_author_time = $author_time if !$max_author_time || $author_time > $max_author_time;

        $min_author_time = $author_time if !$min_author_time || $author_time < $min_author_time;

        my $author_age_string_date = $self->_age_string_date($author_time);

        $blame_line->{author_age_string_date} = $author_age_string_date;

        my $author_age_string_date_local = $self->_age_string_date_local($author_time);

        $blame_line->{author_age_string_date_local} = $author_age_string_date_local;

      }

      elsif ($line =~ /^summary +(.+)/) {

        $blame_line->{summary} = $1;

      }

      elsif ($line =~ /^\t(.+)?/) {

        my $content = $1;

        $content = '' unless defined $content;

        $blame_line->{content} = $content;

        push @$blame_lines, $blame_line;

        $blame_line = undef;

      }

    }

    elsif ($line =~ /^([a-fA-F0-9]{40}) +\d+ +(\d+)/) {

      $blame_line = {};

      $blame_line->{commit} = $1;

      $blame_line->{number} = $2;

      if ($blame_lines->[-1]

        && $blame_lines->[-1]{commit} eq $blame_line->{commit})

      {

        $blame_line->{before_same_commit} = 1;

      }

    }

  }

  my $blame = {

    lines => $blame_lines,

    max_author_time => $max_author_time,

    min_author_time => $min_author_time

  };

  return $blame;

}

sub blob {

  my ($self, $rep_info, $rev, $file) = @_;

  # Blob

  my $hash = $self->path_to_hash($rep_info, $rev, $file, 'blob')

    or croak 'Cannot find file';

  my @cmd = $self->cmd(

    $rep_info,

    'cat-file',

    'blob',

    $hash

  );

  open my $fh, '-|', @cmd

    or croak "Can't cat $file, $hash";

  # Format lines

  my @lines = <$fh>;

  my @new_lines;

  my $enc = $self->decide_encoding($rep_info, \@lines);

  for my $line (@lines) {

    $line = decode($enc, $line);

    chomp $line;

    push @new_lines, $line;

  }

  return \@new_lines;

}

sub blob_diffs {

  my ($self, $rep_info, $rev1, $rev2, $diff_trees, $opt) = @_;

  $opt //= {};

  my $ignore_space_change = $opt->{ignore_space_change};

  return unless defined $rev1 && defined $rev2;

  # Diff tree

  my @cmd = $self->cmd(

    $rep_info,

    'diff-tree',

    '-r',

    '-M',

    '--no-commit-id',

    '--patch-with-raw',

    ($ignore_space_change ? '--ignore-space-change' : ()),

    $rev1,

    $rev2,

    '--'

  );

  open my $fh, '-|', @cmd

    or croak('Open self-diff-tree failed');

  my @diff_tree;

  my @diff_tree_lines = <$fh>;

  my $diff_tree_enc = $self->decide_encoding($rep_info, \@diff_tree_lines);

  for my $line (@diff_tree_lines) {

    $line = decode($diff_tree_enc, $line);

    chomp $line;

    push @diff_tree, $line if $line =~ /^:/;

    last if $line =~ /^\n/;

  }

  close $fh;

  # Blob diffs

  my $blob_diffs = [];

  for my $line (@diff_tree) {

    # File information

    chomp $line;

    my $diffinfo = $self->parse_diff_tree_line($line);

    my $from_file = $diffinfo->{from_file};

    my $file = $diffinfo->{to_file};

    # Blob diff

    my @cmd = $self->cmd(

      $rep_info,

      'diff-tree',

      '-r',

      '-M',

      '-p',

      ($ignore_space_change ? '--ignore-space-change' : ()),

      $rev1,

      $rev2,

      '--',

      (defined $from_file ? $from_file : ()),

      $file

    );

    open my $fh, '-|', @cmd

      or croak('Open self-diff-tree failed');

    my @lines = <$fh>;

    my $enc = $self->decide_encoding($rep_info, \@lines);

    @lines = map { decode($enc, $_) } @lines;

    close $fh;

    my ($lines, $diff_info) = $self->parse_blob_diff_lines(\@lines);

    my $blob_diff = {

      file => $file,

      from_file => $from_file,

      lines => $lines,

      add_line_count => $diff_info->{add_line_count},

      delete_line_count => $diff_info->{delete_line_count},

      binary => $diff_info->{binary}

    };

    # Diff tree info

    for my $diff_tree (@$diff_trees) {

      if ($diff_tree->{to_file} eq $file) {

        $blob_diff->{status} = $diff_tree->{status};

        $diff_tree->{add_line_count} = $diff_info->{add_line_count};

        $diff_tree->{delete_line_count} = $diff_info->{delete_line_count};

        $diff_tree->{add_block_count} = $diff_info->{add_block_count};

        $diff_tree->{delete_block_count} = $diff_info->{delete_block_count};

        $diff_tree->{binary} = $diff_info->{binary};

        last;

      }

    }

    push @$blob_diffs, $blob_diff;

  }

  return $blob_diffs;

}

sub blob_is_image {

  my $self = shift;

  my $mime_type = $self->blob_mime_type(@_);

  return ($mime_type || '') =~ m#^image/#;

}

sub blob_mime_type {

  my ($self, $rep_info, $rev, $file) = @_;

  # Blob

  my $hash = $self->path_to_hash($rep_info, $rev, $file, 'blob')

    or croak 'Cannot find file';

  my @cmd = $self->cmd(

    $rep_info,

    'cat-file',

    'blob',

    $hash

  );

  open my $fh, '-|', @cmd

    or croak "Can't cat $file, $hash";

  return 'text/plain' unless $fh;

  # MIME type

  my $text_exts = $self->text_exts;

  for my $text_ext (@$text_exts) {

    my $ext = quotemeta($text_ext);

    return 'text/plain' if $file =~ /\.$ext$/i;

  }

  if (-T $fh) { return 'text/plain' }

  elsif (! $file) { return 'application/octet-stream' }

  elsif ($file =~ m/\.png$/i) { return 'image/png' }

  elsif ($file =~ m/\.gif$/i) { return 'image/gif' }

  elsif ($file =~ m/\.jpe?g$/i) { return 'image/jpeg'}

  else { return 'application/octet-stream'}

  return;

}

sub blob_content_type {

  my $self = shift;

  # Content type

  my $type = $self->blob_mime_type(@_);

  if ($type eq 'text/plain') {

    $type .= "; charset=" . $self->default_encoding;

  }

  return $type;

}

sub blob_mode {

  my ($self, $rep_info, $rev, $file) = @_;

  # Blob mode

  $file =~ s#/+$##;

  my @cmd = $self->cmd(

    $rep_info,

    'ls-tree',

    $rev,

    '--',

    $file

  );

  open my $fh, '-|', @cmd

    or croak 'Open git-ls-tree failed';

  my $line = <$fh>;

  $line = $self->_dec($line);

  close $fh or return;

  my ($mode) = ($line || '') =~ m/^([0-9]+) /;

  return $mode;

}

sub blob_raw {

  my ($self, $rep_info, $rev, $path) = @_;

  # Blob raw

  my @cmd = $self->cmd($rep_info, 'cat-file', 'blob', "$rev:$path");

  open my $fh, "-|", @cmd

    or croak 500, "Open git-cat-file failed";

  local $/;

  my $blob_raw = <$fh>;

  close $fh or croak 'Reading git-shortlog failed';

  return $blob_raw;

}

sub blob_size {

  my ($self, $rep_info, $rev, $file) = @_;

  # Blob size(KB)

  my @cmd = $self->cmd(

    $rep_info,

    'cat-file',

    '-s',

    "$rev:$file"

  );

  open my $fh, "-|", @cmd

    or croak 500, "Open cat-file failed";

  my $size = <$fh>;

  $size = $self->_dec($size);

  chomp $size;

  close $fh or croak 'Reading cat-file failed';

  # Format

  my $size_f = sprintf('%.3f', $size / 1000);

  $size_f =~ s/0+$//;

  return $size_f;

}

sub check_head_link {

  my ($self, $dir) = @_;

  # Chack head

  my $head_file = "$dir/HEAD";

  return ((-e $head_file) ||

    (-l $head_file && readlink($head_file) =~ /^refs\/heads\//));

}

sub commits_number {

  my ($self, $rep_info, $ref) = @_;

  # Command "git diff-tree"

  my @cmd = $self->cmd($rep_info, 'shortlog', '-s', $ref);

  open my $fh, "-|", @cmd

    or croak 500, "Open git-shortlog failed";

  my @commits_infos = <$fh>;

  @commits_infos = map { chomp; $self->_dec($_) } @commits_infos;

  close $fh or croak 'Reading git-shortlog failed';

  my $commits_num = 0;

  for my $commits_info (@commits_infos) {

    if ($commits_info =~ /^ *([0-9]+)/) {

      $commits_num += $1;

    }

  }

  return $commits_num;

}

sub exists_branch {

  my ($self, $rep) = @_;

  # Exists branch

  my @cmd = $self->cmd($rep, 'branch');

  open my $fh, "-|", @cmd

    or croak 'git branch failed';

  local $/;

  my $branch = <$fh>;

  return $branch ne '' ? 1 : 0;

}

sub delete_branch {

  my ($self, $rep, $branch) = @_;

  my $branches = $self->branches($rep);

  my $exists;

  for my $b (@$branches) {

    if ($branch eq $b->{name}) {

      $exists = 1;

      next;

    }

  }

  if ($exists) {

    my @cmd = $self->cmd($rep, 'branch', '-D', $branch);

    Gitprep::Util::run_command(@cmd)

      or croak "Branch deleting failed. Can't delete branch $branch";

  }

  else {

    croak "Branch deleteting failed.. branchg $branch is not exists";

  }

}

sub description {

  my ($self, $rep, $description) = @_;

  my $git_dir = $rep->{git_dir};

  my $file = "$git_dir/description";

  if (defined $description) {

    # Write description

    open my $fh, '>',$file

      or croak "Can't open file $rep: $!";

    print $fh encode('UTF-8', $description)

      or croak "Can't write description: $!";

    close $fh;

  }

  else {

    # Read description

    return unless -f $file;

    my $description = $self->_slurp($file) || '';

    $description = $self->_dec($description);

    return $description;

  }

}

sub diff_tree {

  my ($self, $rep_info, $rev, $parent, $opt) = @_;

  $opt ||= {};

  my $ignore_space_change = $opt->{ignore_space_change};

  # Root

  $parent = '--root' unless defined $parent;

  # Get diff tree

  my @cmd = $self->cmd(

    $rep_info,

    "diff-tree",

    '-r',

    '--no-commit-id',

    '-M',

    ($ignore_space_change ? '--ignore-space-change' : ()),

    $parent,

    $rev,

    '--'

  );

  open my $fh, "-|", @cmd

    or croak 500, "Open git-diff-tree failed";

  my @diff_tree = <$fh>;

  @diff_tree = map { chomp; $self->_dec($_) } @diff_tree;

  close $fh or croak 'Reading git-diff-tree failed';

  # Parse "git diff-tree" output

  my $diffs = [];

  for my $line (@diff_tree) {

    my $diff = $self->parsed_diff_tree_line($line);

    my ($to_mode_oct, $to_mode_str, $to_file_type);

    my ($from_mode_oct, $from_mode_str, $from_file_type);

    if ($diff->{to_mode} ne ('0' x 6)) {

      $to_mode_oct = oct $diff->{to_mode};

      if (S_ISREG($to_mode_oct)) { # only for regular file

        $to_mode_str = sprintf('%04o', $to_mode_oct & 0777); # permission bits

      }

      $to_file_type = $self->file_type($diff->{to_mode});

    }

    if ($diff->{from_mode} ne ('0' x 6)) {

      $from_mode_oct = oct $diff->{from_mode};

      if (S_ISREG($from_mode_oct)) { # only for regular file

        $from_mode_str = sprintf('%04o', $from_mode_oct & 0777); # permission bits

      }

      $from_file_type = $self->file_type($diff->{from_mode});

    }

    $diff->{to_mode_str} = $to_mode_str;

    $diff->{to_mode_oct} = $to_mode_oct;

    $diff->{to_file_type} = $to_file_type;

    $diff->{from_mode_str} = $from_mode_str;

    $diff->{from_mode_oct} = $from_mode_oct;

    $diff->{from_file_type} = $from_file_type;

    push @$diffs, $diff;

  }

  return $diffs;

}

sub file_type {

  my ($self, $mode) = @_;

  # File type

  if ($mode !~ m/^[0-7]+$/) { return $mode }

  else { $mode = oct $mode }

  if ($self->_s_isgitlink($mode)) { return 'submodule' }

  elsif (S_ISDIR($mode & S_IFMT)) { return 'directory' }

  elsif (S_ISLNK($mode)) { return 'symlink' }

  elsif (S_ISREG($mode)) { return 'file' }

  else { return 'unknown' }

  return

}

sub file_type_long {

  my ($self, $mode) = @_;

  # File type long

  if ($mode !~ m/^[0-7]+$/) { return $mode }

  else { $mode = oct $mode }

  if ($self->_s_isgitlink($mode)) { return 'submodule' }

  elsif (S_ISDIR($mode & S_IFMT)) { return 'directory' }

  elsif (S_ISLNK($mode)) { return 'symlink' }

  elsif (S_ISREG($mode)) {

    if ($mode & S_IXUSR) { return 'executable file' }

    else { return 'file' }

  }

  else { return 'unknown' }

  return;

}

sub forward_commits {

  my ($self, $rep_info, $rev1, $rev2) = @_;

  # Forwarding commits

  my @cmd = $self->cmd(

    $rep_info,

    'rev-list',

    '--left-right',

    "$rev1...$rev2"

  );

  open my $fh, '-|', @cmd

    or croak "Can't get info: @cmd";

  my $commits = [];

  while (my $line = <$fh>) {

    if ($line =~ /^>(.+)\s/) {

      my $rev = $1;

      my $commit = $self->get_commit($rep_info, $rev);

      push @$commits, $commit;

    }

  }

  return $commits;

}

sub path_to_hash {

  my ($self, $rep_info, $rev, $path, $type) = @_;

  # Get blob id or tree id (command "git ls-tree")

  $path =~ s#/+$##;

  my @cmd = $self->cmd(

    $rep_info,

    'ls-tree',

    $rev,

    '--',

    $path

  );

  open my $fh, '-|', @cmd

    or croak 'Open git-ls-tree failed';

  my $line = <$fh>;

  $line = $self->_dec($line);

  close $fh or return;

  my ($t, $id) = ($line || '') =~ m/^[0-9]+ (.+) ([0-9a-fA-F]{40})\t/;

  $t ||= '';

  return if defined $type && $type ne $t;

  return $id;

}

sub last_activity {

  my ($self, $rep) = @_;

  # Command "git for-each-ref"

  my @cmd = $self->cmd(

    $rep,

    'for-each-ref',

    '--format=%(committer)',

    '--sort=-committerdate',

    '--count=1', 'refs/heads'

  );

  open my $fh, '-|', @cmd or return;

  my $most_recent = <$fh>;

  $most_recent = $self->_dec($most_recent);

  close $fh or return;

  # Parse most recent

  if (defined $most_recent &&

      $most_recent =~ / (\d+) [-+][01]\d\d\d$/) {

    my $timestamp = $1;

    my $age = time - $timestamp;

    return ($age, $self->_age_string($age));

  }

  return;

}

sub parse_rev_path {

  my ($self, $rep_info, $rev_path) = @_;

  # References

  my @cmd = $self->cmd(

    $rep_info,

    'show-ref',

    '--dereference'

  );

  open my $fh, '-|', @cmd

    or return;

  my $refs = [];

  my @lines = <$fh>;

  for my $line (@lines) {

    $line = $self->_dec($line);

    chomp $line;

    if ($line =~ m!^[0-9a-fA-F]{40}\s(refs/((?:heads|tags)/(.*)))$!) {

      push @$refs, $1, $2, $3;

    }

  }

  close $fh or return;

  @$refs = sort {

    my @a_match = $a =~ /(\/)/g;

    my @b_match = $b =~ /(\/)/g;

    scalar @b_match <=> scalar @a_match;

  } @$refs;

  for my $ref (@$refs) {

    $rev_path =~ m#/$#;

    if ($rev_path =~ m#^(\Q$ref\E)/(.+)#) {

      my $rev = $1;

      my $path = $2;

      return ($rev, $path);

    }

    elsif ($rev_path eq $ref) {

      return ($rev_path, '');

    }

  }

  if ($rev_path) {

    my ($rev, $path) = split /\//, $rev_path, 2;

    $path = '' unless defined $path;

    return ($rev, $path);

  }

  return;

}

sub object_type {

  my ($self, $rep_info, $rev) = @_;

  # Get object type

  my @cmd = $self->cmd(

    $rep_info,

    'cat-file',

    '-t',

    $rev

  );

  open my $fh, '-|', @cmd  or return;

  my $type = <$fh>;

  $type = $self->_dec($type);

  close $fh or return;

  chomp $type;

  return $type;

}

sub repository {

  my ($self, $rep_info) = @_;

  return unless -d $rep_info->{git_dir};

  my $rep = {};

  my @activity = $self->last_activity($rep_info);

  if (@activity) {

    $rep->{age} = $activity[0];

    $rep->{age_string} = $activity[1];

  }

  else { $rep->{age} = 0 }

  my $description = $self->description($rep_info) || '';

  $rep->{description} = $self->_chop_str($description, 25, 5);

  return $rep;

}

sub references {

  my ($self, $rep_info, $type) = @_;

  $type ||= '';

  # Branches or tags

  my @cmd = $self->cmd(

    $rep_info,

    'show-ref',

    '--dereference',

    (

      $type eq 'heads' ? ('--heads') :

      $type eq 'tags' ? ('--tags') :

      ()

    )

  );

  open my $fh, '-|', @cmd

    or return;

  # Parse references

  my %refs;

  my $type_re = $type ? $type : '(?:heads|tags)';

  my @lines = <$fh>;

  for my $line (@lines) {

    $line = $self->_dec($line);

    chomp $line;

    if ($line =~ m!^([0-9a-fA-F]{40})\srefs/$type_re/(.*)$!) {

      my $rev = $1;

      my $ref = $2;

      $ref =~ s/\^\{\}//;

      if (defined $refs{$rev}) { push @{$refs{$rev}}, $ref }

      else { $refs{$rev} = [$ref] }

    }

  }

  close $fh or return;

  return \%refs;

}

sub short_id {

  my ($self, $project) = (shift, shift);

  # Short id

  return $self->id($project, @_, '--short=7');

}

sub tags_count {

  my ($self, $rep_info) = @_;

  my $limit = 1000;

  # Get tags

  my @cmd = $self->cmd(

    $rep_info,

    'for-each-ref',

    ($limit ? '--count='.($limit+1) : ()),

    'refs/tags'

  );

  open my $fh, '-|', @cmd or return;

  # Tags count

  my @lines = <$fh>;

  return scalar @lines;

}

sub tags {

  my ($self, $rep_info, $limit, $count, $offset) = @_;

  $limit ||= 1000;

  $count ||= 50;

  $offset ||= 0;

  # Get tags

  my @cmd = $self->cmd(

    $rep_info,

    'for-each-ref',

    ($limit ? '--count='.($limit+1) : ()),

    '--sort=-creatordate',

    '--format=%(objectname) %(objecttype) %(refname) '

      . '%(*objectname) %(*objecttype) %(subject)%00%(creator)',

    'refs/tags'

  );

  open my $fh, '-|', @cmd or return;

  # Parse Tags

  my @tags;

  my $line_num = 1;

  my @lines = <$fh>;

  for my $line (@lines) {

    $line = $self->_dec($line);

    if ($line_num > $offset && $line_num < $offset + $count + 1) {

      my %tag;

      chomp $line;

      my ($refinfo, $creatorinfo) = split(/\0/, $line);

      my ($id, $type, $name, $refid, $reftype, $title) = split(' ', $refinfo, 6);

      my ($creator, $epoch, $tz) =

        ($creatorinfo =~ /^(.*) ([0-9]+) (.*)$/);

      $tag{fullname} = $name;

      $name =~ s!^refs/tags/!!;

      $tag{type} = $type;

      $tag{id} = $id;

      $tag{name} = $name;

      if ($type eq 'tag') {

        $tag{subject} = $title;

        $tag{reftype} = $reftype;

        $tag{refid}   = $refid;

      } else {

        $tag{reftype} = $type;

        $tag{refid}   = $id;

      }

      if ($type eq 'tag' || $type eq 'commit') {

        $tag{epoch} = $epoch;

        if ($epoch) {

          $tag{age} = $self->_age_string(time - $tag{epoch});

        } else {

          $tag{age} = 'unknown';

        }

      }

      $tag{comment_short} = $self->_chop_str($tag{subject}, 30, 5)

        if $tag{subject};

      $tag{commit} = $self->get_commit($rep_info, $name);

      push @tags, \%tag;

    }

    $line_num++;

  }

  close $fh;

  return \@tags;

}

sub last_change_commit {

  my ($self, $rep_info, $rev, $file) = @_;

  my $commit_log = {};

  $file = '' unless defined $file;

  my @cmd = $self->cmd(

    $rep_info,

    '--no-pager',

    'log',

    '-n',

    '1',

    '--pretty=format:%H', 

    $rev,

    '--',

    $file

  );

  open my $fh, '-|', @cmd

    or croak 'Open git-log failed';

  local $/;

  my $commit_log_text = <$fh>;

  $commit_log_text = $self->_dec($commit_log_text);

  my $commit;

  if ($commit_log_text =~ /^([0-9a-zA-Z]+)/) {

    my $rev = $1;

    $commit = $self->get_commit($rep_info, $rev);

  }

  return $commit;

}

sub parse_blob_diff_lines {

  my ($self, $lines) = @_;

  my $diff_info = {};

  # Parse

  my @lines;

  my $next_before_line_num;

  my $next_after_line_num;

  my $add_line_count = 0;

  my $delete_line_count = 0;

  for my $line (@$lines) {

    chomp $line;

    my $class;

    my $before_line_num;

    my $after_line_num;

    if ($line =~ /^@@\s-(\d+)(?:,\d+)?\s\+(\d+)/) {

      $next_before_line_num = $1;

      $next_after_line_num = $2;

      $before_line_num = '...';

      $after_line_num = '...';

      $class = 'chunk_header';

    }

    elsif ($line =~ /^\+\+\+/ || $line =~ /^---/) { next }