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

use strict;
use warnings;
use Carp;
use Date::Calc;

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

use lib '/app/tools/rps/lib';
use RPS::DB::Item::ControlledComposition;
use RPS::License::ReserveLiquidationList;
use RPS::DB::Item::TrackLicense;

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{controlledCompositionID})
    {
        $self->_propertiesFromDBWithControlledCompID(\%properties, $args{controlledCompositionID});
    }
    elsif ($args{contractID})
    {
        $self->_propertiesFromDBWithContractID(\%properties, $args{contractID});
    }
    else
    {
        $self->_propertiesFromDefaults(\%properties);
    }

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

    return $self;
}


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

    my $dbItem = RPS::DB::Item::ControlledComposition->Lookup(controlled_composition_id => $id);
	if($dbItem)
	{
    	$self->_propertiesFromDBItem($hrProperties, $dbItem);
	}
}

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

    my $dbItem = RPS::DB::Item::ControlledComposition->GetByContractID($id);
	if($dbItem)
	{
    	$self->_propertiesFromDBItem($hrProperties, $dbItem);
	}
}


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

	assert($dbItem);

    $hrProperties->{controlled_composition_id}  = $dbItem->controlled_composition_id;
    $hrProperties->{artist_contract_id}         = $dbItem->artist_contract_id;
    $hrProperties->{track_cap}                  = $dbItem->track_cap;
    $hrProperties->{rate_type}                  = $dbItem->rate_type;
    $hrProperties->{penny_rate}                 = $dbItem->penny_rate;
    $hrProperties->{rate_basis}                 = $dbItem->rate_basis;
    $hrProperties->{rate_percentage}            = $dbItem->rate_percentage;
    $hrProperties->{reserve_percentage}         = $dbItem->reserve_percentage;
    $hrProperties->{lock_date}                  = $dbItem->lock_date;
}


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

    $self->{ControlledCompositionID}    = Common::FormObject::Scalar->new(value => $props->{controlled_composition_id});
    $self->{ArtistContractID}           = Common::FormObject::Scalar->new(value => $props->{artist_contract_id}, required => 1);
    $self->{TrackCap}                   = Common::FormObject::Scalar->new(value => $props->{track_cap}, required => 1);
    $self->{RateType}                   = Common::FormObject::Scalar->new(value => $props->{rate_type}, required => 1);
    $self->{RatePercentage}             = Common::FormObject::Scalar::Percent->new(value => $props->{rate_percentage}, required => 1);
    $self->{PennyRate}                  = Common::FormObject::Scalar::Decimal->new(value => $props->{penny_rate});
    $self->{RateBasis}                  = Common::FormObject::Scalar->new(value => $props->{rate_basis});
    $self->{ReservePercentage}          = Common::FormObject::Scalar::Percent->new(value => $props->{reserve_percentage});
    $self->{LockDate}                   = Common::FormObject::Scalar::Date->new(value => $props->{lock_date});
}


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

    if ($self->loadSubs())
    {
	    $self->{ReserveLiquidationList} = RPS::License::ReserveLiquidationList->new
        (
            id => $props->{controlled_composition_id},
            type => RPS::DB::Item::ReserveLiquidation::kTypeControlledComposition(),
        );
    }
}


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

    $hrProperties->{rate_percentage} = 100;
}

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

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

	# penny rate is required if type is penny rate
	#
	if(RPS::DB::Item::TrackLicense::kRateTypePenny == $self->RateType() && !$self->PennyRate())
	{
		$self->{PennyRate}->setError(Common::FormObject::kErrFieldBlank);
		$valid = 0;
	}

	# RateBasis is not required if the rate type is penny rate
	#
	if(! $self->RateBasis() && $self->RateType() != RPS::DB::Item::TrackLicense::kRateTypePenny)
	{
		$self->{RateBasis}->setError(Common::FormObject::kErrFieldBlank);
		$valid = 0;
	}

    if (RPS::DB::Item::TrackLicense::kRateBasisLock == $self->RateBasis() && !$self->LockDate())
    {
        $self->{LockDate}->setError(Common::FormObject::kErrFieldBlank);
        $valid = 0;
    }
    
	my $sum = 0;
    if ($self->ReservePercentage())
    {
        foreach my $liq (@{$self->{ReserveLiquidationList}->getList()})
        {
            if(defined $liq && $liq->Percent())
            {       
                $sum += $liq->Percent();   
            }
        }
        if ($sum == 0)
        {
			$self->{ReserveLiquidationList}->setError(Common::FormObject::kErrFieldBlank);
			$valid = 0;
	    }                      
        
    }    

	return $valid;
}


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

	# -------------------------------
	# Save myself (ControlledComposition)
	# -------------------------------
	#
	my $dbObj;
	if ($self->ControlledCompositionID())
	{
		$dbObj = RPS::DB::Item::ControlledComposition->Lookup(controlled_composition_id => $self->ControlledCompositionID());
	}
	else
	{
		$dbObj = RPS::DB::Item::ControlledComposition->Create();
	}

	$dbObj->artist_contract_id($self->ArtistContractID());
	$dbObj->track_cap($self->TrackCap());
	$dbObj->rate_type($self->RateType());
	$dbObj->penny_rate($self->PennyRate());
	$dbObj->rate_percentage($self->RatePercentage());
	$dbObj->rate_basis($self->RateBasis());
	$dbObj->reserve_percentage($self->ReservePercentage());
	$dbObj->lock_date($self->LockDate());

	$dbObj->save();


	# let's save the liquidation list
	#
	foreach my $liq (@{$self->{ReserveLiquidationList}->getList()})
	{
		if(defined $liq && $liq->Percent())
		{
			# assign from the newly saved dbObj
			$liq->ID($dbObj->controlled_composition_id);

			# just to be safe
			$liq->Type(RPS::DB::Item::ReserveLiquidation::kTypeControlledComposition);
		}
	}
	$self->{ReserveLiquidationList}->save();


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

###
1;#
###