#!/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::MechanicalCarryover;
use RPS::DB::Item::TrackLicense;
use RPS::DB::Item::Track;
use RPS::DB::Item::Master;
#use RPS::DB::Item::License;
use RPS::DB::Item::LicenseReserve;
use RPS::DB::Item::LicenseReserveLiquidation;
use RPS::DB::Item::StatRate;
use RPS::DB::Item::ProductTrack;
use RPS::DB::Item::Song;

use RPS::DB::Item::Publisher;
use RPS::DB::Item::Product;
use RPS::DB::Item::ControlledComposition;

use RPS::DB::Item::AlbumContract;
use RPS::DB::Item::MechanicalRun;
use RPS::DB::Item::MechanicalStatement;
use RPS::DB::Item::MechanicalStatementItem;
use RPS::DB::Item::MechanicalStatementItem;
use RPS::DB::Item::MechanicalStatementTrack;
use RPS::DB::Item::MechanicalStatementLicense;
use RPS::DB::Item::MechanicalStatementAdjustmentItem;
use RPS::DB::Item::SaleMechanicalStatementItemMap;

use RPS::License::TrackLicense;
use RPS::License::TrackLicenseList;

use RPS::Statement::MechanicalStatementDisplay;
use RPS::XMLCache;


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});


# Read lines from STDIN.
#
while (my $line = <STDIN>)
{
    my ($upc, $firstReserve, $secondReserve, $returns) = _parseLine($line);

#    print "$upc $firstReserve $secondReserve\n";

    
	# Get the physical product associated with this upc
	#
    my $products = RPS::DB::Item::Product->GetByUPC($upc);
#    print "upc: $upc  numProducts: " . $products->size() . "\n";

	while (my $product = $products->next())
	{
		next if (RPS::DB::Item::Product::kProductTypeDigital == $product->product_type_id);
		next if (RPS::DB::Item::Product::kProductTypeDigitalTrack == $product->product_type_id);
#		print Dumper($product) . "\n";

        my $productID = $product->product_id;

		# Now, find the track_license_id(s) associated with this product.
        # Basically, we need to get all the non bonus track ids, then get 
        # the licenses.
		#
        my @trackLiceneIDs;
        my $albumTracks = RPS::DB::Item::Track->GetByAlbumID($product->album_id);
        while (my $albumTrack = $albumTracks->next())
        {
            next if (RPS::DB::Item::ProductTrack->TrackIsBonusTrack($albumTrack->track_id));

            my $track = RPS::DB::Item::Track->Lookup(track_id => $albumTrack->track_id);
            my $trackLicenses = RPS::DB::Item::TrackLicense->GetLicensesByTrackID($albumTrack->track_id);
#            print "  " . $track->title . "   # of licenses: " . $trackLicenses->size . "\n";
            while (my $trackLicense = $trackLicenses->next())
            {
                # Don't create reserves for licenses with no issue date.
                #
                if (! $trackLicense->date_issued || '0000-00-00' eq $trackLicense->date_issued)
                {
                    next;
                }
                if (RPS::DB::Item::TrackLicense::kPublicDomain == $trackLicense->type())
                {
#                    print "    <PUBLIC DOMAIN>\n";
                    next;
                }

                # Populate the carryover table.
                #
                if ($returns < 0)
                {
                    my $saleDate = '2005-12-31';
                    my $releaseDate = $product->release_date;
                    $releaseDate = $saleDate unless $releaseDate;
                    my $issueStatRateID  = _getStatRateID($releaseDate);
                    my $saleStatRateID = _getStatRateID($saleDate);
                    my $co = RPS::DB::Item::MechanicalCarryover->Create(
                     track_license_id       => $trackLicense->track_license_id,
                     sale_stat_rate_id      => $saleStatRateID,
                     issue_stat_rate_id     => $issueStatRateID,
                     product_id             => $productID,
                     units                  => $returns,
                    );
                    $co->save();

                }


                my $publisher = RPS::DB::Item::Publisher->Lookup(publisher_id => $trackLicense->publisher_id);
                if (! $publisher)
                {
                    print "    --- invalid track license: publisher_id " . $trackLicense->publisher_id . " not in system\n";
                }
                else
                {
                    if (! $trackLicense->reserve_percentage)
                    {
#                    print "    publisher: " . $publisher->publisher_name . "    reserve_percentage: " . $trackLicense->reserve_percentage . "\n";
                    }
                    else
                    {
                        # Finally, a valid, normal track license.
                        #
                        # So, now I need to determine the stat rate ids.
                        # Sale will be easy.
                        # Issue... get that from the product if we can.
                        # Otherwise just use the 'sale date'
                        #
                        my $releaseDate = $product->release_date;
                        if ($firstReserve)
                        {
                            _createReserve($firstReserve, $product, $trackLicense, '2005-06-30', 2);
                        }

                        if ($secondReserve)
                        {
                            _createReserve($secondReserve, $product, $trackLicense, '2005-12-31', 1);
                        }
                    }
                }
            }
        }
	}
}


