#------------------------------------------------------------
# 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;