#---------------------------------------------------------------
# ____                   _ _         ____  _
#|  _ \ ___  _   _  __ _| | |_ _   _/ ___|| |__   __ _ _ __ ___
#| |_) / _ \| | | |/ _` | | __| | | \___ \| '_ \ / _` | '__/ _ \
#|  _ < (_) | |_| | (_| | | |_| |_| |___) | | | | (_| | | |  __/
#|_| \_\___/ \__, |\__,_|_|\__|\__, |____/|_| |_|\__,_|_|  \___|
#            |___/             |___/
#
# Copyright (C) 2012 RoyaltyShare, Inc.   All Rights Reserved
#---------------------------------------------------------------

package RPS::LabelRoyalty::Fast::Script::MapSales;

use strict;
use Data::Dumper;
use File::Path;
use POSIX ":sys_wait_h";

use lib '/app/tools/common/lib';
use lib '/app/tools/rps/lib';
use lib '/app/tools/raptor/lib';

use DB_File;

use Common::Util;
use Common::Log;
use Common::Parser;
use Common::WriteXML;
use Common::RSMath;

use RPS::LabelRoyalty::Fast::Static::Sales;
use RPS::LabelRoyalty::Fast::Static::Products;
use RPS::LabelRoyalty::Fast::Static::LabelTerms;
use RPS::LabelRoyalty::Fast::Static::Exceptions;

use RPS::LabelRoyalty::Fast::Mapped::Data;

use base 'Common::Script';

sub _options {
    {
        client_id => {
            short       => 'c',
            required    => 1,
            description => 'Limit to this client id',
            parameter   => 'i'
        },
        data_path => {
            short       => 'd',
            required    => 1,
            description => 'path to directory containing static data',
            parameter   => 's'
        },
        output_path => {
            short       => 'o',
            required    => 1,
            description => 'path to directory to write output files',
            parameter   => 's'
        },
        process_count => {
            short       => 'p',
            required    => 0,
            description => 'number of processes to use. defaults to 1',
            parameter   => 'i',
        },
        index_range => {
            short       => 'i',
            required    => 0,
            description => 'First,Last data indexes to process.  Ex: -s0,10000',
            parameter   => 's',
        },
    };
}

my $gChildCount;

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

    Log->warn("BEGIN");

    my ( $firstSale, $lastSale ) = $self->_parseFirstLastSaleIndex( $self->param('index_range') );

    my $dataPath = $self->param('data_path');

    my $outputDirectory = $self->param('output_path');

    # JPK - Should it be the responsibility of this process to create the directory if
    # it doesn't already exist?   It's a bit of a stretch, but then again it's convenient...
    #
    if ( !-d $outputDirectory ) {

        # !!! Might want to make this behavior optional...
        #
        mkpath($outputDirectory);
    }

    Log->info("Getting Sales");
    my $sales = RPS::LabelRoyalty::Fast::Static::Sales->GetSales( $dataPath, $firstSale, $lastSale );

    # The term data is stored as a hash of serialized array refs.
    # So we'll need to eval each record.
    # JPK - Not particularly abstract, true, but I don't want to waste time instantiating
    # some sort of wrapper object for each product.
    #
    Log->info("Getting LabelTerms");
    my $labelTermData = RPS::LabelRoyalty::Fast::Static::LabelTerms->GetLabelTermData($dataPath);

    Log->info("Getting Exceptions");
    my $exceptionData = RPS::LabelRoyalty::Fast::Static::Exceptions->GetExceptionData($dataPath);

    Log->info("Getting Products");
    my $productData = RPS::LabelRoyalty::Fast::Static::Products->GetProducts($dataPath);

    my $numSales = scalar(@$sales);
    Log->warn("Number of sales: $numSales");

    my $childCount = $self->param('process_count');
    $childCount = 1 unless $childCount;

    my $salesPerProcess = int( $numSales / $childCount );
    Log->warn("sales per process: $salesPerProcess");

    my $firstSale = 0;
    my $lastSale  = $firstSale + $salesPerProcess;

    my @childPIDs;
    $gChildCount = 0;

    for ( my $x = 0 ; $x < $childCount ; $x++ ) {
        my $pid = fork();
        if ( !$pid ) {

            # !!! There may be a bit of a race condition here.  I want to spawn all the children, then set up the parent's signal handlers.
            # !!! We might need to wait a bit before proceeding in the child to allow all that to get set up.
            #
            return $self->_doTheMapping( $firstSale, $lastSale, $outputDirectory, $sales, $productData, $labelTermData, $exceptionData );
        } else {
            $gChildCount++;

            $firstSale = $lastSale;

            # Include all remaining sales if the next child is the last one.
            #
            if ( $x == ( $childCount - 2 ) ) {
                $lastSale = $numSales;
            } else {
                $lastSale = $firstSale + $salesPerProcess;
            }
        }
    }

    $SIG{CHLD} = \&REAPER;
    $SIG{INT}  = 'IGNORE';

    while ($gChildCount) {
        sleep(2);
    }

    Log->warn("All children finished, exiting");
}

