package Gitprep::Main;
use Mojo::Base 'Mojolicious::Controller';
use File::Basename 'dirname';
use Carp 'croak';

sub blob {
  my $self = shift;

  # Parameters
  my $project_ns = $self->param('project');
  my $project = "/$project_ns";
  my $home_ns = dirname $project_ns;
  my $home = "/$home_ns";
  my $id_file = $self->param('id_file');

  # Id and file
  my ($id, $file) = $self->_parse_id_path($project, $id_file);

  # Git
  my $git = $self->app->git;

  # Blob content
  my $bid = $git->id_by_path($project, $id, $file, 'blob')
    or croak 'Cannot find file';
  my @cmd = ($git->cmd($project), 'cat-file', 'blob', $bid);
  open my $fh, '-|', @cmd
    or croak qq/Couldn't cat "$file", "$bid"/;
  
  # Blob plain
  if ($self->stash('plain')) {
    # Content type
    my $type = $git->blob_contenttype($fh, $file);

    # Convert text/* content type to text/plain
    if ($self->config('prevent_xss') &&
      ($type =~ m#^text/[a-z]+\b(.*)$# ||
      ($type =~ m#^[a-z]+/[a-z]\+xml\b(.*)$# && -T $fh)))
    {
      my $rest = $1;
      $rest = defined $rest ? $rest : '';
      $type = "text/plain$rest";
    }

    # File name
    my $file_name = $id;
    if (defined $file) { $file_name = $file }
    elsif ($type =~ m/^text\//) { $file_name .= '.txt' }
    
    # Content
    my $content = do { local $/; <$fh> };
    my $sandbox = $self->config('prevent_xss') &&
      $type !~ m#^(?:text/[a-z]+|image/(?:gif|png|jpeg))(?:[ ;]|$)#;
    my $content_disposition = $sandbox ? 'attachment' : 'inline';
    $content_disposition .= "; filename=$file_name";
    
    # Render
    $self->res->headers->content_disposition($content_disposition);
    $self->res->headers->content_type($type);
    $self->render_data($content);
  }
  
  # Blob
  else {
    # MIME type
    my $mimetype = $git->blob_mimetype($fh, $file);
    
    # Redirect to blob-plain if no display MIME type
    if ($mimetype !~ m#^(?:text/|image/(?:gif|png|jpeg)$)# && -B $fh) {
      close $fh;
      my $url = $self->url_for('blob_plain',
        project => $project_ns, id_file => "$id/$file");
      
      return $self->redirect_to($url);
    }
    
    # Commit
    my $commit = $git->parse_commit($project, $id);

    # Parse line
    my @lines;
    while (my $line = $git->dec(scalar <$fh>)) {
      chomp $line;
      $line = $git->_tab_to_space($line);
      push @lines, $line;
    }
    
    # Render
    $self->render(
      home => $home,
      home_ns => $home_ns,
      project => $project,
      project_ns => $project_ns,
      commit => $commit,
      id => $id,
      file => $file,
      bid => $bid,
      lines => \@lines,
      mimetype => $mimetype
    );
  }
}

sub blobdiff {
  my $self = shift;

  # Parameters
  my $project_ns = $self->param('project');
  my $project = "/$project_ns";
  my $home_ns = dirname $project_ns;
  my $home = "/$home_ns";
  my $diff = $self->param('diff');
  my $file = $self->param('file');
  my $from_file = $self->param('from-file');
  $from_file = $file unless defined $from_file;
  my $plain = $self->param('plain');
  my $from_id;
  my $id;
  if ($diff =~ /\.\./) { ($from_id, $id) = $diff =~ /(.+)\.\.(.+)/ }
  else { $id = $diff }
  
  # Git
  my $git = $self->app->git;

  # Get blob diff (command "git diff")
  open my $fh, '-|', $git->cmd($project), 'diff', '-r', '-M', '-p',
      $from_id, $id, '--', $from_file, $file
    or croak "Open git-diff-tree failed";
  
  # Blob diff plain
  if ($plain) {
    # Content
    my $content = do { local $/; <$fh> };
    close $fh;
    
    # Render
    my $content_disposition .= "inline; filename=$file";
    $self->res->headers->content_disposition($content_disposition);
    $self->res->headers->content_type("text/plain; charset=" . $git->encoding);
    $self->render(data => $content);
  }
  
  # Blob diff
  else {
    # Lines
    my @lines = map { $git->dec($_) } <$fh>;
    close $fh;
    my $lines = $self->_parse_blobdiff_lines(\@lines);
    
    # Commit
    my $commit = $git->parse_commit($project, $id);
    
    # Render
    $self->render(
      '/blobdiff',
      home => $home,
      home_ns => $home_ns,
      project => $project,
      project_ns => $project_ns,
      id => $id,
      from_id => $from_id,
      file => $file,
      from_file => $from_file,
      commit => $commit,
      lines => $lines
    );
  }
}

sub commit {
  my $self = shift;

  # Parameters
  my $project_ns = $self->param('project');
  my $project = "/$project_ns";
  my $home_ns = dirname $project_ns;
  my $home = "/$home_ns";
  my $id = $self->param('id');
  
  # Git
  my $git = $self->app->git;

  # Commit
  my $commit = $git->parse_commit($project, $id);
  my $committer_date
    = $git->parse_date($commit->{committer_epoch}, $commit->{committer_tz});
  my $author_date
    = $git->parse_date($commit->{author_epoch}, $commit->{author_tz});
  $commit->{author_date} = $git->timestamp($author_date);
  $commit->{committer_date} = $git->timestamp($committer_date);
  
  # References
  my $refs = $git->references($project);
  
  # Diff tree
  my $parent = $commit->{parent};
  my $parents = $commit->{parents};
  my $difftrees = $git->difftree($project, $commit->{id}, $parent, $parents);
  
  # Render
  $self->render(
    home => $home,
    home_ns => $home_ns,
    project => $project,
    project_ns => $project_ns,
    id => $id,
    commit => $commit,
    refs => $refs,
    difftrees => $difftrees,
  );
}

sub commitdiff {
  my $self = shift;
  
  # Paramters
  my $project_ns = $self->param('project');
  my $project = "/$project_ns";
  my $home_ns = dirname $project_ns;
  my $home = "/$home_ns";
  my $diff = $self->param('diff');
  my ($from_id, $id) = $diff =~ /(.+)\.\.(.+)/;
  $id = $diff unless defined $id;
  
  # Git
  my $git = $self->app->git;
  
  # Commit
  my $commit = $git->parse_commit($project, $id)
    or croak 'Unknown commit object';
  my $author_date
    = $git->parse_date($commit->{author_epoch}, $commit->{author_tz});
  my $committer_date
    = $git->parse_date($commit->{committer_epoch}, $commit->{committer_tz});
  $commit->{author_date} = $git->timestamp($author_date);
  $commit->{committer_date} = $git->timestamp($committer_date);
  $from_id = $commit->{parent} unless defined $from_id;
  
  # Plain text
  if ($self->param('plain')) {
    # Get blob diffs (command "git diff-tree")
    my @cmd = ($git->cmd($project), 'diff-tree', '-r', '-M',
        '-p', $from_id, $id, '--');
    open my $fh, '-|', @cmd
      or croak 'Open git-diff-tree failed';

    # Content
    my $content = do { local $/; <$fh> };
    my $content_disposition .= "inline; filename=$id";
    
    # Render
    $self->res->headers->content_disposition($content_disposition);
    $self->res->headers->content_type("text/plain;charset=" . $git->encoding);
    $self->render_data($content);
  }
  
  # HTML
  else {
    
    # Diff tree
    my $difftrees = $git->difftree($project,
      $id, $commit->{parent}, $commit->{parents});
    
    # Get blob diffs (command "git diff-tree")
    my @cmd = ($git->cmd($project), 'diff-tree', '-r', '-M',
      '--no-commit-id', '--patch-with-raw', $from_id, $id, '--');
    open my $fh, '-|', @cmd
      or croak 'Open git-diff-tree failed';

    # Parse output
    my @blobdiffs;
    while (my $line = $git->dec(scalar <$fh>)) {
      
      # Parse line
      chomp $line;
      my $diffinfo = $git->parse_difftree_raw_line($line);
      my $from_file = $diffinfo->{from_file};
      my $file = $diffinfo->{to_file};
      
      # Get blobdiff (command "git diff-tree")
      my @cmd = ($git->cmd($project), 'diff-tree', '-r', '-M', '-p',
        $from_id, $id, '--', (defined $from_file ? $from_file : ()), $file);
      open my $fh_blobdiff, '-|', @cmd
        or croak 'Open git-diff-tree failed';
      my @lines = map { $git->dec($_) } <$fh>;
      close $fh_blobdiff;
      my $blobdiff = {
        file => $file,
        from_file => $from_file,
        lines => $self->_parse_blobdiff_lines(\@lines)
      };
      
      # Status
      for my $difftree (@$difftrees) {
        if ($difftree->{to_file} eq $file) {
          $blobdiff->{status} = $difftree->{status};
          last;
        }
      }
      
      push @blobdiffs, $blobdiff;
    }

    # References
    my $refs = $git->references($project);
    
    # Render
    $self->render(
      'commitdiff',
      home => $home,
      home_ns => $home_ns,
      project => $project,
      project_ns => $project_ns,
      from_id => $from_id,
      id => $id,
      commit => $commit,
      difftrees => $difftrees,
      blobdiffs => \@blobdiffs,
      refs => $refs
    );
  }
}

sub home {
  my $self = shift;

  my $rep_home = '/gitpub';
  my @users = qw/kimoto ken/;

  $self->render(users => \@users);
}

sub heads {
  my $self = shift;
  
  # Parameters
  my $project_ns = $self->param('project');
  my $project = "/$project_ns";
  my $home_ns = dirname $project_ns;
  my $home = "/$home_ns";
  
  # Git
  my $git = $self->app->git;
  
  # Ref names
  my $heads  = $git->heads($project);
  
  # Render
  $self->render(
    home => $home,
    home_ns => $home_ns,
    project => $project,
    project_ns => $project_ns,
    heads => $heads,
  );
}

sub log {
  my ($self, %opt) = @_;

  # Parameters
  my $project_ns = $self->param('project');
  my $project = "/$project_ns";
  my $home_ns = dirname $project_ns;
  my $home = "/$home_ns";
  my $id = $self->param('id');
  my $page = $self->param('page');
  $page = 0 if !defined $page;
  my $short = $self->param('short');
  
  # Git
  my $git = $self->app->git;
  
  # Commit
  my $commit = $git->parse_commit($project, $id);
  
  # Commits
  my $page_count = $short ? 50 : 20;
  my $commits = $git->parse_commits(
    $project, $commit->{id},$page_count, $page_count * $page);
  for my $commit (@$commits) {
    my $author_date
      = $git->parse_date($commit->{author_epoch}, $commit->{author_tz});
    $commit->{author_date} = $git->timestamp($author_date);
  }
  
  # References
  my $refs = $git->references($project);

  # Render
  $self->stash->{action} = 'shortlog' if $short;
  $self->render(
    home => $home,
    home_ns => $home_ns,
    project => $project,
    project_ns => $project_ns,
    id => $id,
    commits => $commits,
    refs => $refs,
    page => $page,
    page_count => $page_count
  );
};

has 'root' => '/gitpub';

sub _root_ns {
  my $self = shift;
  
  my $root = $self->root;
  $root =~ s/^\///;
  
  return $root;
}

sub repository {
  my $self = shift;
  
  # Parameters
  my $user = $self->param('user');
  my $repository = $self->param('repository');
  my $root_ns = $self->_root_ns;
  
  my $project_ns = "$root_ns/$user/$repository.git";
  my $project = "/$project_ns";
  my $home_ns = dirname $project_ns;
  my $home = "/$home_ns";
  my $id_dir = $self->param('id_dir') || 'master/';

  # Id and directory
  my ($id, $dir) = $self->_parse_id_path($project, $id_dir);

  # Git
  my $git = $self->app->git;
  
  # Tree id
  my $tid;
  my $commit = $git->parse_commit($project, $id);
  unless (defined $tid) {
    if (defined $dir && $dir ne '') {
      $tid = $git->id_by_path($project, $id, $dir, 'tree');
    }
    else { $tid = $commit->{tree} }
  }
  $self->render_not_found unless defined $tid;

  # Get tree (command "git ls-tree")
  my @entries = ();
  my $show_sizes = 0;
  open my $fh, '-|', $git->cmd($project), 'ls-tree', '-z',
      ($show_sizes ? '-l' : ()), $tid
    or croak 'Open git-ls-tree failed';
  local $/ = "\0";
  @entries = map { chomp; $git->dec($_) } <$fh>;
  close $fh
    or croak 404, "Reading tree failed";
  
  # Parse tree
  my @trees;
  for my $line (@entries) {
    my $tree = $git->parse_ls_tree_line($line, -z => 1, -l => $show_sizes);
    $tree->{mode_str} = $git->_mode_str($tree->{mode});
    push @trees, $tree;
  }
  
  # References
  my $refs = $git->references($project);
  
  # Render
  $self->render(
    home => $home,
    home_ns => $home_ns,
    project => $project,
    project_ns => $project_ns,
    dir => $dir,
    id => $id,
    tid => $tid,
    commit => $commit,
    trees => \@trees,
    refs => $refs
  );
}

sub repositories {
  my $self = shift;

  my $root = $self->root;
  my $user = $self->param('user');
  
  # Repositories
  my $reps = $self->app->git->repositories("/$root/$user");
  
  # Render
  $self->render(reps => $reps);
}

sub snapshot {
  my $self = shift;

  # Parameter
  my $project_ns = $self->param('project');
  my $project = "/$project_ns";
  my $home_ns = dirname $project_ns;
  my $home = "/$home_ns";
  my $id = $self->param('id');
  
  # Git
  my $git = $self->app->git;

  # Object type
  my $type = $git->object_type($project, "$id^{}");
  if (!$type) { croak 404, 'Object does not exist' }
  elsif ($type eq 'blob') { croak 400, 'Object is not a tree-ish' }
  
  my ($name, $prefix) = $git->snapshot_name($project, $id);
  my $file = "$name.tar.gz";
  my $cmd = $self->_quote_command(
    $git->cmd($project), 'archive', "--format=tar", "--prefix=$prefix/", $id
  );
  $cmd .= ' | ' . $self->_quote_command('gzip', '-n');

  $file =~ s/(["\\])/\\$1/g;

  open my $fh, '-|', $cmd
    or croak 'Execute git-archive failed';
  
  # Write chunk
  $self->res->headers->content_type('application/x-tar');
  $self->res->headers->content_disposition(qq/attachment; filename="$file"/);
  my $cb;
  $cb = sub {
    my $c = shift;
    my $size = 500 * 1024;
    my $length = sysread($fh, my $buffer, $size);
    unless (defined $length) {
      close $fh;
      undef $cb;
      return;
    }
    $c->write_chunk($buffer, $cb);
  };
  $self->$cb;
}

sub summary {
  my $self = shift;
  
  # Parameters
  my $project_ns = $self->param('project');
  my $project = "/$project_ns";
  my $home_ns = dirname $project_ns;
  my $home = "/$home_ns";
  
  # Git
  my $git = $self->app->git;
  
  # HEAd commit
  my $project_description = $git->project_description($project);
  my $project_owner = $git->project_owner($project);
  my $head_commit = $git->parse_commit($project, 'HEAD');
  my $committer_date
    = $git->parse_date($head_commit->{committer_epoch}, $head_commit->{committer_tz});
  my $last_change = $git->timestamp($committer_date);
  my $head_id = $head_commit->{id};
  my $urls = $git->project_urls($project);
  
  # Commits
  my $commit_count = 20;
  my $commits = $head_id ? $git->parse_commits($project, $head_id, $commit_count) : ();

  # References
  my $refs = $git->references($project);
  
  # Tags
  my $tag_count = 20;
  my $tags  = $git->tags($project, $tag_count - 1);

  # Heads
  my $head_count = 20;
  my $heads = $git->heads($project, $head_count - 1);
  
  # Render
  $self->render(
    home => $home,
    home_ns => $home_ns,
    project => $project,
    project_ns => $project_ns,
    project_description => $project_description,
    project_owner => $project_owner,
    last_change => $last_change,
    urls => $urls,
    commits => $commits,
    tags => $tags,
    head_id => $head_id,
    heads => $heads,
    refs => $refs,
    commit_count => $commit_count,
    tag_count => $tag_count,
    head_count => $head_count
  );
}

sub tag {
  my $self = shift;
  
  # Parameters
  my $project_ns = $self->param('project');
  my $project = "/$project_ns";
  my $home_ns = dirname $project_ns;
  my $home = "/$home_ns";
  my $id = $self->param('id');
  
  # Git
  my $git = $self->app->git;
  
  # Ref names
  my $tag  = $git->parse_tag($project, $id);
  my $author_date
    = $git->parse_date($tag->{author_epoch}, $tag->{author_tz});
  $tag->{author_date} = $git->timestamp($author_date);
  
  # Render
  $self->render(
    home => $home,
    home_ns => $home_ns,
    project => $project,
    project_ns => $project_ns,
    tag => $tag,
  );
}

sub tags {
  my $self = shift;
  
  # Parameters
  my $project_ns = $self->param('project');
  my $project = "/$project_ns";
  my $home_ns = dirname $project_ns;
  my $home = "/$home_ns";
  
  # Git
  my $git = $self->app->git;
  
  # Ref names
  my $tags  = $git->tags($project);
  
  # Render
  $self->render(
    home => $home,
    home_ns => $home_ns,
    project => $project,
    project_ns => $project_ns,
    tags => $tags,
  );
}

sub tree {
  my $self = shift;
  
  # Parameters
  my $project_ns = $self->param('project');
  my $project = "/$project_ns";
  my $home_ns = dirname $project_ns;
  my $home = "/$home_ns";
  my $id_dir = $self->param('id_dir');

  # Id and directory
  my ($id, $dir) = $self->_parse_id_path($project, $id_dir);

  # Git
  my $git = $self->app->git;
  
  # Tree id
  my $tid;
  my $commit = $git->parse_commit($project, $id);
  unless (defined $tid) {
    if (defined $dir && $dir ne '') {
      $tid = $git->id_by_path($project, $id, $dir, 'tree');
    }
    else { $tid = $commit->{tree} }
  }
  $self->render_not_found unless defined $tid;

  # Get tree (command "git ls-tree")
  my @entries = ();
  my $show_sizes = 0;
  open my $fh, '-|', $git->cmd($project), 'ls-tree', '-z',
      ($show_sizes ? '-l' : ()), $tid
    or croak 'Open git-ls-tree failed';
  local $/ = "\0";
  @entries = map { chomp; $git->dec($_) } <$fh>;
  close $fh
    or croak 404, "Reading tree failed";
  
  # Parse tree
  my @trees;
  for my $line (@entries) {
    my $tree = $git->parse_ls_tree_line($line, -z => 1, -l => $show_sizes);
    $tree->{mode_str} = $git->_mode_str($tree->{mode});
    push @trees, $tree;
  }
  
  # References
  my $refs = $git->references($project);
  
  # Render
  $self->render(
    home => $home,
    home_ns => $home_ns,
    project => $project,
    project_ns => $project_ns,
    dir => $dir,
    id => $id,
    tid => $tid,
    commit => $commit,
    trees => \@trees,
    refs => $refs
  );
}

sub _parse_blobdiff_lines {
  my ($self, $lines_raw) = @_;
  
  # Git
  my $git = $self->app->git;
  
  # Parse
  my @lines;
  for my $line (@$lines_raw) {
    $line = $git->dec($line);
    chomp $line;
    my $class;
    
    if ($line =~ /^diff \-\-git /) { $class = 'diff header' }
    elsif ($line =~ /^index /) { $class = 'diff extended_header' }
    elsif ($line =~ /^\+/) { $class = 'diff to_file' }
    elsif ($line =~ /^\-/) { $class = 'diff from_file' }
    elsif ($line =~ /^\@\@/) { $class = 'diff chunk_header' }
    elsif ($line =~ /^Binary files/) { $class = 'diff binary_file' }
    else { $class = 'diff' }
    push @lines, {value => $line, class => $class};
  }
  
  return \@lines;
}

sub _parse_id_path {
  my ($self, $project, $id_path) = @_;
  
  # Git
  my $git = $self->app->git;
  
  # Parse id and path
  my $refs = $git->references($project);
  my $id;
  my $path;
  for my $rs (values %$refs) {
    for my $ref (@$rs) {
      $ref =~ s#^heads/##;
      $ref =~ s#^tags/##;
      if ($id_path =~ s#^\Q$ref(/|$)##) {
        $id = $ref;
        $path = $id_path;
        last;
      }      
    }
  }
  unless (defined $id) {
    if ($id_path =~ s#(^[^/]+)(/|$)##) {
      $id = $1;
      $path = $id_path;
    }
  }
  
  return ($id, $path);
}

sub _quote_command {
  my $self = shift;
  return join(' ',
    map { my $a = $_; $a =~ s/(['!])/'\\$1'/g; "'$a'" } @_ );
}

1;