#------------------------------------------------------------
# Copyright (C) 2006 RoyaltyShare, Inc.   All Rights Reserved
#------------------------------------------------------------
package RPS::Track::TrackSimple;
use strict;
use warnings;

use Data::Dumper;

use lib '/app/tools/appuser/lib';
use AppUser::User::User;

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

use lib '/app/tools/rps/lib';
use RPS::DB::Item::Track;
use RPS::DB::Item::MediaType;
use RPS::DB::Item::Artist;

use lib '/app/tools/mediaserve/lib';
use MediaServe::DB::Item::ProductTrackFile;

use RPS::Master::Master;
use RPS::Catalog::Album;

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


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

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

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

    $self->_initProperties(\%properties);

    return $self;
}

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

	my $dbItem = RPS::DB::Item::Track->Lookup(track_id => $trackID);

	$self->_propertiesFromDBItem($hrProperties, $dbItem);
}

sub _propertiesFromDBItem
{
	my ($self, $hrProperties, $dbItem) = @_;

	$hrProperties->{track_id}       = $dbItem->track_id;
	$hrProperties->{album_id}       = $dbItem->album_id;
	$hrProperties->{track_order}    = $dbItem->track_order;
	$hrProperties->{title}          = $dbItem->title;
	$hrProperties->{title_clean}    = $dbItem->title_clean;
	$hrProperties->{client_track_id} = $dbItem->client_track_id;
	$hrProperties->{track_order}   = $dbItem->track_order;
	$hrProperties->{master_id}      = $dbItem->master_id;
	$hrProperties->{mechanical_exempt}      = $dbItem->mechanical_exempt;
	$hrProperties->{ca_mechanical_exempt}   = $dbItem->ca_mechanical_exempt;
	$hrProperties->{parental_advisory}      = $dbItem->parental_advisory;

	$hrProperties->{date_created}   = $dbItem->date_created;
	$hrProperties->{date_modified}  = $dbItem->date_modified;
	$hrProperties->{created_by}     = $dbItem->created_by;
	$hrProperties->{modified_by}    = $dbItem->modified_by;
	$hrProperties->{artist_id}      = $dbItem->artist_id;
	$hrProperties->{media_type}     = $dbItem->media_type;

	$hrProperties->{genre_name}      = $dbItem->genre_name;
	$hrProperties->{custom_1}       = $dbItem->custom_1;
	$hrProperties->{custom_2}       = $dbItem->custom_2;
	$hrProperties->{custom_3}       = $dbItem->custom_3;

}

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

	$self->{TrackID}        = Common::FormObject::Scalar->new(value => $props->{track_id}, readOnly => 1);
	$self->{AlbumID}        = Common::FormObject::Scalar->new(value => $props->{album_id}); # !!! had been required
	$self->{Title}          = Common::FormObject::Scalar::String->new(value => $props->{title}, required => 1);
	$self->{TitleClean}     = Common::FormObject::Scalar::String->new(value => $props->{title_clean});
	$self->{ClientTrackID}  = Common::FormObject::Scalar::String->new(value => $props->{client_track_id});
	$self->{TrackOrder}    = Common::FormObject::Scalar->new(value => $props->{track_order});
	$self->{MasterID}       = Common::FormObject::Scalar->new(value => $props->{master_id});
	$self->{MechanicalExempt} = Common::FormObject::Scalar::Boolean->new(value => $props->{mechanical_exempt});
	$self->{CAMechanicalExempt} = Common::FormObject::Scalar::Boolean->new(value => $props->{ca_mechanical_exempt});
	$self->{ParentalAdvisory} = Common::FormObject::Scalar::String->new(value => $props->{parental_advisory});
	$self->{GenreName}      = Common::FormObject::Scalar::String->new(value => $props->{genre_name});
	$self->{MediaType}      = Common::FormObject::Scalar->new(value => $props->{media_type});
	$self->{Custom1}        = Common::FormObject::Scalar::String->new(value => $props->{custom_1});
	$self->{Custom2}        = Common::FormObject::Scalar::String->new(value => $props->{custom_2});
	$self->{Custom3}        = Common::FormObject::Scalar::String->new(value => $props->{custom_3});

	$self->{CreatedDate}    = Common::FormObject::Scalar::DateTime->new(value => $props->{date_created}, readOnly => 1);
	$self->{ModifiedDate}   = Common::FormObject::Scalar::DateTime->new(value => $props->{date_modified}, readOnly => 1);
	$self->{CreatedBy}      = Common::FormObject::Scalar::UserName->new(value => $props->{created_by}, readOnly => 1);
	$self->{ModifiedBy}     = Common::FormObject::Scalar::UserName->new(value => $props->{modified_by}, readOnly => 1);


	# We need to fetch the artist name, given the artist id.
	#
	my $artistName;
	if ($props->{artist_id})
	{
		my $artistDBItem = RPS::DB::Item::Artist->Lookup(artist_id => $props->{artist_id});
		$artistName = $artistDBItem->name if($artistDBItem);
	}
	$self->{ArtistName} = Common::FormObject::Scalar::String->new(value => $artistName, required => 1);
	$self->{ArtistID} = Common::FormObject::Scalar->new(value => $props->{artist_id});


	# this is something we only do for TrackSimple and not
	# for any of its derived classes.
    # !!! Huh? What?  Why is this here?
	#
	if(ref($self) eq 'RPS::Track::TrackSimple')
	{
		my $seconds = 0;
		if($props->{master_id})
		{
			my $master = RPS::DB::Item::Master->Lookup(master_id => $props->{master_id});
			$seconds = $master->duration if($master);
		}
		$self->{Duration} = Common::FormObject::Scalar->new(value => Common::FormObject::_secondsToMMSS($seconds));
	}

	$self->{AudioPreviewURL} = $self->_getTrackAudioURL();
}


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

	my $album = RPS::Catalog::Album->new(albumID => $albumID, loadSubs => 0);
    assert($album);


	# let's figure out the max track number
	#
	my $nextTrackNum = RPS::DB::Item::Track->GetTrackCountByAlbumID($albumID);
	$nextTrackNum++;

    $hrProperties->{album_id} = $albumID;
    $hrProperties->{track_order} = $nextTrackNum;

    # We'll get the artist id from the album as well.
    #
    $hrProperties->{artist_id} = $album->ArtistID();


    $hrProperties->{media_type} = RPS::DB::Item::MediaType::kMediaTypeAudio;
    $hrProperties->{parental_advisory} = 'N';
}

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

    my $dbObj = $self->_saveTrack();
    $self->_init(_dbItem => $dbObj);
}

