#!/usr/bin/perl
use strict;

use Data::Dumper;
use Getopt::Std;
use POSIX qw(ceil);
use POSIX ":sys_wait_h";
use Sys::Hostname;
use Carp;

use lib '/app/tools/common/lib';
use Common::DB::Item;
use Common::Assert;
use Common::TextProgressBar;
use Common::Timer;
use Common::DB::Item::Service;

#use lib '/app/tools/data_classes/lib';
#use File::Sale;
use lib '/app/tools/raptor/lib';

#use Raptor::Sale::Sale;
use Raptor::DB::Item::Sale;
use Raptor::DB::Item::File;

use lib '/app/tools/rps/lib';
use RPS::DB::Item::ArtistPayeeAccount;
use RPS::DB::Item::ArtistRoyaltyAlbum;
use RPS::DB::Item::ArtistRoyaltyRun;
use RPS::DB::Item::ArtistRoyaltyStatement;
use RPS::DB::Item::FinanceAccount;
use RPS::DB::Item::FinanceTransaction;
use RPS::DB::Item::ArtistRoyaltyAlbumBalanceAccount;

my $gVerbosityLevel = 1;

# Parse the command-line options.
#
my %options;
_parseCommandLine( \%options );

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

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

    _report("\n---- Converting run $runID");

    my $statements = RPS::DB::Item::ArtistRoyaltyStatement::GetByArtistRoyaltyRunID($runID);
    while ( my $statement = $statements->next() ) {
        _fixStatement($statement);
    }
}

sub _fixStatement {
    my ($statement) = @_;
    _report( "  statement: " . $statement->artist_royalty_statement_id, 2 );

    my $artistPayeeID  = $statement->payee_id;
    my $statementTotal = $statement->total;
    my $amountDue      = $statement->amount_due;

    my $financeAccountID = _artistPayeeAccountID( $artistPayeeID, $statement->payor_id );

    #    my $expectedTransactionAmount = ($amountDue > 0 ? $amountDue : $statementTotal);
    my $expectedTransactionAmount = $statementTotal;

    # If the expected amount is 0, then there shouldn't be any transactions?
    # Or, there should just be 1 transaction that established the 'previous balance'.
    #
    if ( 0 == $expectedTransactionAmount ) {

        # We might end up here if there was an amount due that paid off the entire previous balance.
        # In that case, we want to roll back that transaction, and force them to make that payment the
        # next time we run.
        #
        my $lastTransaction = RPS::DB::Item::FinanceTransaction::GetLastAccountTransaction($financeAccountID);
        my $lastTransactionAmount;
        if ($lastTransaction) {
            $lastTransactionAmount = $lastTransaction->amount;
        }

        my $expectedMemo = "artist statement " . $statement->artist_royalty_statement_id;
        if ( $lastTransaction && $lastTransaction->memo eq $expectedMemo ) {
            _report("   going to eliminate the last transaction");
            $lastTransaction->delete();
        }

    } else {

        # grab the last transaction.
        #
        if ( !$financeAccountID ) {

            # If there is no account, then probably we need to create one:  Let's see if there was an expected amount.
            #
            if ( 0 != $expectedTransactionAmount ) {
                _report("artist $artistPayeeID will need whole new account, with an amount of $expectedTransactionAmount");
                my $newAccount = RPS::DB::Item::FinanceAccount->Create(
                    description => 'account for artist payee ' . $artistPayeeID,
                    type_code   => 1,
                );
                $newAccount->save();

                $financeAccountID = $newAccount->finance_account_id;

                # Should already be an account map, just with no account id.
                #
                my $accountMap = RPS::DB::Item::ArtistPayeeAccount->Lookup(
                    artist_payee_id => $artistPayeeID,
                    payor_id        => $statement->payor_id,
                );
                if ( !$accountMap ) {
                    _report("!!!! No account map created!");
                }
                $accountMap->finance_account_id($financeAccountID);
                $accountMap->save();
            }
        }

        my $lastTransaction = RPS::DB::Item::FinanceTransaction::GetLastAccountTransaction($financeAccountID);
        my $lastTransactionAmount;
        if ($lastTransaction) {
            $lastTransactionAmount = $lastTransaction->amount;
        }

        # !!! sanity check - should be a 'artist statement X' transaction
        #
        my $expectedMemo = "artist statement " . $statement->artist_royalty_statement_id;
        if ( $lastTransaction && $lastTransaction->memo ne $expectedMemo ) {
            _report( " !!! for artist $artistPayeeID, last transaction does not appear to be correct! " . Dumper($lastTransaction) );
            return;
        }

        # Ok, so now we can see whether all is well.
        #
        if ( $lastTransactionAmount != $expectedTransactionAmount ) {
            _report(" !!! artist $artistPayeeID, last transaction amount of $lastTransactionAmount != expected $expectedTransactionAmount");

            # So, this would usually mean that I need to delete the last transaction, and re-post
            #
            $lastTransaction->delete() if $lastTransaction;
            my $newTransaction = RPS::DB::Item::FinanceTransaction->Create(
                finance_account_id => $financeAccountID,
                amount             => $expectedTransactionAmount,
                memo               => $expectedMemo,
                type_code          => RPS::DB::Item::FinanceTransaction::kTypeAdjustment,
            );
            $newTransaction->save();
        }
    }
}

sub _artistPayeeAccountID {
    my ( $payeeID, $payorID ) = @_;

    my $accountMap = RPS::DB::Item::ArtistPayeeAccount->Lookup(
        artist_payee_id => $payeeID,
        payor_id        => $payorID,
    );
    return undef unless defined $accountMap;
    return $accountMap->finance_account_id;
}

sub _usage {
    print "\nusage: $0 -c client_id [-V]\n";
    print "\n";
    print "Arguments:\n";
    print "\t-c <client_id>\t\tThe client_id of the client to process\n";
    print "\t-V <N>\t\t\tVerbosity level - 0 means no output\n";
}

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

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

# Pass dates in 'yyyy-mm-dd' format.
#
sub _parseCommandLine {
    my ($settings) = @_;

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

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

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