package RPS::Import::KochDigital;

use strict;
use warnings;

use Date::Calc qw(Days_in_Month);
use Math::BigFloat;

use lib '/app/tools/common/lib';
use Common::Util;
use Common::Consts;

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 %indexes = map { lc $_ => -1 } (
    'Album ID / Item #',
    'Album / Track Artist',
    'Album / Track Title',
    'Digital Provider',
    'Disc',
    'Dollars',
    'Format',
    'Units',
    'UPC / ISRC #',
);

# Insert aliases to the above in here:
my %aliases = map lc, (

    #'Foo Bar'  => 'Original Name',
    'Album  / Track Title' => 'Album / Track Title',
    'service_product_id'   => 'Album ID / Item #',
    'artist'               => 'Album / Track Artist',
    'format'               => 'Format',
    'prodcode'             => 'UPC / ISRC #',
    'service'              => 'Digital Provider',
    'title'                => 'Album / Track Title',
    'units'                => 'Units',
    'price'                => 'Dollars',
);

my %format_map = (
    'track ***'                         => [ RPS::File::Sale::TYPE_TRACK, RPS::File::Sale::FORMAT_DOWNLOAD ],
    'track download'                    => [ RPS::File::Sale::TYPE_TRACK, RPS::File::Sale::FORMAT_DOWNLOAD ],
    'track teth download'               => [ RPS::File::Sale::TYPE_TRACK, RPS::File::Sale::FORMAT_TETHERED ],
    'track stream'                      => [ RPS::File::Sale::TYPE_TRACK, RPS::File::Sale::FORMAT_STREAM ],
    'track ringtone'                    => [ RPS::File::Sale::TYPE_TRACK, RPS::File::Sale::FORMAT_RINGTONE ],
    'track background'                  => [ RPS::File::Sale::TYPE_TRACK, RPS::File::Sale::FORMAT_BACKGROUNDMUSIC ],
    'album download'                    => [ RPS::File::Sale::TYPE_ALBUM, RPS::File::Sale::FORMAT_DOWNLOAD ],
    'track non drm upgrade track'       => [ RPS::File::Sale::TYPE_TRACK, RPS::File::Sale::FORMAT_DOWNLOADUPGRADE ],
    'album high quality song'           => [ RPS::File::Sale::TYPE_ALBUM, RPS::File::Sale::FORMAT_DOWNLOADPREMIUM ],
    'track high quality song'           => [ RPS::File::Sale::TYPE_TRACK, RPS::File::Sale::FORMAT_DOWNLOADPREMIUM ],
    'album high quality playlist/album' => [ RPS::File::Sale::TYPE_ALBUM, RPS::File::Sale::FORMAT_DOWNLOADPREMIUM ],
    'album non drm upgrade album'       => [ RPS::File::Sale::TYPE_ALBUM, RPS::File::Sale::FORMAT_DOWNLOADUPGRADE ],
    'track song'                        => [ RPS::File::Sale::TYPE_TRACK, RPS::File::Sale::FORMAT_DOWNLOAD ],
    'track download-subscription'       => [ RPS::File::Sale::TYPE_TRACK, RPS::File::Sale::FORMAT_VPD ],
    'track burn'                        => [ RPS::File::Sale::TYPE_TRACK, RPS::File::Sale::FORMAT_DOWNLOAD ],
    'album download-subscription'       => [ RPS::File::Sale::TYPE_ALBUM, RPS::File::Sale::FORMAT_VPD ],
    'album playlist upgrade'            => [ RPS::File::Sale::TYPE_ALBUM, RPS::File::Sale::FORMAT_DOWNLOADUPGRADE ],
    'track video teth downl'            => [ RPS::File::Sale::TYPE_TRACK, RPS::File::Sale::FORMAT_TETHERED ],
    'track audio ad support/stream'     => [ RPS::File::Sale::TYPE_TRACK, RPS::File::Sale::FORMAT_STREAM ],
);