sub CTRL_C {
    Log->warn("caught a ctrl-c, exiting");
    exit(1);
}

sub REAPER {
    my $deadPid;
    while ( ( $deadPid = waitpid( -1, &WNOHANG ) ) > 0 ) {
        $gChildCount--;
    }
    $SIG{CHLD} = \&REAPER;
}

sub _doTheMapping {
    my ( $self, $firstSale, $lastSale, $outputDirectory, $sales, $productData, $labelTermData, $exceptionData ) = @_;

    # This is in the child process.
    # Install a signal handler to catch ctrl-c
    $SIG{INT} = \&CTRL_C;

    my $mappedDataFD = $self->_openMappedDataFileDescriptor($outputDirectory);

    # !!! JPK - If we ensure that the sales are sorted by product_id, then we can
    # !!! cache the last fetched product data (which would be more efficient).
    #
    my $lastProductID;
    my $lastProduct;

    Log->warn("mapping sales $firstSale up to $lastSale");
    for ( my $i = $firstSale ; $i < $lastSale ; $i++ ) {
        my $saleLine = $sales->[$i];

        Log->info( "\n\nSALE LINE:", $saleLine );

        my @saleArray = split( "\t", $saleLine );
        my $sale = \@saleArray;

        my $saleID    = $sale->[RPS::LabelRoyalty::Fast::Static::Sales::kSaleID];
        my $productID = $sale->[RPS::LabelRoyalty::Fast::Static::Sales::kProductID];

        # Map product id to all matching terms, then output the specifics.
        # !!! Any 'math' that needs to happen?   Exactly what will the MappedData contain?
        # !!! Probably delay any calculations until after the sort (i.e. wait until reduce step).

        my $product;
        if ( $productID != $lastProductID ) {
            my $productLine = $productData->{$productID};
            if ($productLine) {
                my @productArray = split( "\t", $productLine );
                $product = \@productArray;
            } else {
                $product = undef;
            }
            $lastProductID = $productID;
            $lastProduct   = $product;
        } else {
            $product = $lastProduct;
        }

        if ( !$product ) {
            Log->warn("Unable to find a product to match sale $saleID");
            next;
        }

        my $labelID = $product->[RPS::LabelRoyalty::Fast::Static::Products::kLabelID];

        my @labelTerms = $labelTermData->get_dup($labelID);
        foreach my $labelTermLine (@labelTerms) {
            my @labelTerm = split( ',', $labelTermLine );

            # JPK - I think at this point I can just spew out the stuff I'll need for mapping.
            # We'll need:
            # - sale_id
            # - distribution_fee - I believe this is going to be an aggregation factor. From the Term data.
            # - service_id
            # - distributor_id
            # - region_id
            # - start/end date  - These won't be used to aggregate, but we will probably want to keep min/max as we go.
            # - product_type
            # - format_type
            # - media_type
            # - track_id
            # - album_id  - So, note that product_id is NOT included...
            # - units
            # - price
            # - disc_no/track_no.   This could get... weird?   Perhaps we _should_ include product_id, and aggregate on it?
            #   ... going with the product_id for now
            #   But perhaps we should just aggregate on these two values after all.
            # - exception_id (when applicable)

            # JPK - I don't think I actually need the printf approach.

            # I don't have payee_id yet.  Seems like I ought to extract that along with the label term data.

            # Note that we are using the distributor ID (basically, the service ID from the file).
            # This may or may not be the same as the sale's service ID.
            my $serviceID   = $sale->[RPS::LabelRoyalty::Fast::Static::Sales::kDistributorID];
            my $countryCode = $sale->[RPS::LabelRoyalty::Fast::Static::Sales::kCountryCode];
            my $distFee     = $labelTerm[RPS::LabelRoyalty::Fast::Static::LabelTerms::kDistributionFee];
            my $groupTermID = $labelTerm[RPS::LabelRoyalty::Fast::Static::LabelTerms::kLabelContractTermID];

            # We may need to use the dist fee from one of the exceptions.
            # Loop through them for this group term and look for specific matches
            # on service AND country.
            # Next in priority would be an exception with a specific service and ALL for country.
            # Last would be ALL for service and a specific country.
            # If we don't find any of those, we'll leave the dist fee as-is.
            my @exceptions = $exceptionData->get_dup($groupTermID);

            # We need a tie breaker for when we match an "all services - specific country" exception and
            # also a "specific service - all countries" exception.  Gonna give priority to the one with
            # a specific service.
            my $matchedService   = 0;
            my $exceptionID      = 0;
            my $exceptionService = 0;
            my $exceptionCountry = 0;
            foreach my $exceptionLine (@exceptions) {
                my @exception            = split( ',', $exceptionLine );
                my $thisExceptionService = $exception[RPS::LabelRoyalty::Fast::Static::Exceptions::kServiceID];
                my $thisExceptionCountry = $exception[RPS::LabelRoyalty::Fast::Static::Exceptions::kCountryCode];
                my $thisExceptionID      = $exception[RPS::LabelRoyalty::Fast::Static::Exceptions::kExceptionID];
                my $thisExceptionDistFee = $exception[RPS::LabelRoyalty::Fast::Static::Exceptions::kDistributionFee];

                # Exact service and country matches.
                if ( $serviceID == $thisExceptionService && $countryCode eq $thisExceptionCountry ) {
                    $distFee          = $thisExceptionDistFee;
                    $exceptionID      = $thisExceptionID;
                    $exceptionService = $thisExceptionService;
                    $exceptionCountry = $thisExceptionCountry;
                    last;
                }

                if ( $serviceID == $thisExceptionService && $thisExceptionCountry eq '0' ) {
                    $distFee          = $thisExceptionDistFee;
                    $exceptionID      = $thisExceptionID;
                    $exceptionService = $thisExceptionService;
                    $matchedService   = 1;
                }

                if ( $countryCode eq $thisExceptionCountry && $thisExceptionService == 0 && $matchedService == 0 ) {
                    $distFee          = $thisExceptionDistFee;
                    $exceptionID      = $thisExceptionID;
                    $exceptionCountry = $thisExceptionCountry;
                }
            }

            print $mappedDataFD $labelTerm[RPS::LabelRoyalty::Fast::Static::LabelTerms::kLabelPayeeID] . "\t"
              . RPS::LabelRoyalty::Fast::Mapped::Data::kDataSale . "\t"
              . $labelID . "\t"
              . $labelTerm[RPS::LabelRoyalty::Fast::Static::LabelTerms::kLabelContractID] . "\t"
              . $product->[RPS::LabelRoyalty::Fast::Static::Products::kAlbumID] . "\t"
              . $product->[RPS::LabelRoyalty::Fast::Static::Products::kTrackID] . "\t"
              . $sale->[RPS::LabelRoyalty::Fast::Static::Sales::kServiceID] . "\t"
              . $sale->[RPS::LabelRoyalty::Fast::Static::Sales::kDistributorID] . "\t"
              . $sale->[RPS::LabelRoyalty::Fast::Static::Sales::kProductType] . "\t"
              . $sale->[RPS::LabelRoyalty::Fast::Static::Sales::kFormatType] . "\t"
              . (    $product->[RPS::LabelRoyalty::Fast::Static::Products::kMediaType]
                  || $sale->[RPS::LabelRoyalty::Fast::Static::Sales::kMediaType] )
              . "\t"
              . $sale->[RPS::LabelRoyalty::Fast::Static::Sales::kCountryCode] . "\t"
              . $sale->[RPS::LabelRoyalty::Fast::Static::Sales::kConversionRate] . "\t"
              . $distFee . "\t"
              . $productID . "\t"
              . $sale->[RPS::LabelRoyalty::Fast::Static::Sales::kPrice] . "\t"
              . $sale->[RPS::LabelRoyalty::Fast::Static::Sales::kFree] . "\t"
              . $sale->[RPS::LabelRoyalty::Fast::Static::Sales::kUnits] . "\t"
              . $sale->[RPS::LabelRoyalty::Fast::Static::Sales::kDateBegin] . "\t"
              . $sale->[RPS::LabelRoyalty::Fast::Static::Sales::kDateEnd] . "\t"
              . $sale->[RPS::LabelRoyalty::Fast::Static::Sales::kCurrencyCode] . "\t"
              . $sale->[RPS::LabelRoyalty::Fast::Static::Sales::kSaleID] . "\t"
              . lc( substr( $product->[RPS::LabelRoyalty::Fast::Static::Products::kAlbumName], 0, 20 ) ) . "\t"
              . $product->[RPS::LabelRoyalty::Fast::Static::Products::kDiscNo] . "\t"
              . $product->[RPS::LabelRoyalty::Fast::Static::Products::kTrackNo] . "\t" . " " . "\t" . " " . "\t" . " " . "\t"
              . $exceptionID . "\t"
              . $exceptionService . "\t"
              . $exceptionCountry . "\n";
        }
    }
    Log->warn("END");
}

sub _openMappedDataFileDescriptor {
    my ( $self, $outputDirectory ) = @_;

    open OUTPUT, "> $outputDirectory/" . RPS::LabelRoyalty::Fast::Mapped::Data->FileName() . "_$$.unsorted" or die "ERROR: $!";

    binmode( *OUTPUT, ':utf8' );

    return *OUTPUT;
}

sub _openMissedSalesFileDescriptor {
    my ( $self, $outputDirectory ) = @_;

    open MISSED, "> $outputDirectory/" . RPS::LabelRoyalty::Fast::Mapped::MissedSales->FileName() . "_$$.unsorted" or die "ERROR: $!";

    return *MISSED;
}

sub _parseFirstLastSaleIndex {
    my ( $self, $rangeString ) = @_;
    return unless $rangeString;

    my @bits = split( ',', $rangeString );
    if ( 2 != scalar @bits || ( $bits[1] <= $bits[0] ) ) {
        $self->usage('ERROR: sale_range is invalid.');
    }
    return ( $bits[0], $bits[1] );
}

1;