package RPS::Import::FNAC;

use strict;
#use warnings;

use Date::Calc qw(Days_in_Month Decode_Month);

use lib '/app/tools/common/lib';
use Common::Consts qw(%FRENCH_MONTH_MAP);
use Common::Util;

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

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


my %field_map = (
    summary => {
        sheet           => 0,
        period          => [11,1],
        album_unit      => [21,4],
        track_unit_c    => [27,4],
        track_unit_p    => [28,4],
    },
    album => {
        product     => RPS::File::Sale::TYPE_ALBUM,
        sheet       => 1,
        album       => 0,
        artist      => 1,
        #sale        => 2,
        cli_prod_id => 3,
        upc         => 4,
        svc_prod_id => 5,
        label       => 6,
        units       => 7,
    },
    track => {
        product     => RPS::File::Sale::TYPE_TRACK,
        sheet       => 2,
        track       => 0,
        album       => 1,
        artist      => 2,
        sale        => 3,
        isrc        => 4,
        cli_prod_id => 7,
        svc_prod_id => 8,
        label       => 9,
        units       => 10,
    },
);

#public methods

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

    my ($dateBegin, $dateEnd, $unit_price) = $self->_getDatesAndUnitPrices($sheets, $field_map{summary});
    unless ($dateBegin and $dateEnd)
    {
        $self->errstr("couldn't get dates");
        return undef;
    }

    unless ($unit_price->{album} && $unit_price->{track_carte} && $unit_price->{track_pack})
    {
        $self->errstr('failed to get unit prices');
        return undef;
    }

    my $linenum;
    foreach my $type(qw(album track))
    {
        $linenum = 1;
        my $offsets = $field_map{$type};
        my $prodType = $offsets->{product};

        foreach my $line(@{ $sheets->[ $offsets->{sheet} ]})
        {
            my $album       = $line->[ $offsets->{album} ];
            my $artist      = $line->[ $offsets->{artist} ];
            my $cli_prod_id = $line->[ $offsets->{cli_prod_id} ];
            my $svc_prod_id = $line->[ $offsets->{svc_prod_id} ];
            my $label       = $line->[ $offsets->{label} ];
            my ($units)     = $line->[ $offsets->{units} ] =~ m/^(\d+)$/;

            my $upc         = exists $offsets->{upc} ? Common::Util::normalize_upc($line->[ $offsets->{upc} ]) : undef;
            my $isrc        = exists $offsets->{isrc} ? Common::Util::normalize_isrc($line->[ $offsets->{isrc} ]) : undef;
            my $track       = exists $offsets->{isrc} ? $line->[ $offsets->{track} ] : undef;
            my $sale_type   = exists $offsets->{sale} ? lc $line->[ $offsets->{sale} ] : undef;

            if ($units && $album && ($upc || $isrc))
            {

                my $price =
                    $type eq 'album' ? $unit_price->{album} :
                    $sale_type =~ /carte/ ? $unit_price->{track_carte} :
                    $sale_type =~ /pack/ ? $unit_price->{track_pack} :
                    0;

                unless ($price)
                {
                    $self->errstr('unknown price type');
                    print STDERR "sale type: $sale_type\n";
                    return undef;
                }
                my $sale = RPS::Import::SaleRec->new();

                $sale->albumName($album);
                $sale->artistName($artist);
                $sale->clientProductID($cli_prod_id);
                $sale->countryCode('FR');
                $sale->currencyCode('EUR');
                $sale->dateBegin($dateBegin);
                $sale->dateEnd($dateEnd);
                $sale->formatType(RPS::File::Sale::FORMAT_DOWNLOAD);
                $sale->isrc($isrc);
                $sale->labelName($label);
                $sale->lineNum($linenum);
                $sale->price($price);
                $sale->productType($prodType);
                $sale->serviceProductID($svc_prod_id);
                $sale->trackName($track);
                $sale->units($units);
                $sale->upc($upc);

                #$args{dumper}($sale);  ## for cmd-line testing
                $self->_insertSale(sale => $sale);    ## Comment for cmd-line testing.
            }

            $linenum++;
        }
    }

    return $linenum;
}

#
# Private methods
#

sub _getDatesAndUnitPrices
{
    my $self  = shift;
    my $sheets = shift;
    my $offsets = shift;

    my $sheet = $sheets->[ $offsets->{sheet} ];
    my $period = $sheet->[ $offsets->{period}[0] ][ $offsets->{period}[1] ];
    return unless ($period =~ m/^(.+)\D(\d\d\d\d)/);

    my ($french_month, $year) = (lc $1, $2);
    $french_month =~ s/\s+//g;

    my $month = $FRENCH_MONTH_MAP{$french_month};
    unless ($month)
    {
        $self->errstr('invalid month');
        print STDERR "cannot map $french_month\n";
        return undef;
    }

    return (
        Common::Util::normalize_date(join('-', $year, $month, 1)),
        Common::Util::normalize_date(join('-', $year, $month, Days_in_Month($year, $month))),
        {
            album       => $sheet->[ $offsets->{album_unit}[0] ][ $offsets->{album_unit}[1] ],
            track_carte => $sheet->[ $offsets->{track_unit_c}[0] ][ $offsets->{track_unit_c}[1] ],
            track_pack  => $sheet->[ $offsets->{track_unit_p}[0] ][ $offsets->{track_unit_p}[1] ],
        }
    );
}

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