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

use Common::RSApp;
use Common::Client;
use Common::Log;
use Raptor::DB::Item::Sale;
use Raptor::DB::Item::File;
use RPS::Sale::Match;
use RPS::File::Sale;



my $clientID = $ARGV[0];
my $app = Common::RSApp->new(clientID => $clientID);
my $client = Common::Client::Current();

Common::Log::Print("running for client $clientID: " . $client->ClientName());


# Step one:  Find bad sales.
my $badSales = Raptor::DB::Item::Sale->GetAll("SELECT * FROM sale WHERE product_id > 0 AND product_id NOT IN (select product_id from product)");
my $badCount = $badSales->size();
my $count = 0;

my $matchCount = 0;
my $matcher = RPS::Sale::Match->new(client_id => $clientID);

my %badFileSale;

my $unitSum;
my $revenueSum;

while (my $sale = $badSales->next())
{
	$count++;
	if (0 == $count % 1000)
	{
		Common::Log::Print("$count / $badCount");
	}


	# Let's try and re-match this sale.
	#
	my $file = Raptor::DB::Item::File->Lookup(file_id => $sale->file_id());
	my $fileServiceID = $file->service_id();
	my $matchData = {
		service_id 			=> $fileServiceID,
		media_type 			=> $sale->media_type(),
		album				=> $sale->album_name(),
		artist				=> $sale->artist_name(),
		client_product_id	=> $sale->client_product_id(),
		format				=> $sale->format_type(),
		isrc				=> $sale->isrc(),
		product_type		=> $sale->product_type(),
		service_product_id	=> $sale->service_product_id(),
		track_num			=> $sale->track_num,
		track				=> $sale->track_name,
		upc					=> $sale->upc,
		outlet				=> $sale->outlet,
	};

	my $result = $matcher->FindBestMatch(data => $matchData, min_match_level => 90, skip_rec => 1);
	if (File::Sale::STATUS_MATCH == $result->ImportStatus)
	{
		my $matchingProductID = $result->ProductIDs->[0];
		Common::Log::Print(" sale " . $sale->sale_id . " MATCHES product $matchingProductID");
		$matchCount++;

		my $units = $sale->units();
		if ($sale->sales() > 0 || $sale->returns() > 0)
		{
			$units = $sale->sales() - $sale->returns();
		}
		my $revenue = $units * $sale->price();
		$unitSum += $units;
		$revenueSum += $revenue;


		# Ok... Let's go ahead and re-assign these product ids.o
		#
		$sale->product_id($matchingProductID);
		$sale->save();
	}
	elsif (File::Sale::STATUS_MAPPED == $result->ImportStatus
	 || File::Sale::STATUS_AUTO_MAPPED == $result->ImportStatus)
	{
		Common::Log::Print("MAPPED SALE: ", $sale, " MATCH: ", $result);

		my $matchingProductID = $result->ProductIDs->[0];
		$sale->product_id($matchingProductID);
        $sale->map_id($result->MapID);
		$sale->import_status($result->ImportStatus());
		$sale->save();
	}
	else
	{
		Common::Log::Print(" sale " . $sale->sale_id . " NO MATCH", $sale, $result);
		Common::Log::Print("sale " . $sale->sale_id . ", file " . $sale->file_id . ", line " . $sale->line_num);
		
		push @{$badFileSale{$sale->file_id}}, $sale->sale_id;
	}
}


# Let's look again at the files we might need to 'split' - Let's see if we already have a split file in period 0.
#

foreach my $badFileID (keys %badFileSale)
{
	my $badSales = $badFileSale{$badFileID};

	my $file = Raptor::DB::Item::File->Lookup(file_id => $badFileID);
	my $childFile;

	my $parentFileID = $badFileID;
	while (my $f = Raptor::DB::Item::File->Lookup(parent_file_id => $parentFileID))
	{
		$childFile = $f;
		$parentFileID = $childFile->file_id;
	}
	
	Common::Log::Print("FILE: $badFileID, period " . $file->period_id() . "  Sale count: " . scalar @$badSales);
	if ($childFile)
	{
		Common::Log::Print("  LEAF CHILD: " . $childFile->file_id() . ", period " . $childFile->period_id());
        $file = $childFile;
	}

    # !!! One thing that needs to be considered:  If a file only has one sale, or if all the sales in a file
    # !!! (that is in a closed period) are 'bad', then we don't need to split the file: We need to re-open it.
    #
    # So let's get a count of the number of sales first.
    #
    my $allOriginalSales = Raptor::DB::Item::Sale->GetAll("SELECT * FROM sale WHERE file_id = $badFileID");
    my $originalSaleCount = $allOriginalSales->size();
    my $badSaleCount = scalar(@$badSales);

    Common::Log::Print("original sale count: $originalSaleCount,  bad sale count: $badSaleCount");



    # BEFORE we split any files, we need to re-set these 'bad' sales to appear
    # unmatched.   Otherwise the Split code will not work correctly.
    #
    foreach my $badSaleID (@$badSales)
    {
        my $sale = Raptor::DB::Item::Sale->Lookup(sale_id => $badSaleID);
        $sale->product_id(undef);
        $sale->map_id(undef);
        $sale->import_status(File::Sale::STATUS_NOMATCH);
        $sale->save();

        Common::Log::Print("  re-set sale $badSaleID");
    }


    my $oldFileID = $file->file_id();
    my $newFileID;
    if ($badSaleCount == $originalSaleCount)
    {
        # All sales are bad.
        # We need to possibly re-open the file, but the file_id will not change.
        #
        if (0 != $file->period_id())
        {
            Common::Log::Print("  re-opening file " . $file->file_id());
            $file->period_id(0);
            $file->file_status(4);
            $file->save();

            $newFileID = $file->file_id();
        }
    }
    elsif (0 == $file->period_id)
    {
        # Have a split file already, just move the sales.
        #
        Common::Log::Print("  using existing child file " . $file->file_id());
        $newFileID = $file->file_id();
    }
    else
    {
        # Need to split
        #
        Common::Log::Print("  Need to split file");
        my $oldFile = RPS::File::File->new(file_id => $file->file_id());
        my $newFile = $oldFile->Split();
        $newFileID = $newFile->FileID();

        # The Split method clones the original file, which is _usually_ in period 0, and Open.
        # Meaning, it doesn't bother to actually _set_ these fields. Since we are splitting a closed
        # file in a different period, we need to set these fields explicitly.
        #
        $newFile->PeriodID(0);
        $newFile->FileStatus(4);
        $newFile->Save();
        Common::Log::Print("  new file id: $newFileID");
    }

    # This may be redundant if the file was actually split, but should be harmless.
    #
    foreach my $badSaleID (@$badSales)
    {
        my $sale = Raptor::DB::Item::Sale->Lookup(sale_id => $badSaleID);

        # This may be redundant with files that we just split, but it won't hurt.
        #
        $sale->file_id($newFileID);
        $sale->save();

        Common::Log::Print("  updated sale $badSaleID");
    }


    # Re-calculate summary data.
    #
    my $oldFile = RPS::File::File->new(file_id => $oldFileID);
    $oldFile->UpdateSummary(skip_conversion => 1);
    $oldFile->RecalculateRemainingExceptions();

    if ($oldFileID != $newFileID)
    {
        my $newFile = RPS::File::File->new(file_id => $newFileID);
        $newFile->UpdateSummary(skip_conversion => 1);
        $newFile->RecalculateRemainingExceptions();
    }
}


Common::Log::Print("UNIT SUM RECOVERED: $unitSum   REVENUE RECOVERED: $revenueSum");