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.
###