# jpk - broke this out into an 'inner' method to make it easier to subclass
#
sub _saveTrack
{
    my ($self) = @_;


    # !!! This assumes AlbumID gets set before we get here.
    #
    # Get the album data, so we can set the artist name if necessary.
    #
    my $artistID;
    my $albumData = RPS::DB::Item::Album->Lookup(album_id => $self->AlbumID());
    if ($albumData)
    {
        $artistID = $albumData->artist_id;
    }

	# -------------------------------
	# Handle the Track artist here
	# -------------------------------

	# Translate artist name to artist id, creating the artist if necessary.
	# Use the $artistObj to set artist_id in the dbItem.
	#
    if ($self->ArtistName())
    {
	    my $artistObj;
	    $artistObj = RPS::DB::Item::Artist->Lookup(name => $self->ArtistName());
	    if(!defined $artistObj)
	    {
		    $artistObj = RPS::DB::Item::Artist->Create(name => $self->ArtistName());
            ## only good place to set the clean name for artists atm
            $artistObj->name_clean(Common::Util::clean_name_catalog($self->ArtistName()));
		    $artistObj->save();
	    }

        $artistID = $artistObj->artist_id;
    }

	my $masterID = $self->MasterID();


	# -------------------------------
	# Save myself (Track)
	# -------------------------------
	#
	my $trackDBObj;
	if ($self->TrackID())
	{
		$trackDBObj = RPS::DB::Item::Track->Lookup(track_id => $self->TrackID());
	}
	else
	{
		$trackDBObj = RPS::DB::Item::Track->Create();
	}


    # !!! This needs to change.
    # Track order is provided 'externally'.
    # We are using a scalar reference so that we can increment it for the next guy.
    #
#	$trackDBObj->track_order($$trackOrderRef++);
	$trackDBObj->track_order($self->TrackOrder());

	$trackDBObj->album_id($self->AlbumID());
	$trackDBObj->title($self->Title());
	$trackDBObj->mechanical_exempt($self->MechanicalExempt());
	$trackDBObj->ca_mechanical_exempt($self->CAMechanicalExempt());


    # !!! These fields have not been added to the form, yet.
    #
	$trackDBObj->client_track_id($self->ClientTrackID());
	$trackDBObj->genre_name($self->GenreName());
	$trackDBObj->media_type($self->MediaType());
	$trackDBObj->parental_advisory($self->ParentalAdvisory());
	$trackDBObj->custom_1($self->Custom1());
	$trackDBObj->custom_2($self->Custom2());
	$trackDBObj->custom_3($self->Custom3());

	# foreign keys
	#
	$trackDBObj->master_id($masterID);
	$trackDBObj->artist_id($artistID);


    # Derrive clean names
    #
	$trackDBObj->title_clean(Common::Util::clean_name_catalog($self->Title()));

	$trackDBObj->save();

    return $trackDBObj;

}

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

    my $audio = MediaServe::DB::Item::ProductTrackFile->LookupByTrackID( track_id => $self->TrackID );
	#Common::Log::Debug("-------- the 'audio' obj: " . Dumper($audio));
    my $audio_file = MediaServe::Audio::AudioFile->new(
                        clientID => Common::RSApp::GetClientID(),
                        id       => $audio->media_file_id )
        if( $audio );

	#Common::Log::Debug("-------- the 'audio_file' obj: " . Dumper($audio_file));
    return $audio_file ? $audio_file->url() : undef;
}
###
1;# Play nicely.
###