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

# !!! It appears that this class might be going away.
# !!! Need to determine where it is used.
# !!! Will probably replace this with a TrackWithSongAndMaster class, or something like that.
#

use strict;
use warnings;

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

use lib '/app/tools/metadata/lib';
use Metadata::Validate::Harness;

use lib '/app/tools/rps/lib';
use RPS::DB::Item::Track;
use RPS::DB::Item::Artist;
use RPS::DB::Item::TrackLicense;
use RPS::DB::Item::CATrackLicense;
use RPS::DB::Item::TrackContract;
use RPS::DB::Item::ProductTrack;
use RPS::DB::Item::Product;
use RPS::Master::Master;
use RPS::DB::Item::Album;
use RPS::Catalog::TrackAdditionalArtistHash;

use Common::FormObject;

use RPS::Track::TrackSimple;
use base 'RPS::Track::TrackSimple';

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

    # Call the inherited method to fill in the basic fields.
    #
    $self->SUPER::_initProperties($props);

    # !!! There can now be multiple track products per track, so this doesn't make sense anymore.
    #
    # add in the digital track product id
    #my $productDBItem = RPS::DB::Item::Product->GetDigitalTrackProduct($props->{track_id});
    #my $productID = $productDBItem->product_id if( $productDBItem );
    #$self->{ProductID} = Common::FormObject::Scalar->new(value => $productID, readOnly => 1);

    # let's add the album name too, so that when tracks are used
    # outside the context of an album we can show the album name.
    #
    my $albumName;
    if ( $props->{album_id} ) {
        my $albumDBItem = RPS::DB::Item::Album->Lookup( album_id => $props->{album_id} );
        $albumName = $albumDBItem->title;
    }
    $self->{AlbumName} = Common::FormObject::Scalar::String->new( value => $albumName, readOnly => 1 );

    # this is used to determine if the track can be deleted or not.
    # if the track is linked to any licenses, contracts or sales then it cannot be deleted.
    #
    # JPK - Extended this to include Canadian licenses.
    #
    my ( $linkedCountLicense, $linkedCountContract, $linkedCComp );
    if ( $props->{track_id} ) {
        my $collLicense = RPS::DB::Item::TrackLicense->GetLicensesByTrackID( $props->{track_id} );
        $linkedCountLicense = $collLicense->size;
        $linkedCComp        = 0;
        while ( $collLicense->hasNext() ) {
            my $obj = $collLicense->next();
            if ( RPS::DB::Item::TrackLicense::kControlledComposition == $obj->type ) {
                $linkedCComp = 1;
                last;
            }
        }

        my $caCollLicense = RPS::DB::Item::CATrackLicense->GetLicensesByTrackID( $props->{track_id} );
        $linkedCountLicense += $caCollLicense->size;
        while ( $caCollLicense->hasNext() ) {
            my $obj = $caCollLicense->next();
            if ( RPS::DB::Item::CATrackLicense::kControlledComposition == $obj->type ) {
                $linkedCComp = 1;
                last;
            }
        }

        my $collContract = RPS::DB::Item::TrackContract->GetByTrackID( $props->{track_id} );
        $linkedCountContract = $collContract->size;
    }
    $self->{LinkedLicenses}  = Common::FormObject::Scalar->new( value => $linkedCountLicense,  readOnly => 1 );
    $self->{LinkedContracts} = Common::FormObject::Scalar->new( value => $linkedCountContract, readOnly => 1 );
    $self->{LinkedCComp}     = Common::FormObject::Scalar->new( value => $linkedCComp,         readOnly => 1 );

    my $trackCount;
    if ( $props->{album_id} ) {
        $trackCount = RPS::DB::Item::Track->GetTrackCountByAlbumID( $props->{album_id} );
    }
    $self->{AlbumTrackCount} = Common::FormObject::Scalar->new( value => $trackCount, readOnly => 1 );

    if ( defined( $props->{master_id} ) && $props->{master_id} > 0 ) {
        $self->{Master} = RPS::Master::Master->new( masterID => $props->{master_id} );
    } else {
        $self->{Master} = RPS::Master::Master->new();
    }

    $self->{AdditionalArtistList} = RPS::Catalog::TrackAdditionalArtistHash->new( trackID => $props->{track_id} );
}

