#------------------------------------------------------------
# Copyright (C) 2006 RoyaltyShare, Inc.   All Rights Reserved
# $Id$
#------------------------------------------------------------
package MediaServe::MediaFile;

use strict;
use warnings;

use lib '/app/tools/mediaserve/lib';
use MediaServe::Server;
use MediaServe::DB::Item::MediaFile;
use MediaServe::DB::Item::AlbumFile;
use MediaServe::DB::Item::StorageHost;
use MediaServe::DB::Item::Dataroot;
use MediaServe::DB::Item::ProductTrackFile;

use lib '/app/tools/bookpub/lib';
use MediaServe::DB::Item::BookProductImageFile;

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

use base 'Common::FormObject';

use constant kDefaultDatarootID => 2;

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

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

    my %properties;
    if ( $args{_dbItem} ) {
        $self->_propertiesFromDBItem( \%properties, $args{_dbItem} );
    } elsif ( $args{mediaFileID} ) {
        $self->_propertiesFromDB( \%properties, $args{mediaFileID} );
    } else {
        $self->_propertiesFromDefaults( \%properties );
    }

    $self->_initProperties( \%properties );

    return $self;
}

sub _propertiesFromDB {
    my ( $self, $hrProperties, $mediaFileID ) = @_;

    my $dbItem = MediaServe::DB::Item::MediaFile->Lookup( media_file_id => $mediaFileID );
    $self->_propertiesFromDBItem( $hrProperties, $dbItem );
}

sub _propertiesFromDBItem {
    my ( $self, $hrProperties, $dbItem ) = @_;
    my $storage_host = MediaServe::DB::Item::StorageHost->Lookup( storage_host_id => $dbItem->storage_host_id )
      if ( $dbItem->storage_host_id );
    my $dataroot = MediaServe::DB::Item::Dataroot->Lookup( dataroot_id => $dbItem->dataroot_id )
      if ( $dbItem->dataroot_id );

    $hrProperties->{media_file_id}   = $dbItem->media_file_id;
    $hrProperties->{filename}        = $dbItem->filename;
    $hrProperties->{storage_host_id} = $dbItem->storage_host_id;
    $hrProperties->{dataroot_id}     = $dbItem->dataroot_id;

    $hrProperties->{storage_host} = $storage_host->hostname() if ($storage_host);
    $hrProperties->{dataroot}     = $dataroot->mount_point()  if ($dataroot);
}

sub _initProperties {
    my ( $self, $props ) = @_;

    $self->{MediaFileID}   = Common::FormObject::Scalar->new( value => $props->{media_file_id} );
    $self->{Filename}      = Common::FormObject::Scalar->new( value => $props->{filename} );
    $self->{StorageHostID} = Common::FormObject::Scalar->new( value => $props->{storage_host_id} );
    $self->{StorageHost}   = Common::FormObject::Scalar->new( value => $props->{storage_host} );
    $self->{DatarootID}    = Common::FormObject::Scalar->new( value => $props->{dataroot_id} );
    $self->{Dataroot}      = Common::FormObject::Scalar->new( value => $props->{dataroot} );
}

sub _propertiesFromDefaults {
    my ( $self, $hrProperties ) = @_;
}

sub save {
    my $self = shift;

    my $dbobj = MediaServe::DB::Item::MediaFile->Lookup( media_file_id => $self->MediaFileID )
      if ( $self->MediaFileID );

    $dbobj = MediaServe::DB::Item::MediaFile->Create()
      unless ($dbobj);

    # If this is a new record set the writepath
    $dbobj->dataroot_id( $self->_writeDataroot() ) unless ( $dbobj->dataroot_id );
    $dbobj->filename( $self->Filename );

    $dbobj->save();

    $self->_init( _dbItem => $dbobj );
}

sub addAlbumFile {
    my $self      = shift;
    my %args      = @_;
    my $filename  = $args{filename};
    my $album_id  = $args{album_id};
    my $type      = $args{type} || MediaServe::DB::Item::AlbumFile::kFileTypeOriginal;
    my $overwrite = defined $args{overwrite} ? $args{overwrite} : 1;

    assert($self);
    assert($filename);
    assert($type);

    Common::Log::Debug("Adding Album File: $filename, Type: $type");
    my $album_file = MediaServe::DB::Item::AlbumFile->LookupByType( filename => $filename, type => $type );

    my $file;

    if ($album_file) {
        return undef unless $overwrite;
        $file = MediaServe::DB::Item::MediaFile->Lookup( media_file_id => $album_file->media_file_id );
    }

    if ($file) {
        $file->filename($filename);
        $file->save();
    } else {

        #$file = MediaServe::DB::Item::MediaFile->Create( filename => $filename );
        $file = MediaServe::Server::GetNewMediaFile($filename);
    }

    if ($album_file) {
        $album_file->media_file_id( $file->media_file_id );
    } else {
        $album_file = MediaServe::DB::Item::AlbumFile->Create(
            media_file_id => $file->media_file_id,
            album_id      => $album_id,
            file_type     => $type
        );
    }
    $album_file->save();

    $album_file->touch();
    $file->touch();

    return $album_file;
}

sub addBookProductFile {
    my $self            = shift;
    my %args            = @_;
    my $filename        = $args{filename};
    my $book_product_id = $args{book_product_id};
    my $type            = $args{type};
    my $overwrite       = defined $args{overwrite} ? $args{overwrite} : 1;

    assert($self);
    assert($filename);
    assert($type);

    Common::Log::Debug("Adding Book Product Image File: $filename, Type: $type");
    my $book_file = MediaServe::DB::Item::BookProductImageFile->LookupByType( filename => $filename, type => $type );

    my $file;

    if ($book_file) {
        return undef unless $overwrite;
        $file = MediaServe::DB::Item::MediaFile->Lookup( media_file_id => $book_file->media_file_id );
    }

    if ($file) {
        $file->filename($filename);
        $file->save();
    } else {

        #$file = MediaServe::DB::Item::MediaFile->Create( filename => $filename );
        $file = MediaServe::Server::GetNewMediaFile($filename);
    }

    if ($book_file) {
        $book_file->media_file_id( $file->media_file_id );
    } else {
        $book_file = MediaServe::DB::Item::BookProductImageFile->Create(
            media_file_id   => $file->media_file_id,
            book_product_id => $book_product_id,
            file_type       => $type
        );
    }

    $book_file->save();

    $book_file->touch();
    $file->touch();

    return $book_file;
}

sub addProductTrackFile {
    my $self = shift;
    my %args = @_;

    my $type = $args{type} || MediaServe::DB::Item::ProductTrackFile::kFileTypeOriginal;
    assert($self);
    assert( $args{filename} );
    assert( $args{session_id} );

    Common::Log::Debug("Adding Product Track File: $args{filename}, Type: $type session: $args{session_id}");
    my $pTrackFile = MediaServe::DB::Item::ProductTrackFile->LookupByFilename( filename => $args{filename} );

    return undef if ($pTrackFile);    # overwriting not allowed

    my $file = MediaServe::Server::GetNewMediaFile( $args{filename} );
    $file->status(MediaServe::DB::Item::MediaFile::kStatusPending);
    $file->save();
    my $mediaFileID = $file->media_file_id();

    $pTrackFile = MediaServe::DB::Item::ProductTrackFile->Create(
        media_file_id  => $mediaFileID,
        file_type      => $type,
        rip_session_id => $args{session_id}
    );
    $pTrackFile->save();

    return $pTrackFile;
}

sub _writeDataroot {
    my $self = shift;
    return kDefaultDatarootID;
}

1;