#!/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::Client;
use Common::RSApp;

use lib '/app/tools/rps/lib';
use RPS::LabelRoyalty::Job::CreatePDFStatements;
use RPS::RoyaltyRun::Status;
use RPS::Statement::Label::PDF;
use RPS::Statement::Label::Report;
use RPS::DB::Item::LabelPayee;
use RPS::DB::Item::LabelPayeeAccount;
use RPS::DB::Item::LabelRoyaltyLabelItem;
use RPS::DB::Item::LabelRoyaltyTransactionItem;
use RPS::DB::Item::PendingTransaction;
use RPS::DB::Item::LabelRoyaltyRun;
use RPS::DB::Item::LabelRoyaltyStatement;
use RPS::DB::Item::Expense;
use RPS::DB::Item::FinanceAccount;
use RPS::DB::Item::FinanceTransaction;
use RPS::DB::Item::SaleRunMap;

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 <label_royalty_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 <label_royalty_run_id>\t\tThe id of the royalty run 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::LabelRoyaltyRun->Lookup(label_royalty_run_id => $runID);
    die "royalty run $runID does not exist!" unless $run;


    if (RPS::RoyaltyRun::Status::kWaitingToCommit != $run->status)
    {
        die "run $runID is not in the 'waiting to commit' state";
    }


    _report("*** Committing Label Royalty Run $runID ***\n");
    $gRunLabel = $run->label;
    
    # Fetch all the statements in this run, and commit them.
    #
    my $statements = RPS::DB::Item::LabelRoyaltyStatement->GetByLabelRoyaltyRunID($runID);

    _report("statements to commit: " . $statements->size(), 2);
    while ($statements->hasNext())
    {
        my $statement = $statements->next();
        _commitStatement($statement);
    }


    # Tag all sales processed this run as 'processed'.
    #
    my $saleMapItems = RPS::DB::Item::SaleRunMap->GetPaidByLabelRoyaltyRunID($runID);
    if ($saleMapItems)
    {
        _report("marking " . $saleMapItems->size() . " sales as processed", 2);
        while (my $saleMapItem = $saleMapItems->next())
        {
            my $sale = Raptor::DB::Item::Sale->Lookup(sale_id => $saleMapItem->sale_id);
            $sale->label_royalty_status(Raptor::DB::Item::Sale::kProcessed);
            $sale->save();
        }
    }


    # 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::LabelRoyaltyRun->GetAll();
    while (my $oldRun = $allRuns->next())
    {
        my $oldRunID = $oldRun->label_royalty_run_id;
        next if ($runID == $oldRunID);
        next unless (RPS::RoyaltyRun::Status::kCommitted == $oldRun->status());

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


    # Re-generate the pdf statements, to remove the 'DRAFT' watermark.
    #
    my $statementsPath = RPS::Statement::Label::PDF::StatementPathFromRunID($runID, $clientID);
    if (! -d $statementsPath)
    {
        mkpath($statementsPath) or die "ERROR: Unable to create path $statementsPath: $!\n";
    }

# !!! I don't think we need to nuke the old files - They should be overwritten anyway.
#
#    if (-d $statementsPath)
#    {
#        system("rm -rf $statementsPath/*.pdf");
#    }

    my $jobArgs = RPS::LabelRoyalty::Job::CreatePDFStatements->new
    (
        runID => $runID,
        clientID => $clientID,
        filePath => $statementsPath,
    );
    my $job = $jobArgs->enqueue();


    _report("done");
}


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

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


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

    # Fetch the default currency code to use for new account.
    #
    my $defaultCurrencyCode = Common::Client::Current()->Locale()->currencyFormat()->currencyCode();

    my $statementID = $statement->label_royalty_statement_id;
    my $payorID = $statement->payor_id;

    _report("\n------------------------------------\n", 2);

    _report("committing statement id $statementID", 2);


    # Handle the holdover account
    #
    my $total = $statement->total;
    my $labelPayeeID = $statement->payee_id;

    my $payeeAccountMap = RPS::DB::Item::LabelPayeeAccount->Lookup(label_payee_id => $labelPayeeID, payor_id => $payorID);
    if (! $payeeAccountMap)
    {
        $payeeAccountMap = RPS::DB::Item::LabelPayeeAccount->Create
        (
            label_payee_id => $labelPayeeID,
            payor_id => $payorID,
            # !!! Will need to account for currency_code
        );
        $payeeAccountMap->save();
    }

    my $payeeAccountID = $payeeAccountMap->finance_account_id;
    if (! $payeeAccountID)
    {
        my $account = RPS::DB::Item::FinanceAccount->Create
        (
            description => "advance account for label payee $labelPayeeID",
            type_code => RPS::DB::Item::FinanceAccount::kAccountTypeAdvance,
            currency_code => $defaultCurrencyCode,
        );
        $account->save();
        $payeeAccountID = $account->finance_account_id;
        _report("created new account, id $payeeAccountID", 2);


        # Save the account id in the mapping table.
        #
        $payeeAccountMap->finance_account_id($payeeAccountID);
        $payeeAccountMap->save();
    }


    # Apply the royalties total as an adjustment
    #
    my $statementSubtotal = $statement->total;
    if ($statementSubtotal < 0 or $statementSubtotal > 0)
    {
        _report("adjusting balance by total amount of $statementSubtotal", 2);
        my $transaction = RPS::DB::Item::FinanceTransaction->Create
        (
            finance_account_id => $payeeAccountID,
            amount => $statementSubtotal,
            type_code => RPS::DB::Item::FinanceTransaction::kTypeClosingBalance,
            memo => "label royalty run $gRunLabel",
            currency_code => $defaultCurrencyCode,
            # currency_code?
        );
        $transaction->save();
    }

    # Now apply all pending transactions, and delete them.
    #
    my $transactionItems = RPS::DB::Item::LabelRoyaltyTransactionItem->GetByLabelRoyaltyStatementID($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.
        #
        _report("applying pending transaction id " . $pending->pending_transaction_id . " amount of " . $pending->amount(), 2);
        my $transaction = RPS::DB::Item::FinanceTransaction->Create
        (
            finance_account_id => $pending->finance_account_id,
            amount => $pending->amount,
            type_code => $pending->type_code,
            memo => $pending->memo,
            check_number => $pending->check_number,
            currency_code => $pending->currency_code,
        );
        $transaction->save();

        $pending->delete();
    }
}





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

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