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

use strict;
use warnings;

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

use lib '/app/tools/rps/lib';
use RPS::DB::Item::CATrackLicense;
use RPS::DB::Item::PendingTransaction;
use RPS::DB::Item::CAPublisherAccount;
use RPS::DB::Item::CAPublisherIndirectBalanceAccount;
use RPS::Publisher::CA::Publisher;
use RPS::Payor::Payor;
use RPS::Payor::PayorList;
use base 'RPS::Payor::PayorList';

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

    # In this mode, we _need_ a publisher id.
    #
    my $publisherID = $args{publisherID};
    assert($publisherID);

    $self->{_publisherID} = $publisherID;

    $self->{Payor} = [];

    my $payors = RPS::DB::Item::Payor->GetAll();

    while ( $payors->hasNext() ) {
        my $data = $payors->next();

        # We want to show up to 2 lines per payor, so doubling the list allows me
        # to simly loop over them in the template.
        #
        push @{ $self->{Payor} }, $self->_getPayorFromDBItem( $data, 'direct' );
        push @{ $self->{Payor} }, $self->_getPayorFromDBItem( $data, 'indirect' );
    }

    return $self;
}

sub _getPayorFromDBItem {
    my ( $self, $dbItem, $type ) = @_;

    my $payorObj = $self->SUPER::_getPayorFromDBItem($dbItem);

    my $publisher = RPS::Publisher::CA::Publisher->new(
        publisherID => $self->{_publisherID},
        loadSubs    => 0,
        readOnly    => 1,
    );

    my $forcePublisherDirect = 1;

    if ( $publisher->AdminID() || $publisher->AgentID ) {
        $forcePublisherDirect = 0;
    }

    # Going to 'annotate' the publisher with the count.
    # This is a bit of a hack, but I really don't want to bother
    # subclassing Payor for this purpose.

    my $licenseCount;

    if ( $type eq 'direct' ) {

        my $totalLicenses = RPS::DB::Item::CATrackLicense->GetByPublisherIDPayorID( $self->{_publisherID}, $payorObj->PayorID() );

        if ( $forcePublisherDirect == 1 ) {
            $licenseCount = $totalLicenses->size();
        } else {
            my $directLicenses =
              RPS::DB::Item::CATrackLicense->GetDirectByPublisherIDPayorID( $self->{_publisherID}, $payorObj->PayorID() );
            $licenseCount = $directLicenses->size();
        }
    }

    if ( $type eq 'indirect' ) {
        if ( $forcePublisherDirect == 1 ) {
            $licenseCount = 0;
        } else {
            my $indirectLicenses =
              RPS::DB::Item::CATrackLicense->GetIndirectByPublisherIDPayorID( $self->{_publisherID}, $payorObj->PayorID() );
            $licenseCount = $indirectLicenses->size();
        }
    }

    $payorObj->{LicenseCount} = $licenseCount;

    # We need to know if there are any accounts (direct or indirect).
    #

    my $accounts;

    if ( $type eq 'direct' ) {
        $accounts = RPS::DB::Item::CAPublisherAccount->GetByPayorPublisherID( $payorObj->PayorID(), $self->{_publisherID} );
    }
    if ( $type eq 'indirect' ) {
        $accounts = RPS::DB::Item::CAPublisherIndirectBalanceAccount->GetByPayorPublisherID( $payorObj->PayorID(), $self->{_publisherID} );

        # For indirect accounts, we need to total up all of the pending transactions.
        #
        my $pendingBalance;
        while ( my $account = $accounts->next() ) {
            $pendingBalance += RPS::DB::Item::PendingTransaction->GetPendingBalance( $account->{finance_account_id} );
        }

        $payorObj->{PendingBalance} =
          Common::FormObject::Scalar::Money->new( value => $pendingBalance, precision => 0.2, currencyCode => 'USD' );

    }

    $payorObj->{HasAccount} = $accounts->size();

    # Let's add an element so that we can be sure things are lining up correctly.
    #

    if ( $type eq 'direct' ) {
        $payorObj->{Direct} = 1;
    }
    if ( $type eq 'indirect' ) {
        $payorObj->{Indirect} = 1;
    }

    return $payorObj;
}

###
1;    #
###