#------------------------------------------------------------
# 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;    #
###