#!/usr/bin/perl
#------------------------------------------------------------ 
# Copyright (C) 2006 RoyaltyShare, Inc.   All Rights Reserved
#------------------------------------------------------------ 
use strict;

use Data::Dumper;
use Getopt::Std;
use POSIX qw(ceil);
use Carp;

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

use lib '/app/tools/rps/lib';
use RPS::Statement::Mechanical::PDF;
use RPS::Statement::Mechanical::Text;
use RPS::Mechanical::MechanicalRun;
use RPS::DB::Item::MechanicalRun;
use RPS::DB::Item::Product;
use RPS::DB::Item::Publisher;
use RPS::DB::Item::PublisherAccount;
use RPS::DB::Item::Track;
use RPS::DB::Item::TrackLicense;
use RPS::DB::Item::LicenseReserve;
use RPS::DB::Item::LicenseReserveRun;
use RPS::DB::Item::ReserveLiquidation;
use RPS::DB::Item::PendingTransaction;
use RPS::DB::Item::MechanicalStatement;
use RPS::DB::Item::MechanicalStatementTransaction;
use RPS::DB::Item::MechanicalStatementLicenseTransaction;
use RPS::DB::Item::PublisherTrackCrossedLicenseAccount;
use RPS::DB::Item::MechanicalStatementCrossedLicenseTransaction;
use RPS::DB::Item::MechanicalStatementItem;
use RPS::DB::Item::MechanicalCarryover;
use RPS::DB::Item::MechanicalRunCarryover;
use RPS::DB::Item::MechanicalStatementLicense;
use RPS::DB::Item::MechanicalStatementTrack;
use RPS::DB::Item::SaleRunMap;
#use RPS::DB::Item::SaleMechanicalStatementItemMap;
use RPS::DB::Item::FinanceAccount;
use RPS::DB::Item::FinanceTransaction;
use RPS::Mechanical::Job::CreatePDFStatements;
use RPS::Mechanical::Job::CreateTextStatements;
use RPS::RoyaltyRun::Status;

use lib '/app/tools/raptor/lib';
use Raptor::DB::Item::Sale;


my $gVerbosityLevel = 1;
my $gRunLabel;

# Get the id from the command-line
#
my %options;
_parseCommandLine(\%options);
_commitRun($options{clientID}, $options{runID});


sub _parseCommandLine
{
    my ($settings) = @_;

    my %opt;
    getopts('r:c:V:', \%opt);

    if (! $opt{r} || ! $opt{c})
    {
        _usage();
        exit(1);
    }
    $settings->{runID} = $opt{r};
    $settings->{clientID} = $opt{c};

    if (defined $opt{V})
    {
        $gVerbosityLevel = $opt{V};
    }
}

sub _usage
{
    print "\nusage: $0 -c <client_id> -r <mechanical_run_id>\n";
    print "\n";
    print "Arguments:\n";
    print "\t-c <client_id>\t\tThe client_id of the client to process\n";
    print "\t-r <mechanical_run_id>\t\tThe mechanical_run_id to commit\n";
}


