# vim:set sw=4 ts=4 sts=4 ft=perl expandtab:

package Lufi::DB::File::SQLite;

use Mojo::Base 'Lufi::DB::File';

use Mojo::File;

use Mojo::Collection 'c';

use Lufi::DB::SQLite;

use Lufi::DB::Slice;

has 'record';

sub new {

    my $c = shift;

    $c = $c->SUPER::new(@_);

    $c = $c->_slurp if defined $c->record;

    return $c;

}

sub write {

    my $c = shift;

    if (defined $c->record) {

        $c->record->update(

            short                => $c->short,

            deleted              => $c->deleted,

            mediatype            => $c->mediatype,

            filename             => $c->filename,

            filesize             => $c->filesize,

            counter              => $c->counter,

            delete_at_first_view => $c->delete_at_first_view,

            delete_at_day        => $c->delete_at_day,

            created_at           => $c->created_at,

            created_by           => $c->created_by,

            last_access_at       => $c->last_access_at,

            mod_token            => $c->mod_token,

            nbslices             => $c->nbslices,

            complete             => $c->complete,

            passwd               => $c->passwd,

        );

    } else {

        my $record = Lufi::DB::SQLite::Files->create(

            short                => $c->short,

            deleted              => $c->deleted,

            mediatype            => $c->mediatype,

            filename             => $c->filename,

            filesize             => $c->filesize,

            counter              => $c->counter,

            delete_at_first_view => $c->delete_at_first_view,

            delete_at_day        => $c->delete_at_day,

            created_at           => $c->created_at,

            created_by           => $c->created_by,

            last_access_at       => $c->last_access_at,

            mod_token            => $c->mod_token,

            nbslices             => $c->nbslices,

            complete             => $c->complete,

            passwd               => $c->passwd,

        );

        $c->record($record);

    }

    return $c;

}

sub count_empty {

    my $c = shift;

    return Lufi::DB::SQLite::Files->count('WHERE created_at IS NULL');

}

sub already_exists {

    my $c     = shift;

    my $short = shift;

    return Lufi::DB::SQLite::Files->count('WHERE short = ?', $short);

}

sub get_empty {

    my $c     = shift;

    my @records = Lufi::DB::SQLite::Files->select('WHERE created_at IS NULL LIMIT 1');

    return $c->record($records[0])->_slurp->created_at(time)->write;

}

sub get_stats {

    my $c = shift;

    my $files   = Lufi::DB::SQLite::Files->count('WHERE created_at IS NOT null AND deleted = 0');

    my $deleted = Lufi::DB::SQLite::Files->count('WHERE created_at IS NOT null AND deleted = 1');

    my $empty   = Lufi::DB::SQLite::Files->count('WHERE created_at IS null');

    return { files => $files, deleted => $deleted, empty => $empty };

}

sub from_short {

    my $c     = shift;

    my $short = shift;

    my @records = Lufi::DB::SQLite::Files->select('WHERE short = ?', $short);

    if (scalar @records) {

        $c->record($records[0]);

        $c->_slurp;

        return $c;

    } else {

        return undef;

    }

}

sub get_oldest_undeleted_files {

    my $c   = shift;

    my $num = shift;

    my @files = Lufi::DB::SQLite::Files->select('WHERE deleted = 0 ORDER BY created_at ASC LIMIT ?', $num);

    return c(map { Lufi::DB::File->new(app => $c->app, record => $_) } @files);

}

sub get_expired {

    my $c    = shift;

    my $time = shift;

    ## Select only files expired since two days, to be sure that nobody is still downloading it

    my @files = LufiDB::Files->select('WHERE deleted = 0 AND ((delete_at_day + 2) * 86400) < (? - created_at) AND delete_at_day != 0', $time);

    return c(map { Lufi::DB::File->new(app => $c->app, record => $_) } @files);

}

sub get_no_longer_viewed {

    my $c    = shift;

    my $time = shift;

    my @files = LufiDB::Files->select('WHERE deleted = 0 AND last_access_at < ?', $time);

    return c(map { Lufi::DB::File->new(app => $c->app, record => $_) } @files);

}

sub delete_creator_before {

    my $c          = shift;

    my $separation = shift;

    Lufi::DB::SQLite->do(

        'UPDATE files SET created_by = NULL WHERE created_by IS NOT NULL AND created_at < ?',

        {},

        $separation

    );

}

sub _slurp {

    my $c = shift;

    my @files;

    if ($c->record) {

        @files = ($c->record);

    } elsif ($c->short) {

        @files = Lufi::DB::SQLite::Files->select('WHERE short = ?', $c->short);

    }

    if (scalar @files) {

        my $file = $files[0];

        $c->short($file->short);

        $c->deleted($file->deleted)                           if defined $file->deleted;

        $c->mediatype($file->mediatype)                       if defined $file->mediatype;

        $c->filename($file->filename)                         if defined $file->filename;

        $c->filesize($file->filesize)                         if defined $file->filesize;

        $c->counter($file->counter)                           if defined $file->counter;

        $c->delete_at_first_view($file->delete_at_first_view) if defined $file->delete_at_first_view;

        $c->delete_at_day($file->delete_at_day)               if defined $file->delete_at_day;

        $c->created_at($file->created_at)                     if defined $file->created_at;

        $c->created_by($file->created_by)                     if defined $file->created_by;

        $c->last_access_at($file->last_access_at)             if defined $file->last_access_at;

        $c->mod_token($file->mod_token)                       if defined $file->mod_token;

        $c->nbslices($file->nbslices)                         if defined $file->nbslices;

        $c->complete($file->complete)                         if defined $file->complete;

        $c->passwd($file->passwd)                             if defined $file->passwd;

        $c->record($file) unless $c->record;

    }

    $c->slices(Lufi::DB::Slice->new(app => $c->app)->get_slices_of_file($c->short));

    return $c;

}

1;