#---------------------------------------------------------------
# ____                   _ _         ____  _
#|  _ \ ___  _   _  __ _| | |_ _   _/ ___|| |__   __ _ _ __ ___
#| |_) / _ \| | | |/ _` | | __| | | \___ \| '_ \ / _` | '__/ _ \
#|  _ < (_) | |_| | (_| | | |_| |_| |___) | | | | (_| | | |  __/
#|_| \_\___/ \__, |\__,_|_|\__|\__, |____/|_| |_|\__,_|_|  \___|
#            |___/             |___/
#
# Copyright (C) 2008 RoyaltyShare, Inc.      All Rights Reserved
#---------------------------------------------------------------
package RPS::License::BaseCrossedLicenseAccount;

use Carp;
use strict;
use warnings;

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

use lib '/app/tools/rps/lib';
use RPS::Finance::Account;
use RPS::DB::Item::FinanceAccount;

use Common::FormObject;
use base 'Common::FormObject';

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

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

    my %properties;

    $properties{ $self->_publisherID() } = $args{publisherID};
    $properties{track_id}                = $args{trackID};
    $properties{payor_id}                = $args{payorID};

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

    return $self;
}

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

    $self->{PublisherID} = Common::FormObject::Scalar->new( value => $props->{ $self->_publisherID() }, readOnly => 1 );
    $self->{TrackID}     = Common::FormObject::Scalar->new( value => $props->{track_id},                readOnly => 1 );
    $self->{PayorID}     = Common::FormObject::Scalar->new( value => $props->{payor_id},                readOnly => 1 );
}

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

    if ( $self->loadSubs() ) {
        my $crossedAccountMap = $self->_account()->Lookup(
            $self->_publisherID() => $props->{ $self->_publisherID() },
            payor_id              => $props->{payor_id},
            track_id              => $props->{track_id},
        );
        my $crossedAccountObj;
        if ( $crossedAccountMap && $crossedAccountMap->finance_account_id ) {
            $crossedAccountObj = RPS::Finance::Account->new( accountID => $crossedAccountMap->finance_account_id );

        }

        if ( !$crossedAccountObj ) {
            $crossedAccountObj = RPS::Finance::Account->new();

            $crossedAccountObj->CurrencyCode( $self->_currencyCode() );
        }

        $self->{FinanceAccount} = $crossedAccountObj;

        # I think we want to list all the licenses that are attached to this account.
        #
        $self->{CrossedLicenseList} = $self->_licenseList()
          ->new( trackID => $props->{track_id}, publisherID => $props->{ $self->_publisherID() }, payorID => $props->{payor_id} );
    }
}

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

    my $publisherID = $self->PublisherID();
    my $trackID     = $self->TrackID();
    my $payorID     = $self->PayorID();

    assert($publisherID);
    assert($trackID);
    assert($payorID);

    if ( !$self->{FinanceAccount}->Description() ) {
        $self->{FinanceAccount}->Description("crossed license account for track $trackID publisher $publisherID payor $payorID");
    }
    if ( !$self->{FinanceAccount}->TypeCode() ) {
        $self->{FinanceAccount}->TypeCode(RPS::DB::Item::FinanceAccount::kAccountTypeHoldover);
    }
    $self->{FinanceAccount}->save();
    my $accountID = $self->{FinanceAccount}->AccountID();

    my $crossedAccountMap = $self->_account()->Lookup(
        $self->_publisherID() => $publisherID,
        payor_id              => $payorID,
        track_id              => $trackID,
    );
    if ( !$crossedAccountMap ) {
        $crossedAccountMap = $self->_account()->Create(
            $self->_publisherID() => $publisherID,
            payor_id              => $payorID,
            track_id              => $trackID,
            finance_account_id    => $accountID,
        );
        $crossedAccountMap->save();
    }

    return 1;
}

###
1;    #
###