sub _commitRun
{
    my ($clientID, $runID) = @_;

    # Instantiate the application singleton object.
    #
    my $appSingleton = Common::RSApp->new(clientID => $clientID);


    # Get the run state, and make sure it isn't already committed.
    #
    my $run = RPS::DB::Item::MechanicalRun->Lookup(mechanical_run_id => $runID);
    die "mechanical run $runID does not exist!" unless $run;

    if (RPS::RoyaltyRun::Status::kRunning == $run->status)
    {
        die "mechanical run $runID has not completed";
    }

    if (RPS::RoyaltyRun::Status::kCommitted == $run->status)
    {
        die "mechanical run $runID has already been committed";
    }

    if (RPS::RoyaltyRun::Status::kClosed == $run->status)
    {
        die "mechanical run $runID has already been closed";
    }

    _report("*** Committing Mechanical Royalty Run $runID ***\n");


    # Need to generate the 'name' of this run, which we use for transaction memos.
    #
    $gRunLabel = RPS::Mechanical::MechanicalRun::GenerateFileLabel($run->start_date, $run->end_date);


    # Before we start messing with any data, we need to do some pre-flight sanity checks.
    #
    if (! _preflightCheck($runID))
    {
        _report("*** preflight checks FAILED, exiting\n");
        return 1;
    }

    # Get all the tracks and albums that have unallocated shares.
    # We'll need this data later to decide which sales we can finalize.
    #
    # (XXX) THIS method will probably need to be modified.
    my %unallocatedTracks;
    my %unallocatedAlbums;
    _getUnallocatedTracksAndAlbums(\%unallocatedTracks, \%unallocatedAlbums);


    # Truncate the carryover table.
    #
    my $runCarryoverIDs = RPS::DB::Item::MechanicalRunCarryover->GetByMechanicalRunID($runID);
    while (my $carryoverMapItem = $runCarryoverIDs->next())
    {
        my $carryoverID = $carryoverMapItem->mechanical_carryover_id;
        my $carryover = RPS::DB::Item::MechanicalCarryover->Lookup(mechanical_carryover_id => $carryoverID);
        $carryover->delete();
    }


    # Get rid of entries in the carryover run map
    #
    RPS::DB::Item::MechanicalRunCarryover->DeleteByMechanicalRunID($runID);

    
    # Fetch all the statements in this run, and commit them.
    #
    my $statements = RPS::DB::Item::MechanicalStatement->GetByMechanicalRunID($runID);

    while ($statements->hasNext())
    {
        my $statement = $statements->next();
        _commitStatement($statement, \%unallocatedTracks, \%unallocatedAlbums);
    }

    # Handle the license reserves
    #
    _handleReserves($runID);



    # Mark this run as 'committed'
    #
    _report("setting run status to committed");
    $run->status(RPS::RoyaltyRun::Status::kCommitted);
    $run->save();


    # Mark any previous 'committed' runs as 'closed', if they have the same payor profile.
    #
    my $payorIDProfile = _getRunPayorIDProfile($runID);

    my $allRuns = RPS::DB::Item::MechanicalRun->GetAll();
    while (my $oldRun = $allRuns->next())
    {
        next if ($runID == $oldRun->mechanical_run_id);
        next unless (RPS::RoyaltyRun::Status::kCommitted == $oldRun->status());

        my $oldProfile = _getRunPayorIDProfile($oldRun->mechanical_run_id);
        if ($oldProfile eq $payorIDProfile)
        {
            _report("setting status of previous run " . $oldRun->mechanical_run_id . " to Closed");
            $oldRun->status(RPS::RoyaltyRun::Status::kClosed);
            $oldRun->save();
        }
    }

    # Re-create the pdf statements to remove the 'DRAFT' watermark.
    #
    _report("*** adding PDF statements job to queue");
    my $statementsPath = RPS::Statement::Mechanical::PDF::StatementPathFromRunID($runID, $clientID);
    if (-d $statementsPath)
    {
        system("rm -rf $statementsPath");
    }
    my $jobArgs = RPS::Mechanical::Job::CreatePDFStatements->new
    (
        runID 		=> $runID,
        clientID 	=> $clientID,
        filePath 	=> $statementsPath,
    );
    my $job = $jobArgs->enqueue(); 
    _report("*** done adding PDF statements job to queue!");      

    _report("*** adding Text statements job to queue");
    $statementsPath = RPS::Statement::Mechanical::Text::StatementPathFromRunID($runID, $clientID);
    $jobArgs = RPS::Mechanical::Job::CreateTextStatements->new
    (
        runID 		=> $runID,
        clientID 	=> $clientID,
        filePath 	=> $statementsPath,
    );
    $job = $jobArgs->enqueue(); 
    _report("*** done adding Text statements job to queue!");     
    

    _report("done");
}


