package RPS::Import::Thumbplay::v1;

use strict;

use lib '/app/tools/rps/lib';
use RPS::DB::Item::Client;

use lib '/app/tools/common/lib';
use Common::Country;
use Common::Consts;
use Common::Assert;
use Common::Log;
use Data::Dumper;

use lib '/app/tools/data_classes/lib';

use lib '/app/tools/rps/lib';
use RPS::Import::SaleRec;
use RPS::DB::Item::MediaType;
use RPS::File::Sale;

use lib '/app/tools/rps/lib';
use RPS::Import::Importer;
use base 'RPS::Import::Importer';

sub _fieldMap {
    {

    #-----------------------------------------------------------------
    # Note: the sales file has a blank first column, so in terms of
    # setting up the _fieldMap, we list the column numbers minus one
    # (e.g., the column numbers are zeroed at column B).
    #
    # The actual column information is added as a comment to make
    # it easier to identify the source columns. -ES
    #-----------------------------------------------------------------
        # Summary-related columns
        salesType             => 0, # B - Sales Type
        salesProduct          => 1, # C - Product
        salesUnits            => 2, # D - Units
        salesRevenue          => 9, # K - Sales Revenue
        salesStreamingRevenue => 8, # J (Merged column)

        # Detail-related columns
        dateBegin     => 8,   # J - Period Start Date
        dateEnd       => 9,   # K - Period End Date
        productType   => 5,   # G - Product
        formatType    => 1,   # C - Sales Channel
        artistName    => 6,   # H - Artist
        isrc          => 2,   # D - External Meta Data
        upc           => 4,   # E - UPC
        trackName     => 7,   # I - Title
        units         => 10,  # K - Units
    }
}

#--------------------------------------------------------------------
# productSummaryMap - maps product types found in the summary section
# to the product type in the detail section.
# Note: the following products are assumed to be tracks.
#--------------------------------------------------------------------
my %productSummaryMap = (
   'full track (tier ii)'  => 'ms2 download',
   'streaming'             => 'ms2 stream',
);

#---------------------------------------------------------------
# salesChannelMap - Maps the sales channel to an RPS format type
#---------------------------------------------------------------
my %salesChannelMap = (
   'ms2 download' => RPS::File::Sale::FORMAT_DOWNLOAD,
   'ms2 stream'   => RPS::File::Sale::FORMAT_STREAM,
);

#------------------------------------------------------------------------
# revenueMap - Maps the product type in the summary section to a sales
# channel in the detail section.
#
# For example for the product 'full track (tier ii)' in the summary
# section, we'd map the product type to 'ms2 download' (via the
# productSummaryMap, above), and store the associated revenue as:
#
# revenueMap{ 'ms2 download' }{ 'track' } => {
#    revenue => $revenue,
#    units => $units,
#    unit_price => $revenue/$units
# }
#------------------------------------------------------------------------
my %revenueMap;

