package RPS::Import::Amazon;
use strict;

use Date::Calc qw(Days_in_Month Decode_Month);

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

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

#private constants
use constant FIELD_SVCPRODID   => 0;
use constant FIELD_CLIPRODID_A => 1;
use constant FIELD_UPC         => 2;
use constant FIELD_CLIPRODID_T => 3;
use constant FIELD_ISRC        => 4;
use constant FIELD_PRODTYPE    => 5;
use constant FIELD_UNITS       => 6;
use constant FIELD_PRICE       => 7;
use constant FIELD_ARTIST      => 9;
use constant FIELD_ALBUM       => 10;
use constant FIELD_TRACK       => 11;
use constant FIELD_LABEL       => 12;

use constant FORMAT => RPS::File::Sale::FORMAT_DOWNLOAD;

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

my %gCountryCodeToCurrencyMap = (
    'US' => 'USD',
    'JP' => 'JPY',
    'NZ' => 'NZD',
    'IS' => 'ISD',
    'JM' => 'JMD',
    'EU' => 'EUR',
    'GB' => 'GBP',
    'CA' => 'CAD',
    'AU' => 'AUD',
    'DE' => 'EUR',
    'FR' => 'EUR',
    'BE' => 'EUR',
    'IT' => 'EUR',
    'CH' => 'CHF',
    'PL' => 'PLN',
    'LV' => 'LVL',
    'LT' => 'LTL',
    'KR' => 'KRW',
    'ZA' => 'ZAR',
    'GR' => 'EUR',
    'NL' => 'EUR',
);

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

    my $lines    = $args{lines};
    my $fileObj  = $args{file};
    my $version  = $self->_version();
    my $fileName = $fileObj->OrigFileName();
    return 0 unless $lines;

    my $currency_code = 'USD';
    my $country_code  = 'US';

    if ( $version == 6 ) {
        $currency_code = 'GBP';
        $country_code  = 'GB';
    }

    my $dates;

    if ( $version == 2 ) {
        $dates = $lines->[0][0];
    } elsif ( ( $version == 6 ) || ( $version == 7 ) ) {
        $dates = $lines->[1][0];
    } else {
        $dates = $fileName;
    }

    if ( $version == 7 ) {
        my $countryRow = $lines->[0][0];

        if ( $countryRow =~ m/Amazon (\w{2}) MP3 Sales$/ ) {
            $country_code  = $1;
            $currency_code = $gCountryCodeToCurrencyMap{$country_code};

            unless ($currency_code) {
                $self->errstr("Unable to determine currency for country: $country_code");
                print STDERR "Unable to determine currency for country: $country_code\n";
                return 0;
            }
        } else {

            # Example:
            # Amazon CH MP3 Sales (Cost in Euros)
            $countryRow =~ m/Amazon (\w{2}) MP3 Sales \(Cost in (.+)\)$/;
            $country_code = $1;
            my $currency = $2;

            if ( $currency eq 'US Dollars' ) {
                $currency_code = 'USD';
            } elsif ( $currency eq 'Euros' ) {
                $currency_code = 'EUR';
            } else {
                $currency_code = $gCountryCodeToCurrencyMap{$country_code};
                unless ($currency_code) {
                    $self->errstr("currency not recognized: $currency");
                    print STDERR "currency not recognized: $currency\n";
                    return 0;
                }
            }
        }

        #foreach my $countryCode(keys %gCountryCodeToCurrencyMap){
        #    if($1 =~ /$countryCode/){
        #        $country_code = $countryCode;
        #        $currency_code = $gCountryCodeToCurrencyMap{$countryCode};
        #    }
        #}
    }

    #my $dates = $version == 2 ? $lines->[0][0] : $fileName;
    my ( $dateBegin, $dateEnd ) = $self->_getDates($dates);

    unless ( $dateBegin && $dateEnd ) {
        $self->errstr("couldn't get dates");
        print STDERR "date source: $dates\n";
        return 0;
    }

    my %errors  = ();
    my $linenum = 1;
    foreach my $line (@$lines) {
        my $free = 0;
        my ( $cliProdID, $upc, $isrc );
        my $prodType  = uc $line->[FIELD_PRODTYPE];
        my $svcProdID = $line->[FIELD_SVCPRODID];

        if ( $prodType eq 'A' ) {
            $cliProdID = $line->[FIELD_CLIPRODID_A];
            $upc = normalize_upc( $line->[FIELD_UPC] ) || normalize_upc($cliProdID);
        } elsif ( $prodType eq 'T' ) {
            $cliProdID = $line->[FIELD_CLIPRODID_T];
            $isrc      = normalize_isrc( $line->[FIELD_ISRC] );
            $upc       = normalize_upc( $line->[FIELD_UPC] ) || normalize_upc( $line->[FIELD_CLIPRODID_A] );
        }

        my $album  = $line->[FIELD_ALBUM];
        my $artist = $line->[FIELD_ARTIST];
        my $label  = $line->[FIELD_LABEL];
        my $price  = abs( $self->numeric( $line->[FIELD_PRICE] ) );
        my $return = 1 if ( $self->numeric( $line->[FIELD_PRICE] ) < 0 );
        my $track  = $line->[FIELD_TRACK];
        my $units  = $self->numeric( $line->[FIELD_UNITS] );
        $units *= -1 if ( $return && $units > 0 );

        if ( $units && ( $track !~ /Track_Name/ || $album !~ /ALBUM_NAME/ ) ) {
            unless ( $prodType =~ /(A|T)/i || $errors{$prodType} ) {
                print STDERR "unknown prod type: " . $line->[FIELD_PRODTYPE] . " ($linenum)\n";
                $errors{$prodType} = 1 unless ( $prodType eq '' );
            }

            if ( !$price ) {
                $price = 0;
            }

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

            $sale->albumName($album);
            $sale->artistName($artist);
            $sale->clientProductID($cliProdID);
            $sale->dateBegin($dateBegin);
            $sale->dateEnd($dateEnd);
            $sale->formatType(FORMAT);
            $sale->isrc($isrc);
            $sale->labelName($label);
            $sale->lineNum($linenum);
            $sale->upc($upc);
            $sale->price($price);
            $sale->productType($prodType);
            $sale->serviceProductID($svcProdID);
            $sale->free($free);
            $sale->trackName($track);
            $sale->units($units);
            $sale->currencyCode($currency_code);
            $sale->countryCode($country_code);

            #$args{dumper}($sale);
            $self->_insertSale( sale => $sale );
        }

        #else { print STDERR "skip: ($linenum) p: $price u: $units t:".$track." a:".$album."\n"; }
        $linenum++;
    }

    return $linenum;
}

#
# Private methods
#

sub _getDates {
    my $self   = shift;
    my $source = shift;

    my ( $month, $year );
    if ( $source =~ m/[\s_\-]+(\w\w\w)(\d\d)\D/ ) {
        ( $month, $year ) = ( $1, $2 );
        $month = Decode_Month($1);
        $year += 2000 if ( $year < 2000 );
    } elsif ( $source =~ m/^(\d+)\D\d+\D(\d+)\D/ ) {
        ( $month, $year ) = ( $1, $2 );
    }

    return undef unless ( $month && $year > 2000 );
    return ( sprintf( "%04d-%02d-01", $year, $month ), sprintf( "%04d-%02d-%02d", $year, $month, Days_in_Month( $year, $month ) ) );
}

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