sub _getRunPayorIDProfile
{
    my ($runID) = @_;

    my @payorIDs = RPS::DB::Item::MechanicalStatement->GetDistinctPayorsByRunID($runID);
    @payorIDs = sort @payorIDs;
    my $profile = join(',', @payorIDs);
    return $profile;
}


sub _commitStatement
{
    my ($statement, $unallocatedTracks, $unallocatedAlbums) = @_;

    my $statementID = $statement->mechanical_statement_id;

    _report("\n------------------------------------");
    # We don't commit 'unknown publisher' statements.
    #
    if (0 == $statement->publisher_id)
    {
        _report("... skipping statement $statementID, which belongs to the unknown publisher", 2);
        return;
    }
    _report("committing statement id $statementID");


    # Commit advances at the license level.
    #
    my $licenseItems = RPS::DB::Item::MechanicalStatementLicense->GetByMechanicalStatementID($statementID);
    while ($licenseItems->hasNext())
    {
        my $licenseItem = $licenseItems->next();

        _applyLicenseAdvance($licenseItem, $statementID);
    }


    # Need to apply pending transactions and such to the crossed license accounts for each track.
    #
    my $allTrackItems = RPS::DB::Item::MechanicalStatementTrack->GetByMechanicalStatementID($statementID);
    while (my $trackItem = $allTrackItems->next())
    {
        _applyCrossedLicenseAdvance($trackItem, $statement);
    }

    # Commit advances at the publisher level.
    #
    _applyPublisherAdvance($statement);


    # Handle the 'holdover' account.
    # !!! Really not necessary anymore - these two accounts have been combined.
    #
#    _handleHoldover($statement);


    # Handle carryover units
    #
    _handleCarryover($statement);

}



sub _handleReserves
{
    my ($runID) = @_;

    # 'turn the crank' on the reserves table.
    #
    my $runReserves = RPS::DB::Item::LicenseReserveRun->GetByMechanicalRunID($runID);
    while (my $runReserveItem = $runReserves->next())
    {
        my $reserve = RPS::DB::Item::LicenseReserve->Lookup(license_reserve_id => $runReserveItem->license_reserve_id);

		if (! $reserve)
		{
			# This should never happen!
			#
			_report("ERROR!  reserve id " . $runReserveItem->license_reserve_id . " is MISSING");
			next;
		}
        my $period = $reserve->periods_remaining();

        if (1 == $period)
        {
            # This reserve has been liquidated;
            # So we'll make note of the run id.
            #
            $reserve->liquidated_run_id($runID);
        }

        # Just decrement the periods_remaining column.
        # Liquidated reserves will end up with '0' periods_remaining.
        # 
        $reserve->periods_remaining($period - 1);
        $reserve->save();
    }
}



sub _handleCarryover
{
    my ($statement) = @_;

    my $statementItems = RPS::DB::Item::MechanicalStatementItem->GetByMechanicalStatementID($statement->mechanical_statement_id);
    while (my $item = $statementItems->next())
    {
        if ($item->carryover)
        {

            my $newCarryover = RPS::DB::Item::MechanicalCarryover->Create
            (
                track_license_id    => $item->track_license_id,
                sale_stat_rate_id   => $item->sale_stat_rate_id,
                issue_stat_rate_id  => $item->issue_stat_rate_id,
                product_id          => $item->product_id,
                units               => $item->carryover,
            );

            $newCarryover->save();
            _report("   created carryover: " . $newCarryover->mechanical_carryover_id . " "
            . $item->track_license_id . " " 
            . $item->sale_stat_rate_id . " " 
            . $item->issue_stat_rate_id . " "
            . $item->product_id . " "
            . $item->carryover, 2);
        }
    }
}

