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

use strict;
use warnings;
use Carp;
use Data::Dumper;

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

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

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{artistContractTermID} ) {
        $self->_propertiesFromDB( \%properties, $args{artistContractTermID} );
    } else {
        $self->_propertiesFromDefaults( \%properties, $args{artistContractID} );
    }

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

    return $self;
}

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

    my $dbItem = RPS::DB::Item::NewArtistContractTerm->Lookup( artist_contract_term_id => $id );
    $self->_propertiesFromDBItem( $hrProperties, $dbItem );
}

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->{rate_reduction}          = $dbItem->rate_reduction;
    $hrProperties->{percentage_of_sales}     = $dbItem->percentage_of_sales;
    $hrProperties->{packaging_deduction}     = $dbItem->packaging_deduction;
    $hrProperties->{free_goods_deduction}    = $dbItem->free_goods_deduction;

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

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

    $self->{ArtistContractTermID} = Common::FormObject::Scalar->new( value => $props->{artist_contract_term_id}, readOnly => 1 );
    $self->{ArtistContractID}     = Common::FormObject::Scalar->new( value => $props->{artist_contract_id} );
    $self->{Priority}             = Common::FormObject::Scalar->new( value => $props->{priority}, required => 1 );
    $self->{ContractTermSourceID} = Common::FormObject::Scalar->new( value => $props->{contract_term_source_id}, required => 1 );
    $self->{RegionID}             = Common::FormObject::Scalar->new( value => $props->{region_id}, required => 1 );
    $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}, required => 1 );

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

    # We're going to force some values if the non-payable rate type has been selected.

    my ( $rate, $rateReduction, $percentageOfSales, $packagingDeduction, $freeGoods );

    if ( $props->{contract_rate_type_id} == RPS::DB::Item::ContractRateType::kRateTypeNonPayable() ) {
        $rate               = 0;
        $rateReduction      = 100;
        $percentageOfSales  = 100;
        $packagingDeduction = 0;
        $freeGoods          = 0;
    } else {
        $rate               = $props->{rate};
        $rateReduction      = $props->{rate_reduction};
        $percentageOfSales  = $props->{percentage_of_sales};
        $packagingDeduction = $props->{packaging_deduction};
        $freeGoods          = $props->{free_goods_deduction};
    }

    $self->{Rate}          = Common::FormObject::Scalar::Decimal->new( value => $rate,          precision => '.4' );
    $self->{RateReduction} = Common::FormObject::Scalar::Percent->new( value => $rateReduction, maxValue  => 300 );
    $self->{PercentageOfSales}  = Common::FormObject::Scalar::Percent->new( value => $percentageOfSales );
    $self->{PackagingDeduction} = Common::FormObject::Scalar::Percent->new( value => $packagingDeduction );
    $self->{FreeGoodsDeduction} = Common::FormObject::Scalar::Percent->new( value => $freeGoods );

    # this is how the template tells the backend to delete one of these.
    # the default is 'OFF' (ie. don't delete)
    #
    $self->{Delete} = Common::FormObject::Scalar::Boolean->new();
}

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

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

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

    if ( $self->Delete() ) {
        if ( $self->hasDependency() ) {
            $self->{Delete}->setError('has_dependency');
            return 0;
        }

        # else, no need to validate any properties
        return 1;
    }

    foreach my $field (
        qw(ContractTermSourceID RegionID ChannelID PriceLevelID ContractRateTypeID Rate RateReduction PercentageOfSales PackagingDeduction FreeGoodsDeduction)
      ) {
        if ( $self->$field() ) {
            $self->{_hasData} = 1;
        }
    }

    if ( $self->{_hasData} ) {
        my $valid = $self->SUPER::validate();

        # contract term source is always required
        if ( !defined $self->ContractTermSourceID() ) {
            $self->{ContractTermSourceID}->setError(Common::FormObject::kErrFieldBlank);
            $valid = 0;
        } else {

            # Rate is required unless the non-payable rate type has been selected.
            #
            if ( $self->ContractRateTypeID() != RPS::DB::Item::ContractRateType::kRateTypeNonPayable() ) {
                if ( !defined $self->Rate() ) {
                    $self->{Rate}->setError(Common::FormObject::kErrFieldBlank);
                    $valid = 0;
                }
            }

            # only physical products need a channel and price level
            #
            if ( $self->_isPhysical() ) {
                if ( !defined $self->ChannelID() ) {
                    $self->{ChannelID}->setError(Common::FormObject::kErrFieldBlank);
                    $valid = 0;
                }
                if ( !defined $self->PriceLevelID() ) {
                    $self->{PriceLevelID}->setError(Common::FormObject::kErrFieldBlank);
                    $valid = 0;
                }
            }

            # terms with the following digital sources must have a rate type of % net revenue
            #
            #			if($self->IncomeSourceID() == RPS::DB::Item::IncomeSource::kIncomeSourceVPD() ||
            #	           $self->IncomeSourceID() == RPS::DB::Item::IncomeSource::kIncomeSourceDigitalStream() ||
            #	           $self->IncomeSourceID() == RPS::DB::Item::IncomeSource::kIncomeSourceDigitalTethered())
            #	           #$self->IncomeSourceID() == RPS::DB::Item::IncomeSource::kIncomeSourceDigitalAlbumPremium() ||
            #	           #$self->IncomeSourceID() == RPS::DB::Item::IncomeSource::kIncomeSourceDigitalTrackPremium() ||
            #	           #$self->IncomeSourceID() == RPS::DB::Item::IncomeSource::kIncomeSourceDigitalAlbumUpgrade() ||
            #	           #$self->IncomeSourceID() == RPS::DB::Item::IncomeSource::kIncomeSourceDigitalTrackUpgrade())
            #			{
            #				if(($self->ContractRateTypeID() != RPS::DB::Item::ContractRateType::kRateTypePercentRevenue()) &&
            #				   ($self->ContractRateTypeID() != RPS::DB::Item::ContractRateType::kRateTypeNonPayable()))
            #				{
            #					$self->{ContractRateTypeID}->setError(Common::FormObject::kErrFieldInvalid);
            #	    			$valid = 0;
            #				}
            #			}

        }

        return $valid;
    } else {
        return 1;
    }
}

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

    my $hasDigital = RPS::DB::Item::ContractTermSource->hasDigital( $self->ContractTermSourceID() );
    return $hasDigital ? undef : 1;
}

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

    if ( $self->Delete() ) {
        $self->delete();
        return;
    }

    return unless $self->{_hasData};

    my $dbObj;
    if ( $self->ArtistContractTermID() ) {
        $dbObj = RPS::DB::Item::NewArtistContractTerm->Lookup( artist_contract_term_id => $self->ArtistContractTermID() );
    } else {
        $dbObj = RPS::DB::Item::NewArtistContractTerm->Create();
    }

    # set fields here
    #
    $dbObj->artist_contract_id( $self->ArtistContractID() );
    $dbObj->priority( $self->Priority() );
    $dbObj->contract_term_source_id( $self->ContractTermSourceID() );
    $dbObj->region_id( $self->RegionID() );
    $dbObj->channel_id( $self->ChannelID() );
    $dbObj->price_level_id( $self->PriceLevelID() );
    $dbObj->contract_rate_type_id( $self->ContractRateTypeID() );
    $dbObj->rate( $self->Rate() );
    $dbObj->modified_by( $self->ModifiedBy() );
    $dbObj->date_modified(Common::DB::Item::kDateTimeNow);

    # rate_reduction and percentage_of_sales need to default to 100, not 0.
    #
    $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() );

    # a little massaging of the data,
    # if we change a physical term to a digital then we need
    # to blank out certain fields that don't apply to digital
    #
    if ( !$self->_isPhysical() ) {
        $dbObj->channel_id(undef);
        $dbObj->price_level_id(undef);
    }

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

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

sub setDependency {
    my $self = shift;
    $self->{HasDependency} = 1;
}

sub hasDependency {
    my $self = shift;
    return $self->{HasDependency} ? 1 : 0;
}

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