package RPS::Import::ADA::v13;

use strict;

use Date::Calc qw(Days_in_Month Decode_Month);
use Data::Dumper;

use lib '/app/tools/common/lib';
use Common::Util qw(normalize_date normalize_upc);
use Common::Country;

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

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

use base 'RPS::Import::MapFaceBase';
use base 'RPS::Import::ADA::ADACommon';

sub _headerIdentifier { ( upc => 'UPC' ) }

sub _validateFieldMap {}

sub _fieldMap {
    
    my $self = shift;
    
    my $sheetName = lc $self->{sheetname};    
    
    # Need to be able to accept flat files too.
    if (!$sheetName) {
        $sheetName = 'digital sales';   
    }
    
    my %fieldMaps = (
        'statement summary' => {
        },

        'digital sales' => {
            label            => 0,  # A 
            serviceID        => 11, # L
            countryCode      => 13, # N
            productType      => 5,  # F
            formatType       => 15, # P
            serviceProductID => 9,  # J
            clientProductID  => 8,  # I
            artistName       => 3,  # D
            upc              => 6,  # G

            albumName        => 4,  # E  can be track name (depending on product type)
            trackName        => 4,  # E

            isrc             => 7,  # H
            units            => 18, # S
            price            => 23, # X
        },        
    );
    if ($fieldMaps{$sheetName}) {
        return $fieldMaps{$sheetName};
    } else {
        print STDERR "ADA v13: Illegal sheet '$sheetName'\n";            
        die "Sheet '$sheetName' is not valid"; 
    }    
}

sub _unverifiedFieldMap {
    
    my $self = shift;
    
    my $sheetName = lc $self->{sheetname};    
    
    # Need to be able to accept flat files too.
    if (!$sheetName) {
        $sheetName = 'digital sales';   
    }
    
    my %fieldMaps = (
        'statement summary' => {
            date_row => 3,  # Row 4
            date_col => 1,  # Col B
        },

        'digital sales' => {
        },        
    );
    if ($fieldMaps{$sheetName}) {
        return $fieldMaps{$sheetName};
    } else {
        print STDERR "ADA v13: Illegal sheet '$sheetName'\n";            
        die "Sheet '$sheetName' is not valid"; 
    }    
}


my %mediaProductTypeMap = (
   'album' => {
      product_type => RPS::File::Sale::TYPE_ALBUM,
      media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
   },
   'audio clip' => {
      product_type => RPS::File::Sale::TYPE_TRACK,
      media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
   },
   'ep' => {
      product_type => RPS::File::Sale::TYPE_ALBUM,
      media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
   },
   'full length' => {
      product_type => RPS::File::Sale::TYPE_ALBUM,
      media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
   },
   'full length release' => {
      product_type => RPS::File::Sale::TYPE_ALBUM,
      media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
   },
   'full length recording (track)' => {
      product_type => RPS::File::Sale::TYPE_TRACK,
      media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
   },
   'mastertone' => {
      product_type => RPS::File::Sale::TYPE_TRACK,
      media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
   },
   'music video ringer' => {
      product_type => RPS::File::Sale::TYPE_TRACK,
      media_type   => RPS::DB::Item::MediaType::kMediaTypeVideo,
   },
   'ringbacktone' => {
      product_type => RPS::File::Sale::TYPE_TRACK,
      media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
   },
   'ringtone' => {
      product_type => RPS::File::Sale::TYPE_TRACK,
      media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
   },
   'single' => {
      product_type => RPS::File::Sale::TYPE_ALBUM,
      media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
   },
   'single track' => {
      product_type => RPS::File::Sale::TYPE_TRACK,
      media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
   },
   'track' => {
      product_type => RPS::File::Sale::TYPE_TRACK,
      media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
   },
   'track (step)' => {
      product_type => RPS::File::Sale::TYPE_TRACK,
      media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
   },   
   'video' => {
      product_type => RPS::File::Sale::TYPE_TRACK,
      media_type   => RPS::DB::Item::MediaType::kMediaTypeVideo,
   },
   'videosingle' => {
      product_type => RPS::File::Sale::TYPE_ALBUM,
      media_type   => RPS::DB::Item::MediaType::kMediaTypeVideo,
   },
   'video single' => {
      product_type => RPS::File::Sale::TYPE_ALBUM,
      media_type   => RPS::DB::Item::MediaType::kMediaTypeVideo,
   },
);

sub currencyCode { 'GBP' }

sub _getDateBegin { shift->{_dateBegin} }
sub _getDateEnd   { shift->{_dateEnd} }