sub _applyCrossedLicenseAdvance
{
    my ($trackItem, $statement) = @_;


    # Is there any activity?
    #
    if (0 != $trackItem->crossed_previous_advance_balance
     || 0 != $trackItem->crossed_transaction_subtotal
     || 0 != $trackItem->crossed_advance_balance)
    {
        # See if we need to create a new account and mapping.
        #
        my $publisherID = $trackItem->publisher_id;
        my $trackID = $trackItem->track_id;
        my $payorID = $statement->payor_id;
        my $statementID = $statement->mechanical_statement_id;

        my $accountID;
        my $crossedAccountMap = RPS::DB::Item::PublisherTrackCrossedLicenseAccount->Lookup
        (
            publisher_id => $trackItem->publisher_id,
            track_id => $trackItem->track_id,
            payor_id => $statement->payor_id,
        );

        if ($crossedAccountMap)
        {
            $accountID = $crossedAccountMap->finance_account_id;
        }
        
        if (! $accountID)
        {
            my $account = RPS::DB::Item::FinanceAccount->Create
            (
                description => "account for crossed licenses, publisher $publisherID, track $trackID, payor $payorID",
                type_code => RPS::DB::Item::FinanceAccount::kAccountTypeAdvance,
            # !!! Will need to account for currency_code
                currency_code => 'USD',
            );
            $account->save();

            $accountID = $account->finance_account_id;

            # Create the map if necessary.
            #
            if (! $crossedAccountMap)
            {
                $crossedAccountMap = RPS::DB::Item::PublisherTrackCrossedLicenseAccount->Create
                (
                    publisher_id => $trackItem->publisher_id,
                    track_id => $trackItem->track_id,
                    payor_id => $statement->payor_id,
                    finance_account_id => $accountID,
                );
            }
            else
            {
                $crossedAccountMap->finance_account_id($accountID);
            }
            $crossedAccountMap->save();
        }


        # Now apply all pending transactions, and delete them.
        #
        my $transactionItems = RPS::DB::Item::MechanicalStatementCrossedLicenseTransaction->GetByMechanicalStatementIDPublisherIDTrackID($statementID, $publisherID, $trackID);


        while (my $item = $transactionItems->next())
        {
            # Fetch the 'real' pending transaction.
            #
            my $pending = RPS::DB::Item::PendingTransaction->Lookup(pending_transaction_id => $item->pending_transaction_id);


            # !!! Note that amount == amount. no sign flipping.  We have to get the sign right when we create the
            # !!! pending transaction in the first place.
            #
            my $transaction = RPS::DB::Item::FinanceTransaction->Create
            (
                finance_account_id => $pending->finance_account_id,
                amount => Common::RSMath::round($pending->amount, 2),
                transaction_date => $pending->transaction_date,
                type_code => $pending->type_code,
                memo => $pending->memo,
                check_number => $pending->check_number,
                currency_code => $pending->currency_code,
            );
            $transaction->save();


            # Done with the pending transaction, get rid of it.
            #
            $pending->delete();
        }


        # Now, figure out what sort of adjustment to make on this account based on what happened
        # on this statement.
        #
        my $amount = $trackItem->crossed_advance_balance - ($trackItem->crossed_previous_advance_balance + $trackItem->crossed_transaction_subtotal);
        
        if (0 != $amount)
        {
            my $transaction = RPS::DB::Item::FinanceTransaction->Create
            (
                finance_account_id => $accountID,
                amount => Common::RSMath::round($amount, 2),
                transaction_date => Common::DB::Item::kDateTimeNow(),
                type_code => RPS::DB::Item::FinanceTransaction::kTypeClosingBalance,
                memo => "mechanical run $gRunLabel, statement $statementID",
                # !!! At the moment we are presuming that _everything_ is done in US Dollars...
                # !!! This will have to change once we start to support different currencies
                # !!! for publishers...
                #
                currency_code => 'USD',
            );
            $transaction->save();

            _report("   removed transaction amount $amount from license advance account",2);
        }
    }
}