# We want to detect when we're changing the track order.
# So we'll override the TrackOrder accessor to set a flag.
#
sub TrackOrder {
    my ( $self, $newVal ) = @_;

    if ( !defined $newVal ) {
        return $self->{TrackOrder}->access();
    }

    my $oldVal = $self->{TrackOrder}->access();

    # !!! Remember, access returns '1' upon successful assignment.
    # !!!
    my $returnVal = $self->{TrackOrder}->access($newVal);

    if ( $returnVal && $oldVal != $newVal ) {
        $self->{_renumberTracks} = 1;
    }

    return $returnVal;
}

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

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

    # let's validate the track_number
    #
    my $trackCount = RPS::DB::Item::Track->GetTrackCountByAlbumID( $self->AlbumID() );

    if ( $self->TrackID() ) {

        # existing tracks can only be numbered in the current range
        #
        if ( $self->TrackOrder() > $self->AlbumTrackCount() || $self->TrackOrder() < 1 ) {
            $self->{TrackOrder}->setError(Common::FormObject::kErrFieldInvalid);
            $valid = 0;
        }
    } else {

        # new tracks can only be numbered in the current range + 1
        #
        #if($self->TrackOrder() > $self->AlbumTrackCount()+1 || $self->TrackOrder() < 1)
        #{
        #	$self->{TrackOrder}->setError(Common::FormObject::kErrFieldInvalid);
        #	$valid = 0;
        #}
    }

    unless ( $self->_validateMetadata(%args) ) {
        $valid = 0;
    }

    $valid = 0
      unless $self->{AdditionalArtistList}->validate(%args);

    return $valid;
}

sub _validateMetadata() {
    my ( $self, %args ) = @_;
    my $validator = $args{metadataValidator};

    my $currentData = RPS::DB::Item::Track->Lookup( track_id => $self->TrackID )
      if ( $self->TrackID );

    my $scalar_rule_map = {
        Title => {
            legacy   => 'title',
            validate => 'track-title'
        },
        TrackOrder => {
            legacy   => 'track_order',
            validate => 'track-number'
        },
        ClientTrackID => {
            legacy   => 'client_track_id',
            validate => 'client-track-id'
        },
        ParentalAdvisory => {
            legacy   => 'parental_advisory',
            validate => 'explicit'
        },
        MediaType => {
            legacy   => 'media_type',
            validate => 'media-type'
        },
        Custom1 => {
            legacy   => 'custom_1',
            validate => 'track-custom-1'
        },
        Custom2 => {
            legacy   => 'custom_2',
            validate => 'track-custom-2'
        },
        Custom3 => {
            legacy   => 'custom_3',
            validate => 'track-custom-3'
        }
    };

    my $valid = $self->SUPER::_validateMetadata(
        fieldMap          => $scalar_rule_map,
        currentData       => $currentData,
        metadataValidator => $validator
    );

    unless ($validator) {
        Common::Log::Debug( "No validator passed to " . ref($self) . "::_validateMetadata, skipping validation!!!!!" );
        return $valid;
    }

    my $currentMaster = RPS::DB::Item::Master->Lookup( master_id => $self->{Master}->MasterID )
      if ( $self->{Master} && $self->{Master}->MasterID );

    if (   $validator->ignore_current_data()
        || !$currentMaster
        || $currentMaster->isrc ne $self->{Master}->ISRC ) {
        my $compResult = $validator->validate_item( 'isrc', $self->{Master}->ISRC );

        if ($compResult) {
            $self->{Master}->{ISRC}->setError( $compResult->{code} );
            $self->{Master}->{ISRC}->setErrorString( $compResult->{message} );
            $valid = 0;
        }
    }

    if (
        $self->{Master}->ISRC
        && RPS::DB::Item::Track::hasDuplicateISRC(
            album_id   => $self->AlbumID,
            track_id   => $self->TrackID,
            isrc       => $self->{Master}->ISRC,
            media_type => $self->MediaType
        )
      ) {
        $self->{Master}->{ISRC}->setError(Common::FormObject::kErrDuplicate);
        $valid = 0;
    }

    my $master_valid = 1;
    $master_valid = $self->{Master}->_validateMetadata(
        fieldMap          => $scalar_rule_map,
        currentData       => $currentData,
        metadataValidator => $validator
    ) if ( $self->{Master} );

    my ( $pGenre, $sGenre ) = RPS::DB::Item::Genre->getGenreNames( album_id => $self->AlbumID );

    my $song_valid = 1;
    if ( $self->{Master} && $self->{Master}->{Song} ) {
        my $compResult = $validator->validate_item(
            'track-composer',
            $self->{Master}->{Song}->ComposerName, undef,
            'primary_genre'   => $pGenre,
            'secondary_genre' => $sGenre
        );
        if ($compResult) {
            $self->{Master}->{Song}->{ComposerName}->setError( $compResult->{code} );
            $self->{Master}->{Song}->{ComposerName}->setErrorString( $compResult->{message} );
            $song_valid = 0;
        }
    }

    #
    # We also need to validate the composer of a song. The problem is we need
    # album ID to get the correct genre.  So we need to test that constraint here
    # instead of in the song object.
    #

    return $valid && $master_valid && $song_valid;
}

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

    my $renumberFlag = $self->{_renumberTracks};

    my $trackDBObj = $self->_saveTrack();

    # Clear the flag before we init
    #
    $self->{_renumberTracks} = 0;

    $self->{AdditionalArtistList}->save( trackID => $trackDBObj->track_id );

    $self->_init( _dbItem => $trackDBObj );

    if ($renumberFlag) {
        RPS::DB::Item::Track->RenumberTracks($trackDBObj);
    }

}

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

    # -------------------------------
    # Handle the Master
    # -------------------------------
    $self->{Master}->save();
    my $masterID = $self->{Master}->MasterID();
    $self->MasterID($masterID);

    my $dbObj = $self->SUPER::_saveTrack();

    return $dbObj;

}

