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

use strict;
use warnings;

use Data::Dumper;

use lib '/app/tools/rps/lib';
use RPS::DB::Item::Artist;
use RPS::DB::Item::AlbumAdditionalArtist;
use RPS::ArtistRole;
use Common::FormObject;
use Common::Assert;

use base 'RPS::Catalog::AdditionalArtist';

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

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

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

    $self->_initProperties(\%properties);
    $self->_initSubs(\%properties);

    return $self;
}

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

	my $dbItem = RPS::DB::Item::Artist->LookupWithAlbumAdditionalArtist(
        artist_id => $args{artistID}, artist_role_id => $args{artistRoleID}, album_id => $args{album_id} );

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

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

    $hrProperties->{album_id}       = $dbItem->{album_id};

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

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

    $self->SUPER::_initProperties( $props );

    $self->{AlbumID}       = Common::FormObject::Scalar->new( value => $props->{album_id} );

    return $self;
}

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

	return $self->SUPER::validate( %args );
}

sub save {
    my $self = shift;
    my %args = @_;
    my $oldInfo = $self->parseKey($self->OriginalKey());

    $self->AlbumID($args{albumID}) if( $args{albumID} );


	# Check if anything has changed.  If not, we're done.
    unless( $self->hasChanged( $args{key} ) || $self->Delete() ) {
        Common::Log::Debug( "No change detected, not updating" );
        return;
    }

	my $dbObj;

    ###
	#   Delete
	###
	if( $self->Delete() ) {
		$self->_delete( $oldInfo );

	###
	#   Update
	###
	} elsif( $oldInfo ) {
		$self->_update( $oldInfo );
	}

	###
	#   Create
	###
	else {
		$self->_create();
	}

}

sub _create {
	my $self = shift;

    my $artistID = $self->_getArtistID();
	assert($artistID);
	$self->ArtistID($artistID);

	# Do we need to clear our an old record?

    my $dbObj = RPS::DB::Item::AlbumAdditionalArtist->Create();

    $dbObj->album_id( $self->AlbumID );
    $dbObj->artist_role_id( $self->ArtistRoleID );
    $dbObj->artist_id( $self->ArtistID );

	$dbObj->save;
}

sub _update {
	my $self = shift;
	my $oldInfo = shift;

    my $artistID = $self->_getArtistID();
	assert($artistID);
	$self->ArtistID($artistID);

	assert( $oldInfo->{artistID} && $oldInfo->{artistRoleID} && $oldInfo->{albumID} );

	my $dbObj = RPS::DB::Item::AlbumAdditionalArtist->Lookup(
		artist_id      => $oldInfo->{artistID},
		album_id       => $oldInfo->{albumID},
		artist_role_id => $oldInfo->{artistRoleID},
	);

	assert($dbObj);

	$dbObj->album_id( $self->AlbumID );
    $dbObj->artist_role_id( $self->ArtistRoleID );
    $dbObj->artist_id( $self->ArtistID );

	$dbObj->save;
}

sub _delete {
	my $self = shift;
	my $oldInfo = shift;

	return unless( $oldInfo );

	assert( $oldInfo->{artistID} && $oldInfo->{artistRoleID} && $oldInfo->{albumID} );

    RPS::DB::Item::AlbumAdditionalArtist->Delete(
    	artist_id      => $oldInfo->{artistID},
		artist_role_id => $oldInfo->{artistRoleID},
		album_id       => $oldInfo->{albumID}
	);
}

sub hasChanged {
    my $self = shift;
    my $key = shift;
    my $oldInfo = $self->parseKey($key);

    if( $oldInfo->{albumID} != $self->AlbumID ) {
        return 1;
    }

    return $self->SUPER::hasChanged( $key );
}

sub hashKey {
    my $self = shift;
    my $albumID  = $self->AlbumID  || "";
    my $artistID = $self->ArtistID || "";
    my $artistRoleID = $self->ArtistRoleID || "";

    return $self->OriginalKey() if( $self->OriginalKey() );

	return "$albumID.$artistID.$artistRoleID";
}

sub parseKey {
    my $self = shift;
    my $key  = shift;

    Common::Log::Debug( "Parse Key: $key" ) if( $key );

    return unless( $key && $key !~ /new/i );

    my ( $albumID, $artistID, $artistRoleID ) = split( /\./, $key );

    return { albumID => $albumID, artistID => $artistID, artistRoleID => $artistRoleID }
}

1;