sub _applyLicenseAdvance
{
    my ($licenseItem, $statementID) = @_;


    # Is there any activity?
    #
    if (0 != $licenseItem->previous_advance_balance
     || 0 != $licenseItem->transaction_subtotal
     || 0 != $licenseItem->advance_balance)
    {
        my $statementLicenseID = $licenseItem->mechanical_statement_license_id;
        _report("   mechanical_statement_license $statementLicenseID"
         . " has an advance balance of " . $licenseItem->previous_advance_balance, 2);
       

        # Fetch the license, and see if we need to create the advance account.
        #
        my $trackLicense = RPS::DB::Item::TrackLicense->Lookup(track_license_id => $licenseItem->track_license_id);

        # !!! Currently assuming that the license type is NOT controlled comp
        #
#        assert(RPS::DB::Item::TrackLicense::kPublishingLicense == $trackLicense->type);

#        my $license = RPS::DB::Item::License->Lookup(license_id => $trackLicense->id);
        my $accountID = $trackLicense->finance_account_id;
        if (! $accountID)
        {
            # Creating the advance account.
            # -- Note that the starting balance is theoretically in two places:
            #    Both in the license table, and in the mechanical_statement_table as
            #    the 'previous_balance' column.
            #    I'm going to use the value in the license table...
            #
            my $licenseID = $trackLicense->track_license_id;
            my $account = RPS::DB::Item::FinanceAccount->Create
            (
                description => "advance account for track license $licenseID",
                type_code => RPS::DB::Item::FinanceAccount::kAccountTypeAdvance,
            # !!! Will need to account for currency_code
                currency_code => 'USD',
            );
            $account->save();

            $accountID = $account->finance_account_id;

            # Update the license with the account id.
            #
            $trackLicense->finance_account_id($accountID);
            $trackLicense->save();
            _report("      created new advance account $accountID for track license $licenseID", 2);
        }


        # Now apply all pending transactions, and delete them.
        #
        my $transactionItems = RPS::DB::Item::MechanicalStatementLicenseTransaction->GetByMechanicalStatementLicenseID($statementLicenseID);
        while (my $item = $transactionItems->next())
        {
            # Fetch the 'real' pending transaction.
            #
            my $pending = RPS::DB::Item::PendingTransaction->Lookup(pending_transaction_id => $item->pending_transaction_id);


            # !!! Note that amount == amount. no sign flipping.  We have to get the sign right when we create the
            # !!! pending transaction in the first place.
            #
            my $transaction = RPS::DB::Item::FinanceTransaction->Create
            (
                finance_account_id => $pending->finance_account_id,
                amount => Common::RSMath::round($pending->amount, 2),
                transaction_date => $pending->transaction_date,
                type_code => $pending->type_code,
                memo => $pending->memo,
                check_number => $pending->check_number,
                currency_code => $pending->currency_code,
            );
            $transaction->save();


            # Done with the pending transaction, get rid of it.
            #
            $pending->delete();
        }


        # Now, figure out what sort of adjustment to make on this account based on what happened
        # on this statement.
        #
        # !!! Not clear whether this is going to work for 'zeroing-out' the balance if the license was crossed...
        #
        #
        my $amount = $licenseItem->advance_balance - ($licenseItem->previous_advance_balance + $licenseItem->transaction_subtotal);
        
        if (0 != $amount)
        {
            my $transaction = RPS::DB::Item::FinanceTransaction->Create
            (
                finance_account_id => $accountID,
                amount => Common::RSMath::round($amount, 2),
                transaction_date => Common::DB::Item::kDateTimeNow(),
                type_code => RPS::DB::Item::FinanceTransaction::kTypeClosingBalance,
                memo => "mechanical run $gRunLabel, statement $statementID",
                # !!! At the moment we are presuming that _everything_ is done in US Dollars...
                # !!! This will have to change once we start to support different currencies
                # !!! for publishers...
                #
                currency_code => 'USD',
            );
            $transaction->save();

            _report("   removed transaction amount $amount from license advance account",2);
        }
    }
}