sub _createReserve
{
    my ($units, $product, $trackLicense, $saleDate, $nextPeriod) = @_;

    my $releaseDate = $product->release_date;
    $releaseDate = $saleDate unless $releaseDate;
    my $issueStatRateID  = _getStatRateID($releaseDate);
    my $saleStatRateID = _getStatRateID($saleDate);

    my $track = RPS::DB::Item::Track->Lookup(track_id => $trackLicense->track_id);
    my $master = RPS::DB::Item::Master->Lookup(master_id => $track->master_id);
    my $duration = $master->duration;

    # Calculate the effective rate
    #
    my ($effectiveRate, $baseRate, $appliedStatRateID) = _calculateEffectiveRate($issueStatRateID, $saleStatRateID, 
     $trackLicense->rate_basis, $trackLicense->rate_type, $trackLicense->penny_rate, $duration, $trackLicense->share);
                    
    my $newReserve = RPS::DB::Item::LicenseReserve->Create
    (
        track_license_id => $trackLicense->track_license_id,
        original_statement_item_id => 0,
        product_id => $product->product_id,
        sale_stat_rate_id => $saleStatRateID,
        issue_stat_rate_id => $issueStatRateID,
        initial_units => $units,
        remaining_units => $units,
        effective_rate => $effectiveRate,
        next_period => $nextPeriod,
    );
    $newReserve->save();
}


sub _parseLine
{
    my ($line) = @_;

    chomp $line;
	print "\n$line\n";
    my @bits = split("\t", $line);

    # strip the '-' from upc.
    #
    my @upcBits = split('-', $bits[3]);
    $bits[3] = join('', @upcBits);
    return ($bits[3],$bits[4], $bits[5], $bits[6]);
}


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

    my %opt;
    getopts('s:e:c:V:n', \%opt);

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

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


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 STDERR $string . "\n";
    }
}


# It's dumb to hit the database for these stat rate tables.
# Better to read the whole table into memory first, then 
# read from ram.

my $gStatRateTable;
my $gStatRateByDate;
sub _getStatRateTable
{
    if (! $gStatRateTable)
    {
        $gStatRateTable = {};

        my $statRates = RPS::DB::Item::StatRate->GetAll();
        while (my $statRate = $statRates->next())
        {
            $gStatRateTable->{$statRate->stat_rate_id} = $statRate;
        }
    }

    return $gStatRateTable;
}


# Generally we are going to be asking for the same stat rate for the same
# date over and over and over and over... so it makes sense to cache it.
#
sub _getStatRateID
{
    my $endDate = shift;

    if (! $gStatRateByDate->{$endDate})
    {
        my $table = _getStatRateTable();

        # get the stat rates, sorted by date
        #
        my @sortedRateIDs = sort { $table->{$b}->date_effective <=> $table->{$a}->date_effective} keys %$table;
        foreach my $testRateID (@sortedRateIDs)
        {
            if ($table->{$testRateID}->date_effective <= $endDate)
            {
                $gStatRateByDate->{$endDate} = $table->{$testRateID}->stat_rate_id;
                last;
            }
        }
    }
    return $gStatRateByDate->{$endDate};
}


sub _calculateEffectiveRate
{
    my ($issueStatRateID, $saleStatRateID, $rateBasis, $rateType, $pennyRate, $duration, $share) = @_;


    # Calculate the effective rate per unit to pay.
    # rate basis - either sale or release
    # rate term - full, partial, or penny
    #
    my $appliedStatRateID;
    my ($baseStatRate, $minuteRate);
    my $effectiveRate;
    if (RPS::DB::Item::TrackLicense::kRateBasisSale == $rateBasis)
    {
        ($baseStatRate, $minuteRate)= _getStatRate($saleStatRateID);
        $appliedStatRateID = $saleStatRateID;
    }
    elsif (RPS::DB::Item::TrackLicense::kRateBasisIssue == $rateBasis)
    {
        ($baseStatRate, $minuteRate)= _getStatRate($issueStatRateID);
        $appliedStatRateID = $issueStatRateID;
    }
    else
    {
        croak "!!! Unknown rate basis: " . $rateBasis;
    }
                    
    if (RPS::DB::Item::TrackLicense::kRateTypeFull == $rateType)
    {
        # Use the base stat rate for songs of 5 minutes or less.
        # Use the minute rate for longer songs.
        #
        $effectiveRate = $baseStatRate;
        if ($duration > 300)
        {
            my $minutes = ceil($duration / 60);
            my $minBasedRate = ($minutes * $minuteRate);

            $effectiveRate = ($minBasedRate > $effectiveRate ? $minBasedRate : $effectiveRate);
        }
    }
    elsif (RPS::DB::Item::TrackLicense::kRateTypeMinimum == $rateType)
    {
        $effectiveRate = $baseStatRate;
    }
    elsif (RPS::DB::Item::TrackLicense::kRateTypePenny == $rateType)
    {
        $effectiveRate = $pennyRate;
    }
    else
    {
        croak "!!! Unknown rate type: " . $rateType;
    }


    # Now that we have the effective rate, cut it according to the share percentage.
    #
    my $baseRate = $effectiveRate;
    $effectiveRate = $effectiveRate * ($share / 100);

    return ($effectiveRate, $baseRate, $appliedStatRateID);
}


sub _getStatRate
{
    my $statRateID = shift;
    
    my $table = _getStatRateTable();
    my $statRate = $table->{$statRateID};
    assert($statRate);

    return ($statRate->rate, $statRate->minute_rate);
}

sub _getControlledCompIDFromAlbumID
{
    my ($albumID) = @_;

    my $albumContract = RPS::DB::Item::AlbumContract::GetCComp($albumID);
    my $cc = RPS::DB::Item::ControlledComposition->GetByContractID($albumContract->artist_contract_id);
    return $cc->controlled_composition_id;
}