# Copyright © 2010 Julian Blake Kongslie <jblake@omgwallhack.org>
# Licensed under the BSD 3-clause license.

package Piny::Repo;

use Moose;
use Moose::Util::TypeConstraints;

use File::Find qw( find );

use Piny::Group;
use Piny::User;

# Types

subtype 'Reponame'
  => as 'Str'
  => where { $_ =~ /^[a-zA-Z0-9][a-zA-Z0-9_.-]*$/ }
  => message { 'That name is not in the correct format for a piny repo.' }
  ;

subtype 'SimpleText'
  => as 'Str'
  => where { $_ =~ /^[\x{0020}-\x{FDCF}\x{FDF0}-\x{FFFD}]{1,80}$/ }
  => message { 'That description is not in the correct format for a piny repo.' }
  ;

# Attributes

has 'name' =>
  ( is        => 'rw'
  , isa       => 'Reponame'
  , trigger   => \&_rename_repo
  , required  => 1
  );

has 'group' =>
  ( is          => 'ro'
  , isa         => 'Piny::Group'
  , lazy_build  => 1
  , init_arg    => undef
  );

has 'path' =>
  ( is          => 'ro'
  , isa         => 'Str'
  , lazy_build  => 1
  , init_arg    => undef
  );

has 'description' =>
  ( is          => 'rw'
  , isa         => 'SimpleText'
  , trigger     => \&_set_description
  , lazy_build  => 1
  , init_arg    => undef
  );

has 'repostat' =>
  ( is          => 'ro'
  , isa         => 'ArrayRef'
  , lazy_build  => 1
  , init_arg    => undef
  );

has 'owner' =>
  ( is          => 'rw'
  , isa         => 'Piny::User'
  , trigger     => \&_change_owner
  , lazy_build  => 1
  , init_arg    => undef
  );

has 'globally_readable' =>
  ( is          => 'ro'
  , isa         => 'Bool'
  , lazy_build  => 1
  , init_arg    => undef
  );

has 'globally_writable' =>
  ( is          => 'ro'
  , isa         => 'Bool'
  , lazy_build  => 1
  , init_arg    => undef
  );

# Public methods

sub add_access {
  my ( $s, @users ) = @_;

  $s->group( )->add_member( @users );
};

sub remove_access {
  my ( $s, @users ) = @_;

  $s->group( )->remove_member( @users );
};

sub has_access {
  my ( $s, $user ) = @_;

  return $s->owner( )->uid( ) == $user->uid( ) or $user->has_group( $s->group( ) );
};

# Triggers

sub _rename_repo {
  my ( $s, $new_name, $old_name ) = @_;

  return unless defined $old_name;

  my $olddir = "/srv/git/$old_name.git";
  my $newdir = "/srv/git/$new_name.git";

  rename( $olddir, $newdir ) or die "Couldn't rename $olddir to $newdir: $!";

  $s->clear_path( );
};

sub _set_description {
  my ( $s, $new_description, $old_description ) = @_;

  return unless defined $old_description;

  open( my $fd, ">", $s->path( ) . "/description" ) or die "Unable to open " . $s->path( ) . "/description for writing: $!";
  print $fd $new_description;
  close( $fd ) or die "Error when closing " . $s->path( ) . "/description: $!";
};

sub _change_owner {
  my ( $s, $new_owner, $old_owner ) = @_;

  return unless defined $old_owner;

  find( { wanted => sub { chown( $new_owner->uid( ), -1, $_ ) or die "Couldn't chown $_: $!"; }, no_chdir => 1 }, $s->path( ) );
};

# Class methods

sub all_repos {
  my ( $class, $dir ) = @_;

  $dir = "/srv/git" unless defined $dir;

  my @ret;

  find( { wanted => sub { if ( /^[^.].*\.git$/ ) { $File::Find::prune = 1; push( @ret, $File::Find::name ); }; } }, $dir );

  @ret = map { s/^\Q$dir\E\/?//; s/\.git$//; $class->new( name => $_ ); } @ret;

  return @ret;
};

# Builder methods

# If constructed with just one argument, then treat it as a repo name.
around BUILDARGS => sub {
  my ( $orig, $class ) = ( shift, shift );

  if ( @_ == 1 && ! ref $_[0] ) {
    return $class->$orig( name => $_[0] );
  } else {
    return $class->$orig( @_ );
  };
};

sub _build_group {
  my ( $s ) = @_;

  return Piny::Group->new( groupname => "git-" . $s->name( ) );
};

sub _build_path {
  my ( $s ) = @_;

  my $dir = "/srv/git/" . $s->name( ) . ".git";

  if ( -d $dir ) {
    return $dir;
  } else {
    die "Expected repo $dir does not exist!";
  };
};

sub _build_description {
  my ( $s ) = @_;

  open( my $d, "<", $s->path( ) . "/description" ) or die "Unable to open " . $s->path( ) . "/description: $!";
  my $desc;
  {
    local $/ = undef;
    $desc = <$d>;
  };
  close( $d );

  return $desc;
};

sub _build_repostat {
  my ( $s ) = @_;

  my @res = stat( $s->path( ) );
  die "stat( " . $s->path( ) . " ) failed: $!" unless @res;
  return \@res;
};

sub _build_owner {
  my ( $s ) = @_;

  my ( $uid ) = $s->repostat( )->[4];

  return Piny::User->new( uid => $uid );
};

sub _build_globally_readable {
  my ( $s ) = @_;

  return ( $s->repostat( )->[2] & 0444 ) == 0444;
};

sub _build_globally_writable {
  my ( $s ) = @_;

  return ( $s->repostat( )->[2] & 0111 ) == 0111;
};

# Moose boilerplate

__PACKAGE__->meta->make_immutable;

1;