sub OLDsave {
    my $self = shift @_;

    # -------------------------------
    # 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.
    #
    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();
    }

    # -------------------------------
    # Handle the Master
    # -------------------------------
    $self->{Master}->save();
    my $masterID = $self->{Master}->MasterID();

    # -------------------------------
    # Save myself (Track)
    # -------------------------------
    #

    # These are flags we'll use below to determine how to re-number
    # the tracks. We need to know if this is a new track,
    # if a track number is being changed we need to remember what
    # the original track number was.
    #
    my $renumberTracks = 0;
    my $trackDBObj;
    if ( $self->TrackID() ) {
        $trackDBObj = RPS::DB::Item::Track->Lookup( track_id => $self->TrackID() );

        # are we changing track number?
        #
        if ( $trackDBObj->track_order != $self->TrackOrder() ) {
            $renumberTracks = 1;
        }
    } else {
        $trackDBObj     = RPS::DB::Item::Track->Create();
        $renumberTracks = 1;
    }

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

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

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

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

    $trackDBObj->save();

    # reload
    #
    $self->_init( _dbItem => $trackDBObj );

    if ($renumberTracks) {
        RPS::DB::Item::Track->RenumberTracks($trackDBObj);
    }
}

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

    # first we need to check if this Track have any License, CComps, contracts,
    # or sales associated with it
    # if yes to any of the above, then we can't delete so return the appropriate message
    if ( $self->LinkedLicenses() > 0 ) {
        $self->setError(Common::FormObject::kErrTrackHasLicenses);
        return undef;
    }

    if ( $self->LinkedContracts() > 0 ) {
        $self->setError(Common::FormObject::kErrTrackHasContracts);
        return undef;
    }

    # We need to check all of the digital track products for sales before we start deleting any of them.
    my $products = RPS::DB::Item::Product->GetAllDigitalTrackProducts( $self->TrackID() );
    while ( $products->hasNext() ) {
        my $product = $products->next();
        if ( !RPS::DB::Item::Product->CanDelete( $product->product_id() ) ) {
            $self->setError(Common::FormObject::kErrTrackHasSales);
            return undef;
        }
    }

    # If we made it this far, then it must be okay to delete them all.
    $products = RPS::DB::Item::Product->GetAllDigitalTrackProducts( $self->TrackID() );
    while ( $products->hasNext() ) {
        my $product = $products->next();
        $product->delete();
    }

    # delete the Master
    #
    $self->{Master}->delete();

    # delete product track items
    #
    my $productTracks = RPS::DB::Item::ProductTrack->GetByTrackID( $self->TrackID() );
    while ( $productTracks->hasNext() ) {
        my $dbObj = $productTracks->next();
        $dbObj->delete();
    }

    # ok, now we can delete ourself (the track)
    #
    my $track = RPS::DB::Item::Track->Lookup( track_id => $self->TrackID() );
    $track->delete();

    RPS::DB::Item::Album->RenumberTracks( $self->AlbumID() );

    return 1;
}

###
1;    # Play nicely.
###