#------------------------------------------------------------
# Copyright (C) 2006 RoyaltyShare, Inc.   All Rights Reserved
# $Id$
#------------------------------------------------------------
package RPS::Catalog::ImageUpload;
use strict;
use warnings;

use lib '/app/tools/common/lib';
use Common::Assert;
use Common::RSApp;
use Common::Util;

use lib '/app/tools/mediaserve/lib';
use MediaServe::MediaFile;
use MediaServe::Image::Matcher;
use MediaServe::Image::Converter;
use MediaServe::DB::Item::AlbumFile;

use lib '/app/tools/rps/lib';
use RPS::Catalog::AlbumSimple;
use RPS::DB::Item::Product;

use Common::FormObject;
use base 'Common::FormObject';

use constant kImageDirectory   => '/app/data/images';
use constant kImageTypeAllowed => qw( tif tiff jpg jpeg );

sub _init {
    my ( $self, %args ) = @_;

    $self->SUPER::_init(%args);

    $self->{_albumID}   = $args{albumID};
    $self->{_imageFH}   = $args{imageFH};
    $self->{_imageName} = $args{imageName};

    return $self;
}

sub validate {
    my ( $self, @args ) = @_;
    my @types       = (kImageTypeAllowed);
    my $images      = join( "|", @types );
    my $image_regex = qr/.*\.($images)$/i;

    my $valid = $self->SUPER::validate();

    Common::Log::Debug("Validate uploaded image file");

    my $albumID = $self->{_albumID};

    my $import_fh   = $self->{_imageFH};
    my $import_file = $self->{_imageName};

    Common::Log::Debug("IMAGE NAME: $import_file, FH: $import_fh");

    unless ($import_fh) {
        Common::Log::Debug("ERROR: File Requried");
        $self->setError("error");
        $self->setErrorString("File required");
        $valid = 0;
    }

    unless ( $import_fh && $import_file ) {
        Common::Log::Debug("ERROR: Can't read file");
        $self->setError("error");
        $self->setErrorString("Unable to read from input file");
        $valid = 0;
    }

    unless ( $import_file =~ /$image_regex/ ) {
        Common::Log::Debug("ERROR: Invalid Format");
        $self->setError("error");
        $self->setErrorString( "Invalid file format, valid extensions: " . join( ", ", @types ) );
        $valid = 0;
    }

    unless ( $import_file !~ /(\.\.|\/)/ ) {
        Common::Log::Debug("ERROR: Bad chars in filename");
        $self->setError("error");
        $self->setErrorString("Filename contains invalid characters");
        $valid = 0;
    }

    unless ($albumID) {
        Common::Log::Debug("ERROR: Album ID Required");
        $self->setError("error");
        $self->setErrorString("Album ID Required");
        $valid = 0;
    }

    return $valid;
}

sub import_file {
    my $self   = shift;
    my $infile = $self->{_imageFH};

    assert($self);
    assert( $self->{_albumID} );
    assert($infile);

    my $file;

    while (<$infile>) {
        $file .= $_;
    }

    unless ($file) {
        Common::Log::Debug("ERROR: Can't read file");
        $self->setError("error");
        $self->setErrorString("Unable to read from input file");
        return undef;
    }

    Common::Log::Debug( "Reading image file.  Size: " . length($file) );

    $self->store_file($file);
}

sub store_file {
    my $self           = shift;
    my $file           = shift;
    my $input_filename = $self->{_imageName};
    my $album_id       = $self->{_albumID};
    my $client_id      = Common::RSApp::GetClientID();
    my $upc            = RPS::DB::Item::Product::GetDigitalUPCByAlbumID($album_id);

    my $media_file = new MediaServe::MediaFile();
    my $converter  = new MediaServe::Image::Converter();

    Common::Log::Debug("Storing image file");

    assert($self);
    assert($file);
    assert($input_filename);
    assert($album_id);
    assert($client_id);
    assert( -w kImageDirectory );

    my $extension = $input_filename;
    $extension =~ s/.*\.//g;
    my $dir = "album_$album_id";
    my $filename .= "$dir.$extension";
    my $img_dest   = kImageDirectory . "/$client_id/upload";
    my $spool_dest = kImageDirectory . "/$client_id/spool";

    Common::Log::Debug("  - Output filename: $filename");
    system("mkdir -p $img_dest")   unless ( -d $img_dest );
    system("mkdir -p $spool_dest") unless ( -d $spool_dest );

    open( OUTFILE, ">$spool_dest/$filename" )
      || die("Can not write to output directory: $spool_dest");
    print OUTFILE "$file";
    close(OUTFILE);

    if ( $converter->validate("$spool_dest/$filename") ) {

        # Create assets for all image files
        foreach ( $converter->getFileTypes() ) {
            $media_file->addAlbumFile(
                album_id => $album_id,
                type     => $_,
                filename => $converter->outputFilename( $filename, $_ )
            );
        }

        system("mv $spool_dest/$filename $img_dest/$filename");
    } else {
        unlink("$spool_dest/$filename");

        $self->setError("error");
        $self->setErrorString( $converter->error );
    }
}

1;