package RPS::Import::ADAPhysical::v6;

use strict;


use lib '/app/tools/common/lib';
use Common::Util qw(normalize_date normalize_upc);
use Common::Country;
use Date::Calc qw(Days_in_Month);
use Data::Dumper;

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

use lib '/app/tools/rps/lib';
use RPS::File::Sale;
use RPS::File::Sale;
use RPS::Import::ServiceMap;

use base 'RPS::Import::Importer';

use constant kDataNotFound => -1;

sub _fieldMap {
    {
        'statement summary' => {
            date_row        => 3,
            date_col        => 1,
        },

        'physical sales' => {
            label           => 0,  # A
            configuration   => 7,  # H
            artistName      => 3,  # D
            catalogID       => 2,  # C
            upc             => 8,  # I
            albumName       => 4,  # E
            country         => 12, # M
            wholesalePrice  => 13, # N
            distFee         => 22, # W            
            returnFee       => 23, # X            

            sales           => 14, # O
            returns         => 15, # P
            netUnits        => 16, # Q
            totalRevenue    => 24, # Y            
        },            
    }
}


my %productTypeMap = (
   '1cd'              => RPS::File::Sale::TYPE_CD,
   '2cd'              => RPS::File::Sale::TYPE_CD,
   'single (10")'     => RPS::File::Sale::TYPE_LP5,
   '12" vinyl single' => RPS::File::Sale::TYPE_LP5,
   '7"'               => RPS::File::Sale::TYPE_LP5,
   '12" vinyl'        => RPS::File::Sale::TYPE_LP,
   'cd'               => RPS::File::Sale::TYPE_CD,
   '1cd + 1dvd'       => RPS::File::Sale::TYPE_DVD_CD_SET,
   '12" vinyl x 2'    => RPS::File::Sale::TYPE_LP,
   'lp'               => RPS::File::Sale::TYPE_LP, # FB 10795
   '1lp'              => RPS::File::Sale::TYPE_LP, # FB 10795
);