#
# This map is no longer used.  Calling the function getServiceID instead.
my %service_map = map lc,
  (
    AltNet         => Client::Service::DSP_ALTNET,
    BuyMusic       => Client::Service::DSP_BUYMUSIC,
    eMusic         => Client::Service::DSP_EMUSIC,
    iTunes         => Client::Service::DSP_ITUNES,
    'Liquid Audio' => Client::Service::DSP_LIQUIDAUDIO,
    MusicMatch     => Client::Service::DSP_MUSICMATCH,
    MusicNet       => Client::Service::DSP_MEDIANET,
    MusicNow       => Client::Service::DSP_MUSICNOW,
    Napster        => Client::Service::DSP_NAPSTER,
    Real           => Client::Service::DSP_REAL,
    "musicgiant"   => Client::Service::DSP_MUSICGIANTS,
    "hdtracks"     => Client::Service::DSP_HDTRACKS,
  );

my %format_errors;

#public methods

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

    my $fileObj  = $args{file};
    my $fileName = $fileObj->OrigFileName;
    ##my $fileName = $args{OrigFileName}; ## for cmd-line testing

    my $lines = $args{lines};

    my $linenum     = 1;
    my $headerFound = 0;

    my $fileDate;

    while ( my $line = shift @$lines ) {
        my @elements = map { Common::Util::trimspaces($_) } @$line;
        my $elementnum = 0;
        for my $element (@elements) {
            my $e = lc $element;

            # We can also find the date through regex,
            # but it seems to make the import run a lot slower.
            #if ($e =~ m/^fiscal period:/)
            if ( ( $linenum == 5 ) && ( $elementnum == 2 ) ) {
                $fileDate = $e;
            }

            if ( exists $aliases{$e} ) {
                $e = $aliases{$e};
            }
            if ( exists $indexes{$e} ) {
                $indexes{$e} = $elementnum;
                ++$headerFound;
            }
        }

        continue { $elementnum++; }
    } continue {
        $linenum++;

        if ($headerFound) {
            my $keyCount = scalar keys %indexes;
            if ( $headerFound != $keyCount ) {
                warn "Not all headers found, $headerFound != $keyCount:\n",
                  "Not found: ",
                  join( ', ', grep { $indexes{$_} < 0 } keys %indexes );
            }

            last;
        }
    }

    #
    # First we'll check for the date in the file name
    my ( $dateBegin, $dateEnd ) = $self->_getDatesFromFileName($fileName);

    #
    # If there's no date in the file name, we'll look in the file
    unless ( defined $dateBegin && defined $dateEnd ) {
        ( $dateBegin, $dateEnd ) = $self->_getDatesFromFile($fileDate);
    }

    #
    # If there's no date in the file name or file, then game over, man.
    unless ( defined $dateBegin && defined $dateEnd ) {
        print STDERR "Couldn't get dates from: " . $fileName . "\n";
        $self->errstr( "couldn't get dates from: " . $fileName );
        return undef;
    }

    foreach my $line (@$lines) {
        my $artist           = $line->[ $indexes{ $aliases{artist} } ];
        my $format           = $line->[ $indexes{ $aliases{format} } ];
        my $price            = $line->[ $indexes{ $aliases{price} } ];
        my $prodcode         = $line->[ $indexes{ $aliases{prodcode} } ];
        my $serviceName      = $line->[ $indexes{ $aliases{service} } ];
        my $title            = $line->[ $indexes{ $aliases{title} } ];
        my $units            = $line->[ $indexes{ $aliases{units} } ];
        my $serviceProductID = $line->[ $indexes{ $aliases{service_product_id} } ];

        unless ( $artist && $serviceName && $title && $units ) {
            next;
        }

        my $prodtype = $format_map{ lc $format };

        if ( !$prodtype && !$format_errors{$format} ) {
            $self->errstr("Unknown format '$format'");
            print STDERR "Uknown format: '$format\n'";
            $format_errors{$format} = 1;
            next;

            #return;
        } elsif ( !$prodtype ) {
            next;
        }

        ( $prodtype, $format ) = @{$prodtype};

        my $service = $self->_get_service_id($serviceName);

        unless ($service) {

            #print STDERR "Using service map: X".lc($serviceName)."X\n";
            $service = $service_map{ lc $serviceName };
        }

        #$service = $service_map{ lc $service };
        unless ($service) {
            $self->errstr("Unknown service '$serviceName'");
            return;
        }

        # Figure out if this is whole album info, or just single track info:
        my ( $album, $upc );
        my ( $track, $trackNum, $isrc );
        if ( $prodtype eq RPS::File::Sale::TYPE_TRACK ) {
            ( $trackNum, $track ) = $title =~ /^\s*Track:?\s*(\d+)\s*[:-]\s*(.*)/;
            $isrc = $prodcode;
        } elsif ( $prodtype eq RPS::File::Sale::TYPE_ALBUM ) {
            $album = $title;
            $upc   = $prodcode;
        } else {
            $self->errstr("Unknown product type '$prodtype'");
            return;
        }

        if ( 0 != $units ) {
            $price = Math::BigFloat->new($price);
        } else {
            $price = 0;
        }

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

        $sale->albumName($album) if ($album);
        $sale->artistName($artist);

        # averagePrice channel clientProductID
        # configuration conversionRate countryCode
        # currencyCode
        $sale->dateBegin($dateBegin);
        $sale->dateEnd($dateEnd);
        $sale->formatType($format);

        # free importStatus
        $sale->isrc($isrc) if ($isrc);

        # labelName
        $sale->lineNum($linenum);

        # outlet payoutType
        $sale->price( $price / $units );

        # priceLevel priceType
        $sale->productType($prodtype);

        # retail returns returnsRevenue
        # sales salesRevenue
        $sale->serviceID($service);

        # serviceProductID totalRevenue
        $sale->trackName($track)   if ($track);
        $sale->trackNum($trackNum) if ($trackNum);
        $sale->units($units);
        $sale->upc($upc) if ($upc);
        $sale->serviceProductID($serviceProductID);

        # wholesaleRate

        if ( $serviceName =~ /Canada/ ) {
            $sale->countryCode('CA');
        } else {
            $sale->countryCode('US');
        }

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

    return $linenum;
}

