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

use Carp;

use lib '/app/tools/rps/lib';
use RPS::DB::Item::AlbumContract;
use RPS::DB::Item::AlbumContractAdvance;
use RPS::ArtistContract::ArtistContract;
use RPS::Catalog::AlbumContractAdvance;
use RPS::DB::Item::Expense;

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{albumContractID})
    {
        $self->_propertiesFromDB(\%properties, $args{albumContractID});
    }
    elsif($args{albumID} && $args{artistContractID})
    {
		$self->_propertiesFromDefaults(\%properties, $args{albumID}, $args{artistContractID});
    }

    $self->_initProperties(\%properties);

    return $self;
}


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

    my $dbItem = RPS::DB::Item::AlbumContract->Lookup(album_contract_id => $albumContractID);

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


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

    $hrProperties->{album_contract_id}  = $dbItem->album_contract_id;
    $hrProperties->{album_id}           = $dbItem->album_id;
    $hrProperties->{artist_contract_id} = $dbItem->artist_contract_id;
    $hrProperties->{is_controlled_comp} = $dbItem->is_controlled_comp;
    $hrProperties->{is_ca_controlled_comp} = $dbItem->is_ca_controlled_comp;
    $hrProperties->{status}             = $dbItem->status;
    $hrProperties->{last_royalty_run_id}= $dbItem->last_royalty_run_id;
    $hrProperties->{cross_collateralized}= $dbItem->cross_collateralized;
}


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

    $hrProperties->{album_id} = $albumID;
    $hrProperties->{artist_contract_id} = $artistContractID;
}


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

    $self->{AlbumContractID}	= Common::FormObject::Scalar->new(value => $props->{album_contract_id}, readOnly => 1);
    $self->{AlbumID}			= Common::FormObject::Scalar->new(value => $props->{album_id}, required => 1);
    $self->{ContractID}			= Common::FormObject::Scalar->new(value => $props->{artist_contract_id}, required => 1);
    $self->{IsControlledComp}	= Common::FormObject::Scalar->new(value => $props->{is_controlled_comp});
    $self->{IsCAControlledComp}	= Common::FormObject::Scalar->new(value => $props->{is_ca_controlled_comp});
    $self->{Status}				= Common::FormObject::Scalar->new(value => $props->{status});
    $self->{LastRoyaltyRunID}	= Common::FormObject::Scalar->new(value => $props->{last_royalty_run_id});
    $self->{CrossCollateralized}	= Common::FormObject::Scalar::Boolean->new(value => $props->{cross_collateralized});
}


# Going to wrap this logic in a seperate method.
# That way I can be lazy about it - I know that some subclasses are going to want to 
# provide this in the XML, but not all will.  So I don't want to bake in the expense.
#
sub _canDelete
{
    my ($self) = @_;

    if (! defined $self->{_canDelete})
    {
        my $canDelete = 1;

        if (RPS::DB::Item::Expense->GetNumProcessed($self->AlbumContractID(), RPS::DB::Item::Expense::kParentAlbumContract()) > 0)
        {
            # If this contract has processed expenses, then we can't delete it.
            #
            $canDelete = 0;
        }
        else
        {
            # We also can't delete the contract if it's been included on a royalty run.
            # we can get artist_contract_term_id from artist_royalty_income_item
            # and artist_contract_term from new_artist_contract_term
            # !!! This is going to be S L O W - Might need to add some indexes to these tables.
            #
            if (RPS::DB::Item::AlbumContract->HasBeenIncludedInRoyaltyRun($self->AlbumContractID()))
            {
                $canDelete = 0;
            }
        }

        $self->{_canDelete} = $canDelete;
    }

    return $self->{_canDelete};
}


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

	# -------------------------------
	# Save myself (AlbumContract)
	# -------------------------------
	#
	my $dbObj;
	if ($self->AlbumContractID())
	{
		$dbObj = RPS::DB::Item::AlbumContract->Lookup(album_contract_id => $self->AlbumContractID());
	}
	else
	{
		$dbObj = RPS::DB::Item::AlbumContract->Create();
	}

	$dbObj->album_id($self->AlbumID());
	$dbObj->artist_contract_id($self->ContractID());
	$dbObj->is_controlled_comp($self->IsControlledComp());
	$dbObj->is_ca_controlled_comp($self->IsCAControlledComp());
	$dbObj->status($self->Status());
	$dbObj->last_royalty_run_id($self->LastRoyaltyRunID());
	$dbObj->cross_collateralized($self->CrossCollateralized());

	$dbObj->save();

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


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

    # We can't delete a contract that isn't 'active'.
    #
    return undef unless RPS::DB::Item::AlbumContract::kStatusActive == $self->Status();
    return undef unless $self->_canDelete();



    # We've already checked to see whether the expenses are processed when we called '_canDelete'.
    # So, go right ahead...
    #
	my $expenseColl = RPS::DB::Item::Expense->GetByParent($self->AlbumContractID(), RPS::DB::Item::Expense::kParentAlbumContract());
	while(my $expense = $expenseColl->next())
	{
        $expense->delete();
	}

	my $albumContract = RPS::DB::Item::AlbumContract->Lookup(album_contract_id => $self->AlbumContractID());
	$albumContract->delete();

	return 1;
}

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

    # We can't inactivate a contract that isn't 'active'.
    #
    return undef unless RPS::DB::Item::AlbumContract::kStatusActive == $self->Status();

    # We shouldn't be here if this contract can be deleted...
    #
    return undef if $self->_canDelete();


	my $albumContract = RPS::DB::Item::AlbumContract->Lookup(album_contract_id => $self->AlbumContractID());
	$albumContract->status(RPS::DB::Item::AlbumContract::kStatusInactive);
    $albumContract->save();

	return 1;
}

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

    # We can't reactivate a contract that isn't 'inactive'.
    #
    return undef unless RPS::DB::Item::AlbumContract::kStatusInactive == $self->Status();

    # We shouldn't be here if this contract can be deleted...
    # JPK - Well, maybe.  But now that the canDelete method looks at royalty runs, this
    # state _can_ change from 'false' to 'true'...
    #
#    return undef if $self->_canDelete();


	my $albumContract = RPS::DB::Item::AlbumContract->Lookup(album_contract_id => $self->AlbumContractID());
	$albumContract->status(RPS::DB::Item::AlbumContract::kStatusActive);
    $albumContract->save();

	return 1;
}

###
1;#
###