#
# Private methods
#

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

    my $offsets = $self->_fieldMap;

    my $sheet_count = 0;
    my ($linenum,$serviceID);

    return undef unless (defined $args{sheets} && defined $version);

    my $sheet_names = $args{sheet_names};


    my $dateBegin;
    my $dateEnd;

    my $dateField;

    #----------------------------------------------------
    # Extract the date information from the summary sheet
    #----------------------------------------------------

    # Assume that the first sheet is the summary sheet
    #
    my $sheet = @{ $args{sheets} }[0];

    if( $sheet_count == 0 )
    {
        # The row/column offsets can be skewed if there are blank columns (left)
        # and/or rows (top) in the sales file.  Scan the first 10 rows to see
        # if we can find the date information.
        #
        my $dateFound;
        my $row=0;
        while( !$dateFound && $row < 10 )
        {
            my $data = $offsets->{'statement summary'};

            # Get the date information from the top of each sheet
            #
            my $dateRow = $row;
            my $dateCol = $data->{date_col};

            $dateField = $sheet->[$dateRow][$dateCol];
            if( !$dateField )
            {
                # If sheet has a blank leftmost column, then the column offset will be off by 1
                #
                $dateField = $sheet->[$dateRow][$dateCol-1];
            }

            # Period: DD/MM/YYYY - DD/MM/YYYY
            #         $1 $2  $3    $4 $5  $6
            if ( $dateField =~ m/Period: (\d{1,2})\/(\d{1,2})\/(\d{4}) . (\d{1,2})\/(\d{1,2})\/(\d{4})/ )
            {
                # FB4918: Use the end date to determine the sales period
                #
                my($eDay, $eMonth, $eYear) = ($4, $5, $6);
                $dateBegin = join("-", $eYear, sprintf("%02d",$eMonth), "01"               );
                $dateEnd   = join("-", $eYear, sprintf("%02d",$eMonth), Days_in_Month( $eYear, $eMonth ) );

                ($dateBegin, $dateEnd) = $self->_getDates( date_begin => $dateBegin, date_end => $dateEnd );

                $dateFound=1;
            }

            $row++;
        }
    }

    #-------------------------
    # Process the detail sheet
    #-------------------------
    $sheet_count = 0;
    foreach my $sheet(@{ $args{sheets} })
    {

        my $sheetName = $sheet_names->[$sheet_count];

        my $sheetIndex = lc $sheetName;

        if ($sheetIndex ne 'physical sales')
        {
            $sheet_count++;
            next;
        }

        my $data = $offsets->{$sheetIndex};

        $linenum = 1;
        foreach my $line(@{ $sheet })
        {

            my $sn = $sheet_count + 1;
            my $lineInfo = "Sheet $sn, line $linenum";

            my $cfg = $line->[$data->{configuration}];      
            
            # Defaulting config to CD if blank (FB8937)
            if (!$cfg) {
                $cfg = 'cd';
            }  

            my $catalogNumber = $line->[$data->{catalogID}];
            my $label         = $line->[$data->{label}];
            my $upc           = $line->[$data->{upc}];
            my $artist        = $line->[$data->{artistName}];
            my $title         = $line->[$data->{albumName}];     
            my $wholesale     = $line->[$data->{wholesalePrice}];            
            my $country       = $line->[$data->{country}];

            my $netUnits       = $line->[$data->{netUnits}];
            my $totalRevenue   = $line->[$data->{totalRevenue}];

            # Use the net units and revenue for the sales and returns data
            #
            my $sales          = $line->[$data->{sales}];
            my $salesRevenue   = ($totalRevenue > 0) ? $totalRevenue : 0;
            my $returns        = $line->[$data->{returns}];
            my $returnsRevenue = ($totalRevenue < 0) ? $totalRevenue : 0;

            if( $sales < 0 )
            {
                $returns += $sales;
                $sales = 0;
            }


            # Accept lines with sales or returns with revenue.  Also accept lines with
            # revenue but no sale or return units (these will error out, which is what we want).
            #
            if ( ($sales || $returns || $totalRevenue ) &&
                 $cfg !~ m/format\/config/i &&
                 ($artist || $title || $upc) )
            {

                my $countryCode; 
                if( my $obj = Common::Country->Get($country) )
                {
                    $countryCode = $obj->alpha2();
                }
                else
                {
                   $self->errstr("Unknown country '$country' in line $linenum");
                   return undef;
                }

                my $productType = $productTypeMap{ lc $cfg };
                if ( !$productType )
                {
                   print STDERR "Can't determine product type from '$cfg' in line $linenum";
                   $self->errstr("Can't determine product type from '$cfg' in line $linenum");
                   return undef;
                }                   

                my $sale = RPS::Import::SaleRec->new();

                if( $returns )
                {
                    $sale->returns(abs($returns));
                    $sale->returnsRevenue(abs($returnsRevenue));
                }
                if( $sales )
                {
                    $sale->sales($sales);
                    $sale->salesRevenue($salesRevenue);
                }

                $sale->totalRevenue($totalRevenue);
                
                my $free = 0;
                my $netUnits = $sales + $returns;
                
                if ($netUnits != 0 && $totalRevenue == 0) {
                    $free = 1;
                }
                
                $sale->free($free);

                $sale->wholesalePrice($wholesale);              
                $sale->productType($productType);
                $sale->dateBegin($dateBegin);
                $sale->dateEnd($dateEnd);
                $sale->labelName($label);
                $sale->albumName($title);
                $sale->serviceProductID($catalogNumber);

                $sale->upc(Common::Util::normalize_upc($upc)) if( $upc );

                $sale->artistName($artist);

                $sale->channel(RPS::File::Sale::CHANNEL_RETAIL);
                $sale->priceLevel(RPS::File::Sale::PLEVEL_FULL);
                $sale->countryCode($countryCode);                            
                $sale->currencyCode('GBP');                            
                
                $sale->lineNum($linenum);

                $self->_insertSale(sale => $sale);
            }
#            else { print STDERR "skip sheet($sheetIndex) l($linenum) ar($artist) title($title) "
#                   ." s($sales), r($returns) sR($salesRevenue) rR($returnsRevenue) tR($totalRevenue)\n"; }
            $linenum++;
        }
        $sheet_count++;
    }

    return $linenum;
}


sub _validateTotalSum {
    my ($self, $saleRec) = @_;
}

sub _validateReturnTotalSum {
    my( $self, $saleRec ) = @_;
}

sub _validateSaleTotalSum {
    my( $self, $saleRec ) = @_;
}

# _getDates: helper method to process US or UK formatted dates.
#
# The end date is checked to see if it's a US or UK-formatted date, with
# the assumption that the day will be be greater than 12 (most likely
# between 28-31). The begin date determines the reporting period, which
# will span one month regardless of the end date specified in the file.
#
sub _getDates {
    my $self  = shift;
    my %args  = @_;

    my $_dateBegin = $args{date_begin};  # YYYY-MM-DD or YYYY-DD-MM
    my $_dateEnd   = $args{date_end};    # YYYY-MM-DD or YYYY-DD-MM

    my $dateBegin = $_dateBegin;

    my( $beginYear, $beginMonth, $beginDay ) = split("-", $_dateBegin);
    my( $endYear,   $endMonth,   $endDay   ) = split("-", $_dateEnd);

    if( $endMonth > 12 )
    {
        $dateBegin = join("-", $beginYear, $beginDay, $beginMonth); # swap the month/day fields
    }

    return $self->SUPER::_getDates( date_begin => $dateBegin );
}

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