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

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

use lib '/app/tools/rps/lib';
use RPS::DB::Item::Song;
use RPS::DB::Item::Master;
use RPS::DB::Item::Composer;

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{songID} ) {
        $self->_propertiesFromDB( \%properties, $args{songID} );
    } else {
        $self->_propertiesFromDefaults( \%properties );
    }

    $self->_initProperties( \%properties );

    return $self;
}

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

    my $dbItem = RPS::DB::Item::Song->Lookup( song_id => $songID );
    $self->_propertiesFromDBItem( $hrProperties, $dbItem );
}

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

    $hrProperties->{song_id}       = $dbItem->song_id;
    $hrProperties->{title}         = $dbItem->title;
    $hrProperties->{composer_id}   = $dbItem->composer_id;
    $hrProperties->{iswc}          = $dbItem->iswc;
    $hrProperties->{public_domain} = $dbItem->public_domain;

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

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

    $self->{SongID} = Common::FormObject::Scalar->new( value => $props->{song_id} );
    $self->{Title} = Common::FormObject::Scalar::String->new( value => $props->{title}, required => 1 );
    $self->{ComposerID} = Common::FormObject::Scalar->new( value => $props->{composer_id} );
    $self->{ISWC} = Common::FormObject::Scalar::String->new( value => $props->{iswc}, maxlength => 20 );
    $self->{PublicDomain} = Common::FormObject::Scalar->new( value => $props->{public_domain} );

    $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 determine if this song is linked to more
    # than one master, if so it will not be editable on the album page
    #
    my $linkedMasters = 0;
    if ( $props->{song_id} ) {
        my $masters = RPS::DB::Item::Master->GetMastersBySongID( $props->{song_id} );
        $linkedMasters = ( defined $masters ) ? $masters->size() : 0;
    }
    $self->{LinkedMasters} = Common::FormObject::Scalar->new( value => $linkedMasters, readOnly => 1 );

    # We need to fetch the composer name, given the composer id.
    #
    my $composerName;
    my $composerID = $props->{composer_id};
    if ($composerID) {
        my $composerDBItem = RPS::DB::Item::Composer->Lookup( composer_id => $composerID );
        $composerName = $composerDBItem->name if ($composerDBItem);
    }
    $self->{ComposerName} = Common::FormObject::Scalar::String->new( value => $composerName );
}

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

sub isEmpty {
    my $self = shift @_;

    return 0;
}

sub validate {
    my $self = shift @_;

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

    # new Songs get their Title from the Master, but existing
    # Songs must have something set
    #

    # we're removing the automagic between Master and Song title
    #
    #	if($self->SongID() && ! $self->Title())
    #	{
    #		$self->{Title}->setError(Common::FormObject::kErrFieldBlank);
    #		$valid = 0;
    #	}

    return $valid;
}

sub _validateMetadata {
    my $self = shift;
    my %args = @_ if ( @_ % 2 == 0 );

    my $validator = $args{metadataValidator};

    my $currentData = RPS::DB::Item::Song->Lookup( song_id => $self->SongID )
      if ( $self->SongID );

    my %scalar_rule_map = (
        Title => {
            legacy   => "title",
            validate => "track-title"
        },
    );

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

    return $self->SUPER::_validateMetadata(
        fieldMap          => \%scalar_rule_map,
        currentData       => $currentData,
        metadataValidator => $validator
    );
}

sub save {
    my $self = shift @_;

    # -------------------------------
    # Handle the Master composer here
    # -------------------------------

    # Translate composer name to composer id, creating the composer if necessary.
    #
    my $composerObj;
    if ( $self->ComposerName() ) {
        $composerObj = RPS::DB::Item::Composer->Lookup( name => $self->ComposerName() );
        if ( !defined $composerObj ) {
            $composerObj = RPS::DB::Item::Composer->Create( name => $self->ComposerName() );
            $composerObj->save();
        }
    }

    # -------------------------------
    # Save myself
    # -------------------------------
    my $songDBObj;
    if ( $self->SongID() ) {
        $songDBObj = RPS::DB::Item::Song->Lookup( song_id => $self->SongID() );
    } else {
        $songDBObj = RPS::DB::Item::Song->Create();
    }

    $songDBObj->title( $self->Title() );
    $songDBObj->composer_id( $composerObj->composer_id ) if ( defined $composerObj );
    $songDBObj->iswc( $self->ISWC() );
    $songDBObj->public_domain( $self->PublicDomain() );

    $songDBObj->save();

    # reload object
    #
    $self->_init( _dbItem => $songDBObj );
}

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

    # Is this Song used on other Masters?
    # if yes, then skip, else delete the Song
    #
    if ( $self->LinkedMasters() == 1 ) {

        # ok, there's only one master using this song, so delete it!
        #
        my $dbItem = RPS::DB::Item::Song->Lookup( song_id => $self->SongID() );
        $dbItem->delete();
    }

    return 1;
}

sub isValidComposer {
    my ( $self, $album_id ) = @_;

    my $dbItem = RPS::DB::Item::Song->Lookup( song_id => $self->SongID() )
      if ( $self->SongID() );

    # If the data hasn't changed then do not validate
    return 1
      if ( $dbItem && $dbItem->composer_id == $self->ComposerID() );

    die("album_id required") unless ($album_id);

    #    my $req_composer = RPS::DB::Item::Genre::isComposerRequired( album_id => $album_id );

    #    if( $req_composer && ! $self->ComposerName() ) {
    #       $self->{ComposerName}->setError( 1 );
    #       $self->{ComposerName}->setErrorString( "required for this genre" );
    #	    return undef;
    #    }

    return 1;
}

1;