#------------------------------------------------------------
# Copyright (C) 2009 RoyaltyShare, Inc.   All Rights Reserved
#------------------------------------------------------------

package RPS::Mechanical::Process;
use strict;
use POSIX qw(ceil);

use Data::Dumper;

use lib '/app/tools/rps/lib';
use lib '/app/tools/common/lib';
use Common::Process;
use Common::Assert;
use Common::Log;
use RPS::RoyaltyRun::Process;
use RPS::License::RateType;
use RPS::License::RateBasis;
use RPS::DB::Item::RegionCountryMap;
use RPS::Mechanical::Process::Exception;

use base 'RPS::RoyaltyRun::Process';

#     Adding caching accessors here, so that we have the same code
#     available for both the CreateStatement and RunController classes.
#
#     Note that these methods are still all abstract  -  Derrived classes
#     will still need to override '_getStatRates' to return the DB::ItemCollection
#     that represents their particular stat rate table.
#

sub _getStatRateTable {
    my ($self) = @_;

    if ( !$self->{_statRateTable} ) {
        my $statRates = $self->_getStatRates();
        while ( my $statRate = $statRates->next() ) {
            $self->{_statRateTable}{ $statRate->stat_rate_id } = $statRate;
        }
    }

    return $self->{_statRateTable};
}

# 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 ( $self, $endDate ) = @_;

    if ( !$self->{_statRateByDate} ) {
        my $table = $self->_getStatRateTable();

        # get the stat rates, sorted by date
        #
        my @sortedRateIDs = sort { $table->{$b}->date_effective cmp $table->{$a}->date_effective } keys %$table;

        my @sortedStatRates;
        my $ringtoneStatRateType = $self->_ringtoneStatRateType();

        foreach my $sortedID (@sortedRateIDs) {
            if ( $table->{$sortedID}->stat_rate_type_id != $ringtoneStatRateType ) {
                push @sortedStatRates, $table->{$sortedID};
            }
        }
        $self->{_statRateByDate} = \@sortedStatRates;
    }

    my $id;
    my $sortedStatRates = $self->{_statRateByDate};
    foreach my $testRate (@$sortedStatRates) {
        if ( $testRate->date_effective le $endDate ) {
            $id = $testRate->stat_rate_id;
            last;
        }
    }

    return $id;
}

sub _getRingStatRateID {
    my ( $self, $endDate ) = @_;

    if ( !$self->{_ringStatRateByDate} ) {
        my $table = $self->_getStatRateTable();

        # get the stat rates, sorted by date
        #
        my @sortedRateIDs = sort { $table->{$b}->date_effective cmp $table->{$a}->date_effective } keys %$table;

        my @sortedStatRates;
        my $ringtoneStatRateType = $self->_ringtoneStatRateType();

        foreach my $sortedID (@sortedRateIDs) {
            if ( $table->{$sortedID}->stat_rate_type_id == $ringtoneStatRateType ) {
                push @sortedStatRates, $table->{$sortedID};
            }
        }
        $self->{_ringStatRateByDate} = \@sortedStatRates;

        Common::Log::Print( "_getRingStatRateID - Build this sorted table: " . Dumper( $self->{_ringStatRateByDate} ) );
    }

    my $id;
    my $sortedStatRates = $self->{_ringStatRateByDate};
    foreach my $testRate (@$sortedStatRates) {
        if ( $testRate->date_effective le $endDate ) {
            $id = $testRate->stat_rate_id;
            last;
        }
    }

    #Common::Log::Print("_getRingStatRateID - returned id $id for date $endDate");

    return $id;
}

