package SL::File::Backend::Filesystem;

use strict;

use parent qw(SL::File::Backend);
use SL::DB::File;
use SL::DB::FileVersion;

use Carp;
use List::Util qw(first);

use File::Copy;
use File::Slurp;
use File::stat;
use File::Path qw(make_path);
use UUID::Tiny ':std';

#
# public methods
#

sub delete {
  my ($self, %params) = @_;
  die "no dbfile in backend delete" unless $params{dbfile};
  my @versions = @{$params{dbfile}->file_versions_sorted};

  my @versions_to_delete;
  if ($params{last}) {
    my $last = pop @versions;
    @versions_to_delete = ($last);
  } elsif ($params{all_but_notlast}) {
    pop @versions; # remove last
    @versions_to_delete = @versions;
  } elsif ($params{version}) {
    my $version = first {$_->version == $params{version}} @versions
      or confess "Version not found.";
    @versions_to_delete = ($version);
  } else {
    @versions_to_delete = @versions;
  }

  foreach my $version (@versions_to_delete) {
    unlink($version->get_system_location());
    $version->delete;
  }

  return 1;
}

sub save {
  my ($self, %params) = @_;

  die 'dbfile not exists' unless ref $params{dbfile} eq 'SL::DB::File';
  die 'no file contents'  unless $params{file_path} || $params{file_contents};

  my $dbfile = delete $params{dbfile};

  # Do not save and do not create a new version of the document if file size of last version is the same.
  if ($dbfile->source eq 'created' && $self->get_version_count(dbfile => $dbfile)) {
    my $new_file_size  = $params{file_path} ? stat($params{file_path})->size : length($params{file_contents});
    my $last_file_size = stat($self->_filesystem_path($dbfile))->size;

    return 1 if $last_file_size == $new_file_size;
  }

  my @versions = @{$dbfile->file_versions_sorted};
  my $new_version_number = scalar @versions ? $versions[-1]->version + 1 : 1;

  my $tofile = $self->_filesystem_path($dbfile, $new_version_number);
  if ($params{file_path} && -f $params{file_path}) {
    File::Copy::copy($params{file_path}, $tofile);
  } elsif ($params{file_contents}) {
    open(OUT, "> " . $tofile);
    print OUT $params{file_contents};
    close(OUT);
  }

  # save file version
  my $doc_path = $::lx_office_conf{paths}->{document_path};
  my $rel_file = $tofile;
  $rel_file    =~ s/$doc_path//;
  my $fv = SL::DB::FileVersion->new(
    file_id       => $dbfile->id,
    version       => $new_version_number,
    file_location => $rel_file,
    doc_path      => $doc_path,
    backend       => 'Filesystem',
    guid          => create_uuid_as_string(UUID_V4),
  )->save;

  if ($params{mtime}) {
    utime($params{mtime}, $params{mtime}, $tofile);
  }
  return 1;
}

sub get_version_count {
  my ($self, %params) = @_;
  die "no dbfile" unless $params{dbfile};
  my $file_id = $params{dbfile}->id;
  return 0 unless defined $file_id;
  return SL::DB::Manager::FileVersion->get_all_count(where => [file_id => $file_id]);
}

sub get_mtime {
  my ($self, %params) = @_;
  my $path = $self->get_filepath(%params);

  my $dt = DateTime->from_epoch(epoch => stat($path)->mtime, time_zone => $::locale->get_local_time_zone()->name, locale => $::lx_office_conf{system}->{language})->clone();
  return $dt;
}

sub get_filepath {
  my ($self, %params) = @_;
  die "no dbfile" unless $params{dbfile};
  my $path = $self->_filesystem_path($params{dbfile},$params{version});

  die "No file found at $path. Expected: $params{dbfile}{file_name}, file.id: $params{dbfile}{id}" if !-f $path;

  return $path;
}

sub get_content {
  my ($self, %params) = @_;
  my $path = $self->get_filepath(%params);
  return "" unless $path;
  my $contents = File::Slurp::read_file($path);
  return \$contents;
}

sub enabled {
  return 0 unless $::instance_conf->get_doc_files;
  return 0 unless $::lx_office_conf{paths}->{document_path};
  return 0 unless -d $::lx_office_conf{paths}->{document_path};
  return 1;
}

sub sync_from_backend {
  die "Not implemented";
}

#
# internals
#

sub _filesystem_path {
  my ($self, $dbfile, $version) = @_;

  die "No files backend enabled" unless $::instance_conf->get_doc_files || $::lx_office_conf{paths}->{document_path};

  # use filesystem with depth 3
  $version  ||= $dbfile->file_versions_sorted->[-1]->version;
  confess "Version is required." unless $version;
  my $iddir   = sprintf("%04d", $dbfile->id % 1000);
  my $path    = File::Spec->catdir($::lx_office_conf{paths}->{document_path}, $::auth->client->{id}, $iddir, $dbfile->id);
  if (!-d $path) {
    File::Path::make_path($path, { chmod => 0770 });
  }
  return File::Spec->catdir($path, $dbfile->id . '_' . $version);
}

1;

__END__

=pod

=encoding utf8

=head1 NAME

SL::File::Backend::Filesystem  - Filesystem class for file storage backend

=head1 SYNOPSIS

See the synopsis of L<SL::File::Backend>.

=head1 OVERVIEW

This specific storage backend use a Filesystem which is only accessed by this interface.
This is the big difference to the Webdav backend where the files can be accessed without the control of that backend.
This backend use the database id of the SL::DB::File object as filename. The filesystem has up to 1000 subdirectories
to store the files not to flat in the filesystem. In this Subdirectories for each file an additional subdirectory exists
for the versions of this file.

The Versioning is done via a Versionnumber which is incremented by one for each version.
So the Version 2 of the file with the database id 4 is stored as path {root}/0004/4/4_2.


=head1 METHODS

See methods of L<SL::File::Backend>.

=head1 SEE ALSO

L<SL::File::Backend>

=head1 AUTHOR

Martin Helmling E<lt>martin.helmling@opendynamic.deE<gt>

=cut
