#!/usr/bin/perl
use strict;
use Data::Dumper;
use lib '/app/tools/common/lib';
use lib '/app/tools/rps/lib';
use Common::RSApp;
use Common::WriteXML;
use RPS::DB::Item::Payor;
use RPS::DB::Item::ArtistRoyaltyRun;
use RPS::DB::Item::LabelRoyaltyRun;
use RPS::DB::Item::MechanicalRun;
use RPS::DB::Item::UKMechanicalRun;
use RPS::RoyaltyRun::Status;


# To make this sample code run, we need an Application singleton.
# We'll use C_RSDEMO as the client id.
#
my $app = Common::RSApp->new(clientID => 202);

my $xml = getRunTypeStuff();

print "Here's the data structure:" . Dumper($xml) . "\n";

print "... And here is the corresponding XML:\n";
print Common::WriteXML::GetXMLString($xml) . "\n";


sub getRunTypeStuff
{
    # First, we can declare an empty hash.  This method will return this hash by reference.
    #
    my %returnHash;

    # Rather than build joins, I'm going to read the whole payor table in at once and cache it in a hash.
    # I find this easier to grok, personally, and the payor table is not very large...
    #
    my %payorCache;
    my $allPayors = RPS::DB::Item::Payor->GetAll();
    while (my $payor = $allPayors->next())
    {
        # We'll use the payor_id as the key, and the name as the hash value.
        #
        $payorCache{ $payor->payor_id() } = $payor->name();
    }


    # Declaring these way out here... We will use these two variables a few times to traverse hashes.
    #
    my ($key, $value);


    # Since we're going to be returning _every_ completed (or commited or closed) run, I would
    # just iterate over a single collection and build the nested hashes as we go.
    #
    # So, here's how I would do this for artist runs.
    #
    my $allArtistRuns = RPS::DB::Item::ArtistRoyaltyRun->GetAll(); 
    #
    # Get all the runs.   Now, if we had a 'GetAllCompletedRuns' method, I'd use that instead, so I could skip
    # the test of 'status' in the following loop.  But this certainly works...

    # There are a few ways to go here... I think we want a 'list' of <Payor> blocks.  The easiest
    # way to do that will be to build up a temporary hash (keyed by payor_id) containing Arrays of
    # runs. Then at the end of this loop we'll iterate over that and shove things into the 'return hash'.
    #
    my %artistPayors;

    while (my $artistRun = $allArtistRuns->next())
    {
        if (RPS::RoyaltyRun::Status::kComplete != $artistRun->status()
         && RPS::RoyaltyRun::Status::kCommitted != $artistRun->status()
         && RPS::RoyaltyRun::Status::kClosed != $artistRun->status())
        {
            # Skip over runs that are not complete, committed, or closed.
            #
            next;
        }

        # Let's de-reference some fields to make this easier to read.
        #
        my $payorID = $artistRun->payor_id();
        my $label = $artistRun->label();
        my $runID = $artistRun->artist_royalty_run_id();
        

        # So note how we treat the final link in this hash chain as an array.
        # Note also that we don't have to explicitly allocate an array. Perl just deals with it.
        #
        push @{$artistPayors{$payorID}}, {
            'RunID' => $runID,
            'Label' => $label,
        };
    }
    # Now iterate over that temporary hash... Basically we want to re-build that as an array that lives
    # inside the hash we want to return.
    #
    my @artistPayorArray;
    while (($key, $value) = each(%artistPayors))
    {
        # '$value' here is an array reference.
        # To tell the XML Output code that each of these should be in a tag called <Run>, we
        # add this 'Run' key
        #
        push @artistPayorArray, {
            'PayorID' => $key,
            'Name' => $payorCache{$key},
            'Run' => $value,  # remember, 'Run' is an array reference
        };
    }
    # Now we add this new 'payor array' to the outgoing hash.
    # Again, we want each item in this array to start with a <Payor> tag, so
    # we use a hash key of 'Payor'.
    $returnHash{'ArtistRoyalty'}{'Payor'} = \@artistPayorArray;



    my $allLabelRuns = RPS::DB::Item::LabelRoyaltyRun->GetAll(); 

    my %labelPayors;

    my $size = $allLabelRuns->size();
    print "label Run collection size: $size\n";

    while (my $labelRun = $allLabelRuns->next())
    {
        if (RPS::RoyaltyRun::Status::kComplete != $labelRun->status()
         && RPS::RoyaltyRun::Status::kCommitted != $labelRun->status()
         && RPS::RoyaltyRun::Status::kClosed != $labelRun->status())
        {
            next;
        }

        my $payorID = $labelRun->payor_id();
        my $label = $labelRun->label();
        my $runID = $labelRun->label_royalty_run_id();

        push @{$labelPayors{$payorID}}, {
            'RunID' => $runID,
            'Label' => $label,
        };
    }

    my @labelPayorArray;
    while (($key, $value) = each(%labelPayors))
    {
        push @labelPayorArray, {
            'PayorID' => $key,
            'Name' => $payorCache{$key},
            'Run' => $value,  # remember, 'Run' is an array reference
        };
    }

    $returnHash{'LabelRoyalty'}{'Payor'} = \@labelPayorArray;


    # Again, this time with US Mechanicals.
    #
    my $allUSMechRuns = RPS::DB::Item::MechanicalRun->GetAll(); 
    my %usMechPayors;
    while (my $mechRun = $allUSMechRuns->next())
    {
        if (RPS::RoyaltyRun::Status::kComplete != $mechRun->status()
         && RPS::RoyaltyRun::Status::kCommitted != $mechRun->status()
         && RPS::RoyaltyRun::Status::kClosed != $mechRun->status())
        {
            next;
        }

        my $payorID = $mechRun->payor_id();
        my $label = $mechRun->label();
        my $runID = $mechRun->mechanical_run_id();
        

        push @{$usMechPayors{$payorID}}, {
            'RunID' => $runID,
            'Label' => $label,
        };
    }

    my @usMechPayorArray;
    while (($key, $value) = each(%usMechPayors))
    {
        push @usMechPayorArray, {
            'PayorID' => $key,
            'Name' => $payorCache{$key},
            'Run' => $value,
        };
    }
    $returnHash{'USMechanicals'}{'Payor'} = \@usMechPayorArray;


    # !!! I'll leave the others as an exercise for the reader...

    # Again, this time with UK Mechanicals.
    #
    my $allUKMechRuns = RPS::DB::Item::UKMechanicalRun->GetAll(); 
    my %ukMechPayors;
    while (my $ukMechRun = $allUKMechRuns->next())
    {
        if (RPS::RoyaltyRun::Status::kComplete != $ukMechRun->status()
         && RPS::RoyaltyRun::Status::kCommitted != $ukMechRun->status()
         && RPS::RoyaltyRun::Status::kClosed != $ukMechRun->status())
        {
            next;
        }

        my $payorID = $ukMechRun->payor_id();
        my $label = $ukMechRun->label();
        my $runID = $ukMechRun->uk_mechanical_run_id();
        

        push @{$ukMechPayors{$payorID}}, {
            'RunID' => $runID,
            'Label' => $label,
        };
    }

    my @ukMechPayorArray;
    while (($key, $value) = each(%ukMechPayors))
    {
        push @ukMechPayorArray, {
            'PayorID' => $key,
            'Name' => $payorCache{$key},
            'Run' => $value,
        };
    }
    $returnHash{'UKMechanicals'}{'Payor'} = \@ukMechPayorArray;



    # The preceeding backslash means 'return by reference'.
    # It's ok to return by value, too, but this is generally more efficient.
    #
    return \%returnHash;
}