package RPS::Import::DRASubset;

use strict;

use Date::Calc qw(Days_in_Month);

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

use Common::RSMath qw(round);

use lib '/app/tools/data_classes/lib';
use Client::Service;

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

my %service_map = (
    'apple computer, inc.'     => Client::Service::DSP_ITUNES,
    'virginmega sas'           => Client::Service::DSP_VIRGINMEGA,
    'touch tunes, inc.'        => Client::Service::DSP_TOUCHTUNES,
    'hudson entertainment'     => Client::Service::DSP_HUDSON,
    'buongiorno vitaminic spa' => Client::Service::DSP_VITAMINIC,
    'mobilestreams'            => Client::Service::DSP_MOBILESTREAMS,
    'orange'                   => Client::Service::DSP_ORANGENEDERLAND,
    'fnac direct'              => Client::Service::DSP_FNAC,
);

my %format_map = (
    'permanent download'    => RPS::File::Sale::FORMAT_DOWNLOAD,
    'subscription play'     => RPS::File::Sale::FORMAT_STREAM,
    'ota'                   => RPS::File::Sale::FORMAT_DOWNLOAD,
    'subscription download' => RPS::File::Sale::FORMAT_DOWNLOAD,
    'master ringtone'       => RPS::File::Sale::FORMAT_RINGTONE,
    'polyphonic ringtone'   => RPS::File::Sale::FORMAT_RINGTONE,
);

my %field_map = (
    2 => {
        vendor_id   => 0,
        artist      => 1,
        track       => 2,
        album       => 3,
        isrc        => 4,
        upc         => 5,
        date_col    => 7,
        date_row    => 1,
        format_row  => 11,
        service_row => 12,
        start_col   => 37,
    },
);

#public methods

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

    my $lines   = $args{lines};
    my $fileObj = $args{file};
    my $version = $fileObj->VersionNum;

    #my $version = $args{version}; ## for cmd-line testing

    my $offsets = $field_map{$version};

    return undef unless ($lines);
    my ( $dateBegin, $dateEnd ) = $self->_getDates( $lines->[ $offsets->{'date_row'} ]->[ $offsets->{'date_col'} ] );
    unless ( $dateBegin && $dateEnd ) {
        $offsets->{'date_row'}++;
        ( $dateBegin, $dateEnd ) = $self->_getDates( $lines->[ $offsets->{'date_row'} ]->[ $offsets->{'date_col'} ] );
    }

    unless ( $dateBegin && $dateEnd ) {
        $self->errstr( "couldn't get dates from " . $lines->[ $offsets->{'date_row'} ]->[ $offsets->{'date_col'} ] );
        return undef;
    }

    my %errors;
    my @columns;

    my $start_col = 0;
  FIND_START: while ( $start_col < 300 ) {
        foreach my $format ( keys %format_map ) {
            if ( lc $lines->[ $offsets->{'format_row'} ]->[$start_col] eq $format ) {
                last FIND_START;
            }
        }
        $start_col++;
    }

    my $format;
    for ( my $i = $start_col ; $lines->[ $offsets->{'service_row'} ]->[$i] ne "" ; $i += 2 ) {
        if ( $lines->[ $offsets->{'format_row'} ]->[$i] ne "" ) {
            $format = $format_map{ lc $lines->[ $offsets->{'format_row'} ]->[$i] };
            unless ($format) {
                unless ( $errors{ $lines->[ $offsets->{'format_row'} ]->[$i] } ) {
                    print STDERR "unknown format: " . $lines->[ $offsets->{'format_row'} ]->[$i] . "\n";
                    $errors{ $lines->[ $offsets->{'format_row'} ]->[$i] } = 1;
                }
                $self->warning();
                next;
            }
        }

        $columns[$i]->{format} = $format;
        ( $columns[$i]->{service}, $columns[$i]->{country} ) = $self->_parseService( $lines->[ $offsets->{'service_row'} ]->[$i] );
        unless ( $columns[$i]->{service} ) {
            unless ( $errors{ $lines->[ $offsets->{'service_row'} ]->[$i] } ) {
                print STDERR "unknown service: " . $lines->[ $offsets->{'service_row'} ]->[$i] . "\n";
                $errors{ $lines->[ $offsets->{'service_row'} ]->[$i] } = 1;
            }
            $self->warning();
            next;
        }
    }

    my $linenum = 0;
    foreach my $line (@$lines) {
        $linenum++;
        next unless ( $linenum > $offsets->{'service_row'} + 1 );

        my $ptype     = RPS::File::Sale::TYPE_TRACK;
        my $artist    = $line->[ $offsets->{'artist'} ];
        my $album     = $line->[ $offsets->{'album'} ];
        my $track     = $line->[ $offsets->{'track'} ];
        my $vendor_id = $line->[ $offsets->{'vendor_id'} ];
        my $upc       = Common::Util::normalize_upc( $line->[ $offsets->{'upc'} ] );
        my $isrc      = Common::Util::normalize_isrc( $line->[ $offsets->{'isrc'} ] );

        #for (my $col = $offsets->{'start_col'}; $lines->[$offsets->{'service_row'}]->[$col] ne ""; $col += 2) {
        for ( my $col = $start_col ; $lines->[ $offsets->{'service_row'} ]->[$col] ne "" ; $col += 2 ) {

            my $format  = $columns[$col]->{format};
            my $service = $columns[$col]->{service};
            my $country = $columns[$col]->{country};

            my $units = $line->[$col];
            my $price = $line->[ $col + 1 ];

            $price =~ s/^\$//g;

            $price = ( $units != 0 ) ? round( $price / $units, 8 ) : 0;

            if ( $units && $track && $artist && $album && $service && $country && $format ) {
                my $sale = RPS::Import::SaleRec->new();

                $sale->serviceID($service);
                $sale->productType($ptype);
                $sale->formatType($format);
                $sale->dateBegin($dateBegin);
                $sale->dateEnd($dateEnd);
                $sale->serviceProductID($vendor_id);
                $sale->upc($upc);
                $sale->isrc($isrc);
                $sale->artistName($artist);
                $sale->albumName($album);
                $sale->trackName($track);
                $sale->units($units);
                $sale->price($price);
                $sale->lineNum($linenum);
                $sale->countryCode($country);

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

#
# Private methods
#

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

    my ( $dateBegin, $dateEnd );

    if ( $date =~ m/^(\d{4})-(\d?\d)-(\d?\d) to (\d{4})-(\d?\d)-(\d?\d)$/ ) {
        my ( $dateBegin, $dateEnd ) = $self->SUPER::_getDates(
            date_begin => sprintf( "%04d-%02d-%02d", $1, $2, $3 ),
            date_end   => sprintf( "%04d-%02d-%02d", $4, $5, $6 ),
            type       => "iso"
        );

        return ( $dateBegin, $dateEnd );
    }

    return undef;
}

sub _parseService {
    my $self        = shift;
    my $serviceCell = lc shift;

    my $country;
    foreach my $cc ( keys %COUNTRY_CODE ) {
        if ( $serviceCell =~ s/\s+\(?$cc\)?$// ) {
            $country = $COUNTRY_CODE{$cc};
            last;
        }
    }

    if ( $serviceCell =~ s/\s+s\.a\.r\.l\.$// ) {
        $country = 'EU';
    } else {
        $country ||= 'US';
    }

    # if country _is_ present and doesn't match anything in %COUNTRY_CODE then it'll remain part of the
    # service name and won't be identified in the following statement - so it will still get caught
    return ( $self->getServiceID($serviceCell) || $service_map{$serviceCell}, $country, );
}

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