# !!! This is a misnomer - we don't look at the 'advance' account anymore - no such thing
# !!! There is just 1 account.
#
sub _applyPublisherAdvance
{
    my ($statement) = @_;


    my $statementID = $statement->mechanical_statement_id;


    # !!! This is going to have to change.
    #
    # We no longer assume the new balance, or applied to balance.
    #
    # Instead...  we first apply the statement subtotal as a credit,
    # then apply each pending transaction.
    #

    my $publisherID = $statement->publisher_id;
    my $payorID = $statement->payor_id;

    # Create a new publisher_id/payor_id/account_id mapping if necessary
    #
    my $accountMap = RPS::DB::Item::PublisherAccount->Lookup(publisher_id => $publisherID, payor_id => $payorID);
    if (! $accountMap)
    {
        $accountMap = RPS::DB::Item::PublisherAccount->Create
        (
            publisher_id => $publisherID,
            payor_id => $payorID,
        );
        $accountMap->save();
    }


    # Create a new finance account if necessary
    #
    my $accountID = $accountMap->finance_account_id;
    if (! $accountID)
    {
        # Create a new account 
        #
        my $account = RPS::DB::Item::FinanceAccount->Create
        (
            description => "holdover account for publisher $publisherID payor $payorID",
            type_code => RPS::DB::Item::FinanceAccount::kAccountTypeHoldover,
            currency_code => 'USD',
        );
        $account->save();
        $accountID = $account->finance_account_id;


        # save the account_id in the map table
        #
        $accountMap->finance_account_id($accountID);
        $accountMap->save();
    }


    # Apply the statement subtotal as a transaction to this account.
    #
    # !!! We want the memo to be the run name - I'd like a consistent interface around that.
    my $statementSubtotal = $statement->subtotal;
    if ($statementSubtotal < 0 or $statementSubtotal > 0)
    {
        my $transaction = RPS::DB::Item::FinanceTransaction->Create
        (
            finance_account_id => $accountID,
            amount => Common::RSMath::round($statementSubtotal, 2),
            transaction_date => Common::DB::Item::kDateTimeNow(),
            type_code => RPS::DB::Item::FinanceTransaction::kTypeClosingBalance,
            memo => "mechanical statement $statementID royalties owed",
            # !!! At the moment we are presuming that _everything_ is done in US Dollars...
            # !!! This will have to change once we start to support different currencies
            # !!! for publishers...
            #
            currency_code => 'USD',
        );
        $transaction->save();
    }


    # Now apply all pending transactions, and delete them.
    #
    my $transactionItems = RPS::DB::Item::MechanicalStatementTransaction->GetByMechanicalStatementID($statementID);
    while (my $item = $transactionItems->next())
    {
        # Fetch the 'real' pending transaction.
        #
        my $pending = RPS::DB::Item::PendingTransaction->Lookup(pending_transaction_id => $item->pending_transaction_id);


        # !!! Note that amount == amount. no sign flipping.  We have to get the sign right when we create the
        # !!! pending transaction in the first place.
        #
        my $transaction = RPS::DB::Item::FinanceTransaction->Create
        (
            finance_account_id => $pending->finance_account_id,
            amount => Common::RSMath::round($pending->amount, 2),
            type_code => $pending->type_code,
            transaction_date => $pending->transaction_date,
            memo => $pending->memo,
            check_number => $pending->check_number,
            currency_code => $pending->currency_code,
        );
        $transaction->save();


        # Mark this item as processed.
        #
#        $pending->processed(1);
#        $pending->save();

        # No, just delete it.
        #
        $pending->delete();
    }
}




# (XXX)
# !!! This may be a problem.
# !!! I am eliminating all 'unknown publisher' track_licenses.
# !!! So I may need a new way to determine which tracks and albums have
# !!! unallocated shares.
#
# May just have to use a more brute-force method...
#
# Let's just totally re-write this, since the old method relied on the unknown publisher.
#

