#------------------------------------------------------------
# Copyright (C) 2006 RoyaltyShare, Inc.   All Rights Reserved
# $Id$
#------------------------------------------------------------
package RPS::ArtistContract::DefaultTerm;

use strict;
use warnings;
use Carp;

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

use lib '/app/tools/rps/lib';
use RPS::DB::Item::AlbumContract;
use RPS::DB::Item::ContractRateType;
use RPS::DB::Item::Expense;
use RPS::DB::Item::NewArtistContract;
use RPS::DB::Item::NewArtistContractTerm;
use RPS::DB::Item::TrackContract;
use RPS::ArtistContract::ProductFormat;
use RPS::ArtistContract::ChannelList;
use RPS::Region::RegionList;

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{artistContractID})
    {
		# this is a special contract term known as the "Default" term. It's special attribute is priority=0.
		# There should only be one per contract and we'll always look it up by contract, so hence this
		# funky _init procedure. -jff-
		#
		my $dbItem = RPS::DB::Item::NewArtistContractTerm->GetDefault($args{artistContractID});
		if($dbItem)
		{
        	$self->_propertiesFromDBItem(\%properties, $dbItem);
		}
		else
		{
        	$self->_propertiesFromDefaults(\%properties, $args{artistContractID});
		}
    }
    else
    {
		$self->_propertiesFromDefaults(\%properties);
    }

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

    return $self;
}


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


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

	$self->{_inDB} = 1;

    $hrProperties->{artist_contract_term_id} = $dbItem->artist_contract_term_id;
    $hrProperties->{artist_contract_id} = $dbItem->artist_contract_id;
    $hrProperties->{priority} = $dbItem->priority;
    $hrProperties->{contract_term_source_id} = $dbItem->contract_term_source_id;
    $hrProperties->{region_id} = $dbItem->region_id;
    $hrProperties->{channel_id} = $dbItem->channel_id;
    $hrProperties->{price_level_id} = $dbItem->price_level_id;
    $hrProperties->{contract_rate_type_id} = $dbItem->contract_rate_type_id;
    $hrProperties->{rate} = $dbItem->rate;
    $hrProperties->{inactive} = $dbItem->inactive;

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

    # If the following fields are null, we'll go ahead and set them to the default values.
    # These values are also repeated in sub _propertiesFromDefaults. -rdd
    my $rate_reduction = $dbItem->rate_reduction;
    if ($rate_reduction > 0)
    {
    		$hrProperties->{rate_reduction} = $rate_reduction;
    }
    else
    {
    		$hrProperties->{rate_reduction} = 100;
    }
    my $percentage_of_sales = $dbItem->percentage_of_sales;
    if ($percentage_of_sales > 0)
    {
    		$hrProperties->{percentage_of_sales} = $percentage_of_sales;
    }
    else
    {
    		$hrProperties->{percentage_of_sales} = 100;
    }
    my $packaging_deduction = $dbItem->packaging_deduction;
    if ($packaging_deduction > 0)
    {
    		$hrProperties->{packaging_deduction} = $packaging_deduction;
    }
    else
    {
    		$hrProperties->{packaging_deduction} = 0;
    }
    my $free_goods_deduction = $dbItem->free_goods_deduction;
    if ($free_goods_deduction > 0)
    {
    		$hrProperties->{free_goods_deduction} = $free_goods_deduction;
    }
    else
    {
    		$hrProperties->{free_goods_deduction} = 0;
    }
}


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

    $self->{ArtistContractTermID}	= Common::FormObject::Scalar->new(value => $props->{artist_contract_term_id});
    $self->{ArtistContractID}		= Common::FormObject::Scalar->new(value => $props->{artist_contract_id});
    $self->{Priority}		    	= Common::FormObject::Scalar->new(value => $props->{priority});
    $self->{ContractTermSourceID}	= Common::FormObject::Scalar->new(value => $props->{contract_term_source_id});
    $self->{RegionID}				= Common::FormObject::Scalar->new(value => $props->{region_id});
    $self->{ChannelID}				= Common::FormObject::Scalar->new(value => $props->{channel_id});
    $self->{PriceLevelID}			= Common::FormObject::Scalar->new(value => $props->{price_level_id});
    $self->{ContractRateTypeID}		= Common::FormObject::Scalar->new(value => $props->{contract_rate_type_id});
    $self->{Rate}					= Common::FormObject::Scalar::Percent->new(value => $props->{rate}, precision => '.4');
    $self->{RateReduction}			= Common::FormObject::Scalar::Percent->new(value => $props->{rate_reduction});
    $self->{PercentageOfSales}		= Common::FormObject::Scalar::Percent->new(value => $props->{percentage_of_sales});
    $self->{PackagingDeduction}		= Common::FormObject::Scalar::Percent->new(value => $props->{packaging_deduction});
    $self->{FreeGoodsDeduction}		= Common::FormObject::Scalar::Percent->new(value => $props->{free_goods_deduction});
    $self->{Inactive}        		= Common::FormObject::Scalar->new(value => $props->{inactive});

    $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);

    my $dependancies = RPS::DB::Item::NewArtistContractTerm->GetTermDependencyByArtistContractID($self->ArtistContractID);
	$self->{HasDependency} = $dependancies->{$self->ArtistContractTermID} ? 1 : 0;
}


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

	if($self->loadSubs())
	{
	}
}


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

    $hrProperties->{artist_contract_id} = $contractID;
    $hrProperties->{priority} = 0;
    $hrProperties->{rate_reduction} = 100;
    $hrProperties->{percentage_of_sales} = 100;
    $hrProperties->{packaging_deduction} = 0;
    $hrProperties->{free_goods_deduction} = 0;
    $hrProperties->{inactive} = 1;
}

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

	my $valid = 1;
	# if anything was entered then try to validate
	#
	if( $self->Inactive && $self->Rate() == 0 && $self->ArtistContractID())
	{	
	    my $unprocessedExpenses = 0;
	    # If there are unprocessed net revenue expenses,
	    # the rate cannot be zero.
	    
	    # First check the album contracts
	    my $albumContracts = RPS::DB::Item::AlbumContract->GetByContractID($self->ArtistContractID());
	    while ($albumContracts->hasNext())
	    {
	        my $albumContract = $albumContracts->next();
	        my $albumContractID = $albumContract->album_contract_id; 
	        my $albumExpenseCount = RPS::DB::Item::Expense->GetNumUnprocessedPreProcess($albumContractID, RPS::DB::Item::Expense::kParentAlbumContract);
	        $unprocessedExpenses += $albumExpenseCount;
	        
	    }
	    # And now for the track contracts
	    my $trackContracts = RPS::DB::Item::TrackContract->GetByContractID($self->ArtistContractID());
	    while ($trackContracts->hasNext())
	    {
	        my $trackContract = $trackContracts->next();
	        my $trackContractID = $trackContract->track_contract_id; 
	        my $trackExpenseCount = RPS::DB::Item::Expense->GetNumUnprocessedPreProcess($trackContractID, RPS::DB::Item::Expense::kParentTrackContract);
	        $unprocessedExpenses += $trackExpenseCount;
	    }	        

	    if ($unprocessedExpenses == 0)
	    {
	        $valid = $self->SUPER::validate();
        } else {
		    $valid = undef;
		    $self->{Rate}->setErrorString( 'Default rate cannot be 0' );	
		}    
	} elsif( $self->Inactive || ($self->Rate() && $self->Rate() != 0) ) {
    	$valid = $self->SUPER::validate();
	} else {
		$valid = undef;
		$self->{Rate}->setErrorString( 'Default rate cannot be 0' );
	}



	return $valid;
}


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

	my $dbObj;
	if($self->ArtistContractTermID())
	{
		# let's check for a deletion here
		#
		if(!$self->Rate())
		{
			# i guess we should delete in this case
			#
			return $self->delete();
		}
		else
		{
			$dbObj = RPS::DB::Item::NewArtistContractTerm->Lookup(artist_contract_term_id => $self->ArtistContractTermID());
            $dbObj->modified_by($self->ModifiedBy());
            $dbObj->date_modified(Common::DB::Item::kDateTimeNow);

		}
	}
	else
	{
		# don't save something that wasn't entered.
		#
		if(!$self->Rate())
		{
			return 1;
		}

		$dbObj = RPS::DB::Item::NewArtistContractTerm->Create();
        $dbObj->created_by($self->CreatedBy());
        $dbObj->date_created(Common::DB::Item::kDateTimeNow);

	}

	# set fields here
	#
	$dbObj->artist_contract_id($self->ArtistContractID());
    $dbObj->priority(0);
    $dbObj->contract_rate_type_id(RPS::DB::Item::ContractRateType::kRateTypePercentRevenue());
    $dbObj->rate($self->Rate());
    # $dbObj->priority($self->Priority());
    # $dbObj->income_source_id($self->IncomeSourceID());
    # $dbObj->region_id($self->RegionID());
    # $dbObj->channel_id($self->ChannelID());
    # $dbObj->price_level_id($self->PriceLevelID());
    # $dbObj->contract_rate_type_id($self->ContractRateTypeID());

    # We will translate a '0' rate_reduction to 100.
    #
    $dbObj->rate_reduction( $self->RateReduction() > 0 ? $self->RateReduction() : 100);
    $dbObj->percentage_of_sales( $self->PercentageOfSales() > 0 ? $self->PercentageOfSales() : 100);

    $dbObj->packaging_deduction($self->PackagingDeduction());
    $dbObj->free_goods_deduction($self->FreeGoodsDeduction());
    $dbObj->inactive($self->Inactive());

	# save db item
	#
	$dbObj->save();

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



sub delete
{
	my $self = shift;

	if($self->{_inDB})
	{
		my $myDBObj = RPS::DB::Item::NewArtistContractTerm->Lookup(artist_contract_term_id => $self->ArtistContractTermID());
		$myDBObj->delete();
	}
    return 1;
}


###
1;#
###