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

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

use lib '/app/tools/rps/lib';
use RPS::Catalog::AlbumContract;
use RPS::Contract::TermList;
use RPS::Contract::RegionList;
use RPS::Contract::UnitEscalationList;
use RPS::ControlledComposition::ControlledComposition;
use RPS::Payee::ArtistPayee;
use RPS::DB::Item::ArtistContract;
use RPS::DB::Item::Artist;

use RPS::XMLObject;
use base 'RPS::XMLObject';

sub _init {
    my ( $self, %args ) = @_;

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

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

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

    return $self;
}

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

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

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

    $hrProperties->{artist_contract_id} = $dbItem->artist_contract_id;
    $hrProperties->{title}              = $dbItem->title;
    $hrProperties->{artist_description} = $dbItem->artist_description;
    $hrProperties->{artist_payee_id}    = $dbItem->artist_payee_id;
    $hrProperties->{client_contract_id} = $dbItem->client_contract_id;
    $hrProperties->{issue_date}         = $dbItem->issue_date;

    $hrProperties->{unit_based_enabled}      = $dbItem->unit_based_enabled;
    $hrProperties->{unit_based_rate_type}    = $dbItem->unit_based_rate_type;
    $hrProperties->{unit_based_rate}         = $dbItem->unit_based_rate;
    $hrProperties->{unit_based_rate_basis}   = $dbItem->unit_based_rate_basis;
    $hrProperties->{unit_based_reserve_rate} = $dbItem->unit_based_reserve_rate;

    $hrProperties->{unit_based_digital_enabled}          = $dbItem->unit_based_digital_enabled;
    $hrProperties->{unit_based_digital_rate_type}        = $dbItem->unit_based_digital_rate_type;
    $hrProperties->{unit_based_digital_album_rate}       = $dbItem->unit_based_digital_album_rate;
    $hrProperties->{unit_based_digital_single_rate}      = $dbItem->unit_based_digital_single_rate;
    $hrProperties->{unit_based_digital_reserves_enabled} = $dbItem->unit_based_digital_reserves_enabled;

    $hrProperties->{net_based_rate}                     = $dbItem->net_based_rate;
    $hrProperties->{net_based_reserve_rate}             = $dbItem->net_based_reserve_rate;
    $hrProperties->{net_based_digital_reserves_enabled} = $dbItem->net_based_digital_reserves_enabled;

    $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->{ArtistContractID} = RPS::XMLObject::Scalar::Integer->new( value => $props->{artist_contract_id}, readOnly => 1 );
    $self->{Title} = RPS::XMLObject::Scalar::String->new( value => $props->{title}, required => 1 );
    $self->{ArtistDescription} = RPS::XMLObject::Scalar::String->new( value => $props->{artist_description} );
    $self->{ArtistPayeeID} = RPS::XMLObject::Scalar::Integer->new( value => $props->{artist_payee_id}, required => 1 );
    $self->{ClientContractID} = RPS::XMLObject::Scalar::String->new( value => $props->{client_contract_id} );
    $self->{IssueDate} = RPS::XMLObject::Scalar::Date->new( value => $props->{issue_date} );

    $self->{UnitBasedEnabled}     = RPS::XMLObject::Scalar::Boolean->new( value => $props->{unit_based_enabled} );
    $self->{UnitBasedRateType}    = RPS::XMLObject::Scalar::Integer->new( value => $props->{unit_based_rate_type} );
    $self->{UnitBasedRate}        = RPS::XMLObject::Scalar::Percent->new( value => $props->{unit_based_rate} );
    $self->{UnitBasedRateBasis}   = RPS::XMLObject::Scalar::Integer->new( value => $props->{unit_based_rate_basis} );
    $self->{UnitBasedReserveRate} = RPS::XMLObject::Scalar::Percent->new( value => $props->{unit_based_reserve_rate} );

    $self->{UnitBasedDigitalEnabled}    = RPS::XMLObject::Scalar::Boolean->new( value => $props->{unit_based_digital_enabled} );
    $self->{UnitBasedDigitalRateType}   = RPS::XMLObject::Scalar::Integer->new( value => $props->{unit_based_digital_rate_type} );
    $self->{UnitBasedDigitalAlbumRate}  = RPS::XMLObject::Scalar::Decimal->new( value => $props->{unit_based_digital_album_rate} );
    $self->{UnitBasedDigitalSingleRate} = RPS::XMLObject::Scalar::Decimal->new( value => $props->{unit_based_digital_single_rate} );
    $self->{UnitBasedDigitalReservesEnabled} =
      RPS::XMLObject::Scalar::Boolean->new( value => $props->{unit_based_digital_reserves_enabled} );

    $self->{NetBasedRate}                   = RPS::XMLObject::Scalar::Percent->new( value => $props->{net_based_rate} );
    $self->{NetBasedReserveRate}            = RPS::XMLObject::Scalar::Percent->new( value => $props->{net_based_reserve_rate} );
    $self->{NetBasedDigitalReservesEnabled} = RPS::XMLObject::Scalar::Boolean->new( value => $props->{net_based_digital_reserves_enabled} );

    $self->{CreatedDate}  = RPS::XMLObject::Scalar::DateTime->new( value => $props->{date_created},  readOnly => 1 );
    $self->{ModifiedDate} = RPS::XMLObject::Scalar::DateTime->new( value => $props->{date_modified}, readOnly => 1 );
    $self->{CreatedBy}    = RPS::XMLObject::Scalar::UserName->new( value => $props->{created_by},    readOnly => 1 );
    $self->{ModifiedBy}   = RPS::XMLObject::Scalar::UserName->new( value => $props->{modified_by},   readOnly => 1 );

    # -jff- the artist contract by itself is fairly useless,
    # so I feel like ArtistPayee is a pretty integral part of this object.
    # It was in the _initSubs, but I moved it here.
    #
    $self->{ArtistPayee} = RPS::Payee::ArtistPayee->new( artistPayeeID => $props->{artist_payee_id}, loadSubs => 0, readOnly => 1 );

    # the basic contract object needs to know if it has a ControlledComp or not.
    # So we'll look for one here and save it internally so we can reuse it later
    # on in loadSubs (if necessary)
    #
    $self->{_ccomp} = RPS::ControlledComposition::ControlledComposition->new( contractID => $props->{artist_contract_id}, readOnly => 1 );
    my $hasCComp = 0;
    if ( defined $self->{_ccomp} && $self->{_ccomp}->ControlledCompositionID() ) {
        $hasCComp = 1;
    }
    $self->{HasCComp} = RPS::XMLObject::Scalar->new( value => $hasCComp, readOnly => 1 );

    # I need this object when creating a new contract.
    # But I don't want to load all the other subs
    #
    $self->{UnitBasedReserveLiquidationList} = RPS::License::ReserveLiquidationList->new(
        id   => $props->{artist_contract_id},
        type => RPS::DB::Item::ReserveLiquidation::kTypeContractUnitBased,
    );

    $self->{NetBasedReserveLiquidationList} = RPS::License::ReserveLiquidationList->new(
        id   => $props->{artist_contract_id},
        type => RPS::DB::Item::ReserveLiquidation::kTypeContractNetBased,
    );

}

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

    if ( $self->loadSubs() ) {
        my $contractID = $props->{artist_contract_id};

        # MOVED to initProperties so we can always know if a CComp exists -jff-
        #
        # Load the controlled composition clause.
        #
        # $self->{ControlledComposition} = RPS::ControlledComposition::ControlledComposition->new
        # (
        # contractID => $contractID,
        # readOnly => 1,
        # );
        $self->{ControlledComposition} = $self->{_ccomp};

        $self->{UnitBasedRegionList} = RPS::Contract::RegionList->new(
            contractID   => $contractID,
            contractMode => RPS::DB::Item::ArtistContract::kModeUnit
        );

        $self->{NetBasedRegionList} = RPS::Contract::RegionList->new(
            contractID   => $contractID,
            contractMode => RPS::DB::Item::ArtistContract::kModeNetRevenue
        );

        # Load the terms and deductions for unit_based and net_based.
        #
        $self->{UnitBasedTermList} = RPS::Contract::TermList->new(
            contractID   => $contractID,
            contractMode => RPS::DB::Item::ArtistContract::kModeUnit,
            readOnly     => 1,
        );

        $self->{UnitBasedDeductionList} = RPS::Contract::DeductionList->new(
            contractID   => $contractID,
            contractMode => RPS::DB::Item::ArtistContract::kModeUnit,
            readOnly     => 1,
        );

        $self->{UnitBasedDigitalDeductionList} = RPS::Contract::DeductionList->new(
            contractID   => $contractID,
            contractMode => RPS::DB::Item::ArtistContract::kModeUnitDigital,
            readOnly     => 1,
        );

        $self->{UnitBasedUnitEscalationList} = RPS::Contract::UnitEscalationList->new(
            contractID   => $contractID,
            contractMode => RPS::DB::Item::ArtistContract::kModeUnit,
            readOnly     => 1,
        );

        $self->{UnitBasedDigitalAlbumUnitEscalationList} = RPS::Contract::UnitEscalationList->new(
            contractID   => $contractID,
            contractMode => RPS::DB::Item::ArtistContract::kModeUnitDigital,
            readOnly     => 1,
        );

        $self->{UnitBasedDigitalSingleUnitEscalationList} = RPS::Contract::UnitEscalationList->new(
            contractID   => $contractID,
            contractMode => RPS::DB::Item::ArtistContract::kModeUnitDigitalSingle,
            readOnly     => 1,
        );

        $self->{NetBasedTermList} = RPS::Contract::TermList->new(
            contractID   => $contractID,
            contractMode => RPS::DB::Item::ArtistContract::kModeNetRevenue,
            readOnly     => 1,
        );

        $self->{NetBasedDeductionList} = RPS::Contract::DeductionList->new(
            contractID   => $contractID,
            contractMode => RPS::DB::Item::ArtistContract::kModeNetRevenue,
            readOnly     => 1,
        );

        $self->{NetBasedUnitEscalationList} = RPS::Contract::UnitEscalationList->new(
            contractID   => $contractID,
            contractMode => RPS::DB::Item::ArtistContract::kModeNetRevenue,
            readOnly     => 1,
        );
    }

}

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

    # JPK - Don't have any canned defaults (yet)
    #
}

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

    my $dbObj;
    if ( $self->ArtistContractID() ) {
        $dbObj = RPS::DB::Item::ArtistContract->Lookup( artist_contract_id => $self->ArtistContractID() );
    } else {
        $dbObj = RPS::DB::Item::ArtistContract->Create();
    }

    # set fields here
    #
    $dbObj->artist_payee_id( $self->ArtistPayeeID() );
    $dbObj->client_contract_id( $self->ClientContractID() );
    $dbObj->title( $self->Title() );
    $dbObj->artist_description( $self->ArtistDescription() );
    $dbObj->issue_date( $self->IssueDate() );

    $dbObj->unit_based_enabled( $self->UnitBasedEnabled() );
    $dbObj->unit_based_rate_type( $self->UnitBasedRateType() );
    $dbObj->unit_based_rate( $self->UnitBasedRate() );
    $dbObj->unit_based_rate_basis( $self->UnitBasedRateBasis() );
    $dbObj->unit_based_reserve_rate( $self->UnitBasedReserveRate() );

    $dbObj->unit_based_digital_enabled( $self->UnitBasedDigitalEnabled() );
    $dbObj->unit_based_digital_rate_type( $self->UnitBasedDigitalRateType() );
    $dbObj->unit_based_digital_album_rate( $self->UnitBasedDigitalAlbumRate() );
    $dbObj->unit_based_digital_single_rate( $self->UnitBasedDigitalSingleRate() );
    $dbObj->unit_based_digital_reserves_enabled( $self->UnitBasedDigitalReservesEnabled() );

    $dbObj->net_based_rate( $self->NetBasedRate() );

    #	$dbObj->net_based_rate_basis($self->NetBasedRateBasis());
    $dbObj->net_based_reserve_rate( $self->NetBasedReserveRate() );
    $dbObj->net_based_digital_reserves_enabled( $self->NetBasedDigitalReservesEnabled() );

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

    # Now save the liquidation list.
    #
    foreach my $liq ( @{ $self->{UnitBasedReserveLiquidationList}->getList() } ) {
        if ( defined $liq && $liq->Percent() ) {

            # assign from the newly saved dbObj
            $liq->ID( $dbObj->artist_contract_id );
        }
    }
    $self->{UnitBasedReserveLiquidationList}->save();

    foreach my $liq ( @{ $self->{NetBasedReserveLiquidationList}->getList() } ) {
        if ( defined $liq && $liq->Percent() ) {

            # assign from the newly saved dbObj
            $liq->ID( $dbObj->artist_contract_id );
        }
    }
    $self->{NetBasedReserveLiquidationList}->save();

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

sub delete {
    my $self = shift;

    my $myDBObj = RPS::DB::Item::ArtistContract->Lookup( artist_contract_id => $self->ArtistContractID() );
    $myDBObj->delete();

    return 1;
}

###
1;    #
###