#
# Private methods
#

my %month_map = (
    Jan => 1,
    Feb => 2,
    Mar => 3,
    Apr => 4,
    May => 5,
    Jun => 6,
    Jul => 7,
    Aug => 8,
    Sep => 9,
    Oct => 10,
    Nov => 11,
    Dec => 12,
);
my $MONTH = '(?:' . join( '|', sort keys %month_map ) . ')';
my $YY = qr/[0-9]{2}/;

sub _getDatesFromFileName {
    my $self  = shift;
    my $fname = shift;
    return unless ( $fname =~ m/^BN($MONTH)($YY)digital/ );

    my $month = $month_map{$1};
    my $year  = 2000 + $2;

    my $month_end = Days_in_Month( $year, $month );

    my $format    = '%4d-%02d-%02d';
    my $beginDate = sprintf( $format, $year, $month, 1 );
    my $endDate   = sprintf( $format, $year, $month, $month_end );

    return ( $beginDate, $endDate );
}

sub _getDatesFromFile {

    # This is what get's passed in:
    # fiscal period: 200804 thru: 200806

    my $self = shift;
    my $date = shift;
    return unless ( $date =~ m/^fiscal period: (\d{6}) thru: (\d{6})$/ );

    my $beginYear  = substr( $1, 0, 4 );
    my $beginMonth = substr( $1, 4, 2 );

    my $endYear  = substr( $2, 0, 4 );
    my $endMonth = substr( $2, 4, 2 );

    my $endMonthEnd = Days_in_Month( $endYear, $endMonth );

    my $format    = '%4d-%02d-%02d';
    my $beginDate = sprintf( $format, $beginYear, $beginMonth, 1 );
    my $endDate   = sprintf( $format, $endYear, $endMonth, $endMonthEnd );

    return ( $beginDate, $endDate );
}

sub _get_service_id {
    my $self        = shift;
    my $serviceName = lc shift;

    # minor adjustments to help the service name match ours
    $serviceName =~ s/ canada//;
    $serviceName =~ s/ us//;
    $serviceName =~ s/ uk//;
    $serviceName =~ s/Mix and Burn/mix_burn/i;

    return $self->getServiceID($serviceName);
}

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