sub _getUnallocatedTracksAndAlbums
{
    my ($unallocatedTracks, $unallocatedAlbums) = @_;
    

    # Scan the track_license table, and note the share for every
    # track and album
    #
    my %trackShares;
    my %albumShares;

    my $trackLicenseList = RPS::DB::Item::TrackLicense->GetAll();
    while ($trackLicenseList->hasNext())
    {
        my $trackLicense = $trackLicenseList->next();
        my $trackID = $trackLicense->track_id;

        $trackShares{$trackID} += $trackLicense->share;

        my $track = RPS::DB::Item::Track->Lookup(track_id => $trackID);
        my $albumID = $track->album_id;
        if ($albumID)
        {
            $albumShares{$albumID} += $trackLicense->share;
        }
    }


    # Now we can figure out which tracks and albums are not fully allocated.
    #
    foreach my $trackID (keys %trackShares)
    {
        if ($trackShares{$trackID} < 100)
        {
            $unallocatedTracks->{$trackID} = 1;
        }
    }


    # We want to mark _every track_ on these albums as unallocated, even
    # if they technically are - This is the safest way to insure that we
    # know to handle adjustments properly down the road.
    # (Basically, if in the future additional licenses are added to the album,
    #  we will need to possibly make adjustments to the controlled comps on
    #  all that album's tracks.)
    #
    foreach my $albumID (keys %albumShares)
    {
        if ($albumShares{$albumID} < 100)
        {
            $unallocatedAlbums->{$albumID} = 1;

            my $trackList = RPS::DB::Item::Track->GetTracksByAlbumID($albumID);
            while ($trackList->hasNext())
            {
                my $anotherTrack = $trackList->next();
                $unallocatedTracks->{$anotherTrack->track_id} = 1;
            }
        }
    }
}




sub _report
{
    my ($string, $verbosity) = @_;
    $verbosity = 1 unless defined $verbosity;

    if ($gVerbosityLevel >= $verbosity)
    {
        print STDERR $string . "\n";
    }
}



sub _preflightCheck
{
    my ($runID) = @_;

    return 0 unless _pendingTransactionsAreValid($runID);

	# See if all the reserves are present and accounted for...
	#
	if (RPS::DB::Item::LicenseReserveRun->CountMissingRunReserves($runID) > 0)
	{
		_report("ERROR - Not all run reserves are accounted for");
		return 0;
	}

	return 1;
}


sub _pendingTransactionsAreValid
{
    my ($runID) = @_;

    # Make sure nobody deleted the pending transactions that appear on this run!
    #
    my $statements = RPS::DB::Item::MechanicalStatement->GetByMechanicalRunID($runID);
    while (my $statement = $statements->next())
    {
        my $statementID = $statement->mechanical_statement_id;
        my $statementTransItems = RPS::DB::Item::MechanicalStatementTransaction->GetByMechanicalStatementID($statementID);
        my $transItem;
        while ($transItem = $statementTransItems->next())
        {
            my $pendingTransactionID = $transItem->pending_transaction_id;
            my $pending = RPS::DB::Item::PendingTransaction->Lookup(pending_transaction_id => $pendingTransactionID);
            if (! $pending)
            {
                _report("ERROR - original pending transaction was deleted! : " . Dumper($transItem));
                return 0;
            }
        }

        my $licenseTransItems = RPS::DB::Item::MechanicalStatementLicenseTransaction->GetByMechanicalStatementID($statementID);
        while ($transItem = $licenseTransItems->next())
        {
            my $pendingTransactionID = $transItem->pending_transaction_id;
            my $pending = RPS::DB::Item::PendingTransaction->Lookup(pending_transaction_id => $pendingTransactionID);
            if (! $pending)
            {
                _report("ERROR - original pending transaction was deleted! : " . Dumper($transItem));
                return 0;
            }
        }
    }

    return 1;
}