sub _importLines
{
    my $self        = shift;
    my %args        = @_;
    my $fileObj     = $args{file};
    my $version     = $args{file}->VersionNum();
    my $fileName    = $args{file}->OrigFileName();
    my $serviceID   = $args{file}->ServiceID;
    my $sheet_count = 0;

    assert(defined $args{sheets});
    assert(defined $version);

    my $offsets     = $self->_fieldMap;
    my $sheet_names = $args{sheet_names};
    my $sheets      = $args{sheets};
    my $linenum     = 1;


    for (my $sheetIndex = 0; $sheetIndex < scalar @{$args{sheets}}; $sheetIndex++)
    {
        my $sheet = $sheets->[$sheetIndex];

        #--------------------------------------------------------------------
        # All data is assumed to be on the first sheet.
        #
        # We'll look for the summary section first.  Once it is found, we'll
        # set 'foundSummaryHeader' and process the summary data until we
        # encounter the detail section.  At that point, we'll set the
        # 'foundDetailHeader' flag and the subsequent sales data will be read
        # in.  We'll set the price information for each sale based on the
        # unit price information derived from the summary section.
        #--------------------------------------------------------------------
        next if( $sheetIndex > 0 );

        my $foundSummaryHeader = 0;
        my $foundDetailHeader  = 0;

        for( my $lineIndex = 0; $lineIndex < scalar @$sheet; $lineIndex++ )
        {
            $linenum = $lineIndex + 1;
            my $line = $sheet->[$lineIndex];

            if (! $foundSummaryHeader)
            {
                if ('Sales Type' eq $line->[$offsets->{format_type}])
                {
                    $foundSummaryHeader = 1;
                }
                next;
            }

            if ( $foundSummaryHeader )
            {

                if ( !$foundDetailHeader )
                {
                    #-------------------------
                    # Process the summary data
                    #-------------------------

                    #==================================================================
                    # NOTE: The revenue column for Subscription/(Streaming) is slightly
                    # different than for Subscription/(anything_but_streaming) or
                    # A La Carte/(anything).  This is due to the merged cell for the
                    # 'Proportionate Share' data with Subscription/Streaming.
                    #==================================================================
                    my $salesType             = $line->[$offsets->{salesType}];
                    my $salesProduct          = $line->[$offsets->{salesProduct}];
                    my $salesUnits            = $line->[$offsets->{salesUnits}];

                    my $salesRevenue          = $line->[$offsets->{salesRevenue}];
                    my $salesStreamingRevenue = $line->[$offsets->{salesStreamingRevenue}];

                    if ('Row number' eq $line->[$offsets->{format_type}])
                    {
                        $foundDetailHeader = 1;
                        next;  # keep looking for detail section...
                    }
                    elsif ( $salesType && ($salesType ne 'Sales Type') && $salesProduct && $salesUnits )
                    {
                        #---------------------------------------------------------
                        # Store the units/revenue data for the given sales_type &
                        # product combination. 
                        #
                        # Per the template, the initial version of the importer
                        # will only accept 'Full Track (Tier II)' and 'Streaming'
                        # as valid sales types, and those are only valid for track
                        # sales.
                        #---------------------------------------------------------
                        my $mappedProduct = $productSummaryMap{ lc $salesProduct };

                        if ( $mappedProduct )
                        {
                            my $_revenue   = $salesRevenue;
                            $_revenue      = $salesStreamingRevenue if ( $salesProduct =~ m/^streaming$/i );
                            my $_unitPrice = $_revenue / $salesUnits;

                            $revenueMap{ $mappedProduct }{ track } = {
                                units      => $salesUnits,
                                revenue    => $_revenue,
                                unit_price => $_unitPrice
                            };
                        }
                        else
                        {
                            print STDERR "Unknown sales product '$salesProduct' detected\n"; # XXX
                            $self->errstr("Line $linenum: unknown sales product");
                            return undef;
                        }
                    }

                }
                else
                {
                    #------------------------
                    # Process the detail data
                    #------------------------

                    my( $dateBegin, $dateEnd) = $self->_getDates(
                        date_begin => $line->[$offsets->{dateBegin}],
                        date_end   => $line->[$offsets->{dateEnd}]
                        );

                    my $artist       = $line->[$offsets->{artistName}];
                    my $units        = $line->[$offsets->{units}];
                    my $formatType   = $line->[$offsets->{formatType}];
                    my $_productType = $line->[$offsets->{productType}];

                    my $productFormat = $salesChannelMap{ lc $formatType };
                    if( !$productFormat )
                    {
                        print STDERR "ERROR: line $linenum: Unable to map sales channel '$formatType'\n";
                        $self->errstr("Line $linenum: unknown sales channel");
                        return undef;
                    }

                    my $unitPrice;
                    my $upc;
                    my $isrc;
                    my $albumTitle;
                    my $trackTitle;
                    my $productType;
                    my $_title = $line->[$offsets->{trackName}];

                    if ( lc $_productType eq 'track' )
                    {
                       $trackTitle = $_title;
                       $isrc = $line->[$offsets->{isrc}];
                       $productType = RPS::File::Sale::TYPE_TRACK;

                       if ( exists $revenueMap{$formatType}{track} )
                       {
                           $unitPrice = $revenueMap{$formatType}{track}->{unit_price};
                       }
                       else
                       {
                           print STDERR "ERROR: line $linenum: Unable to determine unit price for track format($formatType)\n";
                           $self->errstr("Line $linenum: unable to determine unit price");
                           return undef;
                       }
                    }
                    elsif( lc $_productType eq 'album' )
                    {
                       $albumTitle = $_title;
                       $upc = $line->[$offsets->{upc}];
                       $productType = RPS::File::Sale::TYPE_ALBUM;
                       if ( exists $revenueMap{$formatType}{album} )
                       {
                           $unitPrice = $revenueMap{$formatType}{album}->{unit_price};
                       }
                       else
                       {
                           print STDERR "ERROR: line $linenum: Unable to determine net price for album format($formatType)\n";
                           $self->errstr("Line $linenum: unable to determine unit price");
                           return undef;
                       }
                    }
                    else
                    {
                        print STDERR "ERROR: line $linenum: Unknown product type '$_productType'\n";
                        $self->errstr("Line $linenum: unknown product type");
                        return undef;
                    }

                    my $mediaType = RPS::DB::Item::MediaType::kMediaTypeAudio;


                    if ( ($units || $artist) && $unitPrice && ('' ne $albumTitle || '' ne $trackTitle) )
                    {

                        my $sale = RPS::Import::SaleRec->new();
                        $sale->mediaType($mediaType);
                        $sale->productType($productType);
                        $sale->formatType($productFormat);
                        $sale->dateBegin($dateBegin);
                        $sale->dateEnd($dateEnd);
                        $sale->trackName($trackTitle) if ( $trackTitle );
                        $sale->albumName($albumTitle) if ( $albumTitle );
                        $sale->artistName($artist);
                        $sale->upc($upc)   if ( $upc );
                        $sale->isrc($isrc) if ( $isrc );
                        $sale->units($units);
                        $sale->price($unitPrice);
                        $sale->countryCode('US');
                        $sale->currencyCode('USD');
                        $sale->lineNum($linenum);

                        $self->_insertSale(sale => $sale);
                    }
                }
            }


        }
    }

    return $linenum;
}

###
1;# Play nicely.
###