sub _preProcess {
    my $self = shift;
    my %args = @_;

    Log->info( "Starting _preProcess" );
    $self->SUPER::_preProcess(%args);

    # For some sales files (huge XLSX files), we'll have to manually save the
    # XLSX detail data as a flat-file, and extract the date information from
    # from the filename itself.  This is a workaround until we come up with
    # a solution for handling "too large" XLSX files.  See FB311.
    #
    my $dateBegin;
    my $dateEnd;
    
    my $isFlatFile = ( scalar @{$args{sheets}} == 1 ) ? 1 : undef;
    my $fileName = $args{file}->OrigFileName();
    my $sheet_count = 0;
    my $sheet_names = $args{sheet_names};    
    
    if( $isFlatFile )
    {
        if( $fileName =~ /(\d{4})(\d{2})(\d{2})_(\d{4})(\d{2})(\d{2})/ )   # YYYYMMDD_YYYYMMDD.
        {
            $dateBegin = sprintf("%04d-%02d-%02d", $1, $2, $3);
            $dateEnd   = sprintf("%04d-%02d-%02d", $4, $5, $6);
        }
    }
    else
    {
        #-----------------------------------------
        # Extract date information from header tab
        #-----------------------------------------
        my $dateField;
        foreach my $sheet(@{ $args{sheets} })
        {
            my $sheetName = $sheet_names->[$sheet_count];

            my $sheetIndex = lc $sheetName;

            if ($sheetIndex eq 'statement summary')
            {
                # Get the date information from the summary sheet
                $self->{sheetname} = $sheetName;
                my $data = $self->_fieldMap();

                my $dateRow = $data->{date_row};
                my $dateCol = $data->{date_col};

                $dateField = $sheet->[$dateRow][$dateCol];

                if ( $dateField =~ m/Period: (\d{1,2})\/(\d{1,2})\/(\d{4}) . (\d{1,2})\/(\d{1,2})\/(\d{4})/ )
                {
                    $dateBegin = join("-", $3, sprintf("%02d",$1), sprintf("%02d",$2) );
                    $dateEnd   = join("-", $6, sprintf("%02d",$4), sprintf("%02d",$5) );

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

                if( !$dateBegin && !$dateEnd )
                {
                    # If we don't find the date where we expect it, then the actual
                    # cell location has likely shifted due to one or more blank columns
                    # to the left and/or blank rows at the top.  The following will
                    # attempt to find the date cell within the first 5 columns/rows.
                    #
                    foreach my $col (0..4)
                    {
                        foreach my $row (0..4)
                        {
                            my $cellData = $sheet->[$row][$col];

                            if ( $cellData =~ m/Period: (\d{1,2})\/(\d{1,2})\/(\d{4}) . (\d{1,2})\/(\d{1,2})\/(\d{4})/ )
                            {

                                $dateBegin = join("-", $3, sprintf("%02d",$1), sprintf("%02d",$2) );
                                $dateEnd   = join("-", $6, sprintf("%02d",$4), sprintf("%02d",$5) );

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

                            }
                            last if ( $dateBegin || $dateEnd );
                        }

                        last if ( $dateBegin || $dateEnd );
                    }

                }
            }# statement summary

            last if ( $dateField );
            $sheet_count++;
        }
    }
    
    $self->{_dateBegin} = $dateBegin;
    $self->{_dateEnd}   = $dateEnd;
}

sub countryCode {
    my $self = shift;

    if (defined $self->_getByFieldName( 'countryCode' )) {
        my $name = $self->_getByFieldName( 'countryCode' );
	    my $country = Common::Country->Get( $name );
		if ($country) {
			return $country->alpha2();
		} else {
			return $name;
		}        
    } 
}

sub units {
    my $self = shift;
    my $units = $self->_getByFieldName( 'units' ) || return;
    $units =~ s/,//g;
    $units =~ s/\s+//g;   
    if( $units =~ /^\((\d*\.?\d*)\)$/ )
    {
        $units = $1 * -1;
    }
     
    my $price = $self->_getByFieldName( 'price' );
    if( $price =~ /^\((\d*\.?\d*)\)$/ )
    {
        $price = $1 * -1;
    }      

    if ( $units && $units < 0 && $price && $price > 0 )
    {               
        return $self->handleError( "Negative units with revenue", RPS::DB::Item::SaleImportError::kErrorNonqualifying );
    }

    # For this importer, We'll follow the sign of the revenue to determine
    # the sign of the units (FB1168).
    #
    if( $price && $units )
    {
        if( $price < 0 )
        {
            $units = 0 - $units if( $units > 0 ); # price is negative, force negative units
        }
        else
        {
            $units = abs($units) if( $units < 0 ); # price is positive, force positive units
        }
    }

    return $units;
}

sub price {
    my $self = shift;
     
    my $price = $self->_getByFieldName( 'price' );
    if( $price =~ /^\((\d*\.?\d*)\)$/ )
    {
        $price = $1;
    }     
    
    return $price;     
}

sub free 
{
    my $self = shift;
    my $price = $self->_getByFieldName( 'price' );
    return ( $price == 0 ) ? 1 : 0;
}

            
sub _isValidSaleRecord 
{
    my $self = shift;
    my $units  = $self->units;
    my $price  = $self->price;
    my $releaseType = lc $self->_getByFieldName( 'productType' );

    return undef if ( !$units && $price && $price < 0 );
    return undef if ( $releaseType =~ /wallpaper/i );
    return $self->SUPER::_isValidSaleRecord();
}
          

sub formatType 
{
    my $self = shift;
    my $releaseType = lc $self->_getByFieldName( 'productType' );
    my $deliveryFormat = lc $self->_getByFieldName( 'formatType' );

    my $formatType = $self->_getFormatType( release_type => $releaseType, delivery_format => $deliveryFormat );
    if ($formatType) 
    {
        return $formatType;
    }
    else
    { 
        return $deliveryFormat;
    }   
}  

sub mediaType           
{
    my $self = shift;
    my $releaseType = lc $self->_getByFieldName( 'productType' );
    my $deliveryFormat = lc $self->_getByFieldName( 'formatType' );

    my $mediaType;
    
    if ($releaseType eq '' && $deliveryFormat =~ /^usergenmastertone$/i) 
    {
        $mediaType   = RPS::DB::Item::MediaType::kMediaTypeAudio;
    }
    else
    {
        $mediaType = $mediaProductTypeMap{ $releaseType }->{ media_type };
    }
    
    if ($mediaType)
    {               
        return $mediaType
    } else {
        return $releaseType;
    }
}

sub productType           
{
    my $self = shift;
    my $releaseType = lc $self->_getByFieldName( 'productType' );
    my $deliveryFormat = lc $self->_getByFieldName( 'formatType' );

    my $productType;
    
    if ( $releaseType eq '' && $deliveryFormat =~ /^usergenmastertone$/i ) 
    {
        $productType = RPS::File::Sale::TYPE_TRACK;
    }
    # Per FB16627: If the release type is video, then
    #   product type is track if ISRC is populated, otherwise
    #   product type is album if UPC is populated.
    #
    elsif ( $releaseType =~ /^video$/i || $releaseType =~ /^video.*single$/i )    
    {
        my $_isrc = $self->_getByFieldName( 'isrc' ) if (defined $self->_getByFieldName( 'isrc' ));  
        my $_upc  = $self->_getByFieldName( 'upc' )  if (defined $self->_getByFieldName( 'upc' ) );  
        if( $_isrc )
        {
            $productType = RPS::File::Sale::TYPE_TRACK;
        }
        elsif( $_upc )
        {
            $productType = RPS::File::Sale::TYPE_ALBUM;
        }        
    }
    else
    {
        $productType = $mediaProductTypeMap{ $releaseType }->{ product_type };
    }
    
    if ($productType)
    {               
        return $productType
    } else {
        return $releaseType;
    }
}

sub serviceID {
    my $self = shift;
    my $serviceName = $self->_getByFieldName( 'serviceID' ) || return;

    my $serviceID = $self->getServiceID(lc ($serviceName)); # See ADACommon
    if (!$serviceID)
    {                  
        return $self->handleError("Unknown service: $serviceName", RPS::DB::Item::SaleImportError::kErrorService);
    } 
    else
    {
        return $serviceID;   
    }
}

sub isrc {
    my $self = shift;
    
    my $isrc = $self->_getByFieldName( 'isrc' );

    if ( $isrc )
    {
        return Common::Util::normalize_isrc($isrc);
    }  
}

sub upc {
    my $self = shift;
    
    my $upc = $self->_getByFieldName( 'upc' );

    if ( $upc )
    {
        return Common::Util::normalize_upc($upc);
    }  
}

sub albumName {
    my $self = shift;
    my $isrc = $self->_getByFieldName( 'isrc' );
    my $name = $self->_getByFieldName( 'albumName' );
    if ( !$isrc )
    {    
        return $name;
    } 
}

sub trackName {
    my $self = shift;
    my $isrc = $self->_getByFieldName( 'isrc' );
    my $name = $self->_getByFieldName( 'trackName' );
    if ( $isrc )
    {    
        return $name;
    }
}
                             

sub _getFormatType
{
    my $self = shift;
    my %args = @_;
    my $releaseType     = $args{release_type};
    my $deliveryFormat  = $args{delivery_format};

    my $formatType;

    if( $releaseType eq 'mastertone' )
    {
        if( $deliveryFormat eq 'download' )
        {
            $formatType = RPS::File::Sale::FORMAT_DOWNLOAD;
        }
        elsif( $deliveryFormat eq 'stream' )
        {
            $formatType = RPS::File::Sale::FORMAT_STREAM;
        }
    }
    elsif( $releaseType eq 'music video ringer' )
    {
        $formatType = RPS::File::Sale::FORMAT_DOWNLOAD if( $deliveryFormat eq 'download' );
    }
    elsif( $releaseType eq 'ringbacktone' )
    {
        if( $deliveryFormat eq 'download' )
        {
            $formatType = RPS::File::Sale::FORMAT_RINGTONE;
        }
        elsif( $deliveryFormat eq 'stream' )
        {
            $formatType = RPS::File::Sale::FORMAT_STREAM;
        }
    }
    elsif( $releaseType eq 'album'        ||
           $releaseType eq 'ep'           ||
           $releaseType eq 'single track' ||
           $releaseType eq 'single'       ||
           $releaseType eq 'track (step)' ||
           $releaseType eq 'track'        ||
           $releaseType eq 'audio clip'   ||
           $releaseType eq 'full length'  ||
           $releaseType eq 'full length recording (track)' )
    {
        if( $deliveryFormat eq 'download' )
        {
            $formatType = RPS::File::Sale::FORMAT_DOWNLOAD;
        }
        elsif( $deliveryFormat eq 'stream' )
        {
            $formatType = RPS::File::Sale::FORMAT_STREAM;
        }
    }
    elsif( $releaseType eq 'full length' )
    {
        if( $deliveryFormat eq 'download' )
        {
            $formatType = RPS::File::Sale::FORMAT_DOWNLOAD;
        }
    }
    elsif( $releaseType eq 'full length release' )
    {
        if( $deliveryFormat eq 'download' )
        {
            $formatType = RPS::File::Sale::FORMAT_DOWNLOAD;
        }
        elsif( $deliveryFormat eq 'stream' )
        {
            $formatType = RPS::File::Sale::FORMAT_STREAM;
        }
    }

    # The following delivery formats apply to all release types
    #
    if( $deliveryFormat eq 'emastertone' ||
        $deliveryFormat eq 'eringback' )
    {
        $formatType = RPS::File::Sale::FORMAT_RINGTONE;
    }

    elsif( $deliveryFormat eq 'emdalbum' ||
           $deliveryFormat eq 'emdtrack' ||
           $deliveryFormat eq 'evd' )
    {
        $formatType = RPS::File::Sale::FORMAT_DOWNLOAD;
    }

    elsif( $deliveryFormat eq 'emdalbumstreaming' ||
           $deliveryFormat eq 'emdtrackstreaming' ||
           $deliveryFormat eq 'evdstreaming' ||
           $deliveryFormat eq 'usergenmastertone' )
    {
        $formatType = RPS::File::Sale::FORMAT_STREAM;
    }
    elsif( $releaseType eq 'videosingle' ||
           $releaseType eq 'video single' )
    {
        if( $deliveryFormat eq 'stream' ) {
            $formatType = RPS::File::Sale::FORMAT_STREAM;
        }
        elsif( $deliveryFormat eq 'download' ) {
            $formatType = RPS::File::Sale::FORMAT_DOWNLOAD;
        }
    }

    return $formatType;
}

# _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).
# Note: the end date is used in determining the sales period.
#
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 $dateEnd = $_dateEnd;

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

    if( $endMonth > 12 )
    {
        $dateEnd = join("-", $endYear, $endDay, $endMonth); # swap the month/day fields
    }

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

## MapFace Stuff
sub _mapFaceCompatibleVersions {
	return (13,20);
}

sub _mapFaceServiceID {
	return ('serviceID', 'countryCode');
}

sub _mapFaceCountryCode {
	return ('countryCode');
}

sub _mapFaceProductType {
	return ('formatType', 'productType');
}

sub _mapFaceFormatType {
	return ('formatType', 'productType');
}

sub _mapFaceMediaType {
	return ('formatType', 'productType');
}

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