sub _getStatRate {
    my ( $self, $statRateID ) = @_;

    my $table    = $self->_getStatRateTable();
    my $statRate = $table->{$statRateID};
    assert( $statRate, "no stat rate found with id $statRateID" );

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

sub _ringtoneStatRateType {
    my ($self) = @_;
    assert( 0, 'override this' );
}

sub _prevalidateRun {
    my $self = shift;

    $self->_report("Begin Mechanical Pre Run Validation.");

    return $self->_prevalidateLicenseShare()
      && $self->SUPER::_prevalidateRun();
}

sub _prevalidateLicenseShare {
    my $self = shift;

    my $collection = $self->_getLicenseShareErrors();

    if ( defined($collection) ) {
        if ( $collection->hasNext() ) {
            while ( my $row = $collection->next() ) {
                $self->_report( "Track license share == 0: " . Dumper $row );
            }

            return;
        } else {
            $self->_report("License share test: Passed");
        }
    } else {
        $self->_report("*****  _getLicenseShareErrors not overloaded. Not validating license share! *****");
    }

    return 1;
}

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

    $self->_report(
"_calculateEffectiveRate : issueStatRateID = $issueStatRateID, saleStatRateID = $saleStatRateID, rateBasis = $rateBasis, pennyRate = $pennyRate, percentOfRate = $percentOfRate, duration = $duration, share = $share",
        3
    );

    # 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::License::RateType::kPenny == $rateType ) {
        $effectiveRate     = $pennyRate;
        $appliedStatRateID = $saleStatRateID;
        $self->_report( "penny rate : minimum, pennyRate = $pennyRate", 3 );
    } else {
        if ( RPS::License::RateBasis::kSale == $rateBasis ) {
            ( $baseStatRate, $minuteRate ) = $self->_getStatRate($saleStatRateID);
            $self->_report( "rate basis = sale, baseRate = $baseStatRate, minute rate = $minuteRate", 3 );
            $appliedStatRateID = $saleStatRateID;
        }

        # !!! For this to convert to 'lock date', I'm going to _NEED_ to know the lock date. duh!
        elsif ( RPS::License::RateBasis::kLock == $rateBasis ) {
            my $lockStatRateID;

            if ( $trackLicense->type == RPS::DB::Item::TrackLicense::kRingtone ) {
                $lockStatRateID = $self->_getRingStatRateID($lockDate);
            } else {
                $lockStatRateID = $self->_getStatRateID($lockDate);
            }

            ( $baseStatRate, $minuteRate ) = $self->_getStatRate($lockStatRateID);
            $self->_report( "rate basis = lock, baseRate = $baseStatRate, minute rate = $minuteRate", 3 );
            $appliedStatRateID = $lockStatRateID;
        } else {
            die RPS::Mechanical::Process::Exception->new( "Unknown rate basis: " . $rateBasis );
        }

        if ( RPS::License::RateType::kFull == $rateType ) {

            # Use the base stat rate for songs of 5 minutes or less.
            # Use the minute rate for longer songs.
            #

            # JPK - If we don't actually _know_ the duration of this track, we'll end up using the
            # min_stat rate.   Now, that seems wrong to me.  But, the unfortunate reality here is that
            # many songs in our data won't have timings.   And we will encounter this code in that
            # situation fairly frequently - For example, when performing the 'album rate' calculation
            # for a controlled comp license, if one of the tracks on that album is full stat without
            # timings, we have to do _something_.   Although I'd prefer to actually blow up and get
            # that data fixed, we've decided to push ahead with the min stat rate.  If in the future
            # they update that track's timing data (because they noticed that they've been accruing
            # on that track because we've been ignoring that 'bad' track), an adjustment would ensue.
            #
            $effectiveRate = $baseStatRate;
            if ( $duration > 300 ) {
                my $minutes      = ceil( $duration / 60 );
                my $minBasedRate = ( $minutes * $minuteRate );

                $self->_report( "full rate. minutes = $minutes, duration = $duration, minute based rate = $minBasedRate", 3 );
                $effectiveRate = ( $minBasedRate > $effectiveRate ? $minBasedRate : $effectiveRate );
            }
        } elsif ( RPS::License::RateType::kMinimum == $rateType ) {
            $effectiveRate = $baseStatRate;
            $self->_report( "min rate : minimum, baseStatRate = $baseStatRate", 3 );
        } else {
            die RPS::Mechanical::Process::Exception->new( "Unknown rate type: " . $rateType );
        }
    }

    my $baseRate = $effectiveRate;

    # 0 %  is not an option...
    #
    if ( $percentOfRate > 0 && RPS::License::RateType::kPenny != $rateType ) {
        $effectiveRate = $effectiveRate * ( $percentOfRate / 100 );
    }
    assert( $effectiveRate > 0 );

    # Now that we have the effective rate, cut it according to the share percentage.
    #
    if ( RPS::License::RateType::kPenny != $rateType ) {
        $effectiveRate = $effectiveRate * ( $share / 100 );
    }

    # For my final trick - round these down to 4 places right of the decimal point.
    #
    $effectiveRate = Common::RSMath::round( $effectiveRate, 4 );
    $baseRate      = Common::RSMath::round( $baseRate,      4 );

    $self->_report( "returning effective rate = $effectiveRate", 3 );
    return ( $effectiveRate, $baseRate, $appliedStatRateID );
}

sub _productIsDigital {
    my ( $self, $product ) = @_;
    assert( 'RPS::DB::Item::Product' eq ref($product) );
    my $typeID = $product->product_type_id;

    if (   RPS::DB::Item::Product::kProductTypeDigital == $typeID
        || RPS::DB::Item::Product::kProductTypeDigitalTrack == $typeID ) {
        return 1;
    }

    return 0;
}

sub _findRegionsForCountryCode {
    my ( $self, $countryCode ) = @_;

    # Probably worth caching this info.
    #
    if ( !$self->{_regionCountryMap} ) {
        my $allMappings = RPS::DB::Item::RegionCountryMap->GetAll();
        while ( my $map = $allMappings->next() ) {
            push @{ $self->{_regionCountryMap}{ $map->country_code } }, $map->region_id;
        }
    }

    return $self->{_regionCountryMap}{$countryCode};
}

sub _getYear {
    my ( $self, $sale ) = @_;
    my ( $year, $month, $day ) = split( '-', $sale->date_end );
    return $year;
}

1;