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

use Carp;
use lib '/app/tools/common/lib';
use Common::Log;

use lib '/app/tools/rps/lib';
use RPS::DB::Item::TrackContract;
use RPS::DB::Item::TrackContractAdvance;
use RPS::ArtistContract::ArtistContract;
use RPS::Track::TrackContractAdvance;
use RPS::Track::TrackSimple;
use RPS::DB::Item::Album;
use RPS::DB::Item::Expense;
use RPS::DB::Item::Track;

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


sub _init
{
    my ($self, %args) = @_;
    my $timer = Common::Timer->new();

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

    my %properties;
	$self->{_showTrack} = $args{showTrack};
	$self->{_showContract} = $args{showContract};

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

    $self->_initProperties(\%properties);

    return $self;
}


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

    my $dbItem = RPS::DB::Item::TrackContract->Lookup(track_contract_id => $trackContractID);

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


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

    $hrProperties->{track_contract_id}  = $dbItem->track_contract_id;
    $hrProperties->{track_id}           = $dbItem->track_id;
    $hrProperties->{artist_contract_id} = $dbItem->artist_contract_id;
    $hrProperties->{status}             = $dbItem->status;
    $hrProperties->{last_royalty_run_id}= $dbItem->last_royalty_run_id;
    $hrProperties->{cross_collateralized}= $dbItem->cross_collateralized;
    $hrProperties->{prorate_track_count} = $dbItem->prorate_track_count;
}


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

    $hrProperties->{track_id} = $trackID;
    $hrProperties->{artist_contract_id} = $artistContractID;

    # We want the prorate track count to default to the number of tracks on
    # the track's album.
    #
    my $trackData = RPS::DB::Item::Track->Lookup(track_id => $trackID);
    if ($trackData && $trackData->album_id)
    {
        $hrProperties->{prorate_track_count} = RPS::DB::Item::Track->GetTrackCountByAlbumID($trackData->album_id);
    }
}


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

    $self->{TrackContractID}	= Common::FormObject::Scalar->new(value => $props->{track_contract_id}, readOnly => 1);
    $self->{TrackID}			= Common::FormObject::Scalar->new(value => $props->{track_id}, required => 1);
    $self->{ContractID}			= Common::FormObject::Scalar->new(value => $props->{artist_contract_id}, required => 1);
    $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});
    $self->{ProrateTrackCount}	= Common::FormObject::Scalar->new(value => $props->{prorate_track_count});
}



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

	# -------------------------------
	# Save myself (TrackContract)
	# -------------------------------
	#
	my $dbObj;
	if ($self->TrackContractID())
	{
		$dbObj = RPS::DB::Item::TrackContract->Lookup(track_contract_id => $self->TrackContractID());
	}
	else
	{
		$dbObj = RPS::DB::Item::TrackContract->Create();
	}

	$dbObj->track_id($self->TrackID());
	$dbObj->artist_contract_id($self->ContractID());
	$dbObj->status($self->Status());
	$dbObj->last_royalty_run_id($self->LastRoyaltyRunID());
	$dbObj->cross_collateralized($self->CrossCollateralized());
	$dbObj->prorate_track_count($self->ProrateTrackCount());

	$dbObj->save();

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


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

    if (! defined $self->{_canDelete})
    {
        Common::Log::Debug("TrackContract::_canDelete - fetching state");
        my $canDelete = 1;

        if (RPS::DB::Item::Expense->GetNumProcessed($self->TrackContractID(), RPS::DB::Item::Expense::kParentTrackContract()) > 0)
        {
            # If this contract has processed expenses, then we can't delete it.
            #
            Common::Log::Debug("TrackContract::_canDelete - has expenses, setting state to 0");
            $canDelete = 0;
        }
        else
        {
            # We also can't delete the contract if it's been included on a royalty run.
            #
            if (RPS::DB::Item::TrackContract->HasBeenIncludedInRoyaltyRun($self->TrackContractID()))
            {
                Common::Log::Debug("TrackContract::_canDelete - on a run, setting state to 0");
                $canDelete = 0;
            }
        }
        $self->{_canDelete} = $canDelete;
    }
    Common::Log::Debug("TrackContract::_canDelete - returning " . $self->{_canDelete});

    return $self->{_canDelete};
}


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

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

    return undef unless $self->_canDelete();


	my $expenseColl = RPS::DB::Item::Expense->GetByParent($self->TrackContractID(), RPS::DB::Item::Expense::kParentTrackContract);
	while(my $expense = $expenseColl->next())
	{
        $expense->delete();
	}

	my $trackContract = RPS::DB::Item::TrackContract->Lookup(track_contract_id => $self->TrackContractID());
	$trackContract->delete();

	return 1;
}


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

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

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


	my $trackContract = RPS::DB::Item::TrackContract->Lookup(track_contract_id => $self->TrackContractID());
	$trackContract->status(RPS::DB::Item::TrackContract::kStatusInactive);
    $trackContract->save();

	return 1;
}

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

    # We can't reactivate a contract that isn't 'inactive'.
    #
    if (RPS::DB::Item::TrackContract::kStatusInactive != $self->Status())
    {
        Common::Log::Debug("TrackContract::reactivate - status not 'inactive'");
        return undef;
    }

    # We shouldn't be here if this contract can be deleted...
    # !!! Well, who cares?
    #
#    if (! $self->_canDelete())
#    {
#        Common::Log::Debug("TrackContract::reactivate - canDelete returned false");
#        return undef;
#    }


    Common::Log::Debug("TrackContract::reactivate - reactivating");
	my $trackContract = RPS::DB::Item::TrackContract->Lookup(track_contract_id => $self->TrackContractID());
	$trackContract->status(RPS::DB::Item::TrackContract::kStatusActive);
    $trackContract->save();

	return 1;
}


###
1;#
###