package RPS::Import::ADA::v12;

use strict;

use lib '/app/tools/common/lib';
use Common::Util qw(normalize_date normalize_upc);
use Date::Calc qw(Days_in_Month Decode_Month);
use Data::Dumper;

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

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

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

# non-standard _fieldMap; need to override _importLines
sub _fieldMap {
    {
        'domestic' => {
            label       => 28,    # AC
            serviceName => 2,     # C
            dateBegin   => 3,     # D
            dateEnd     => 4,     # E
            productType => 17,    # R
            formatType  => 41,    # AP
            artistName  => 7,     # H
            upc         => 20,    # U
            albumName   => 22,    # W
            isrc        => 18,    # S
            trackName   => 9,     # J
            units       => 10,    # K
            price       => 15,    # P
            mediaType   => 17,    # R
            mediaCode   => 41,    # AP
            streamFlag  => 44,    # AS
        },
        'international' => {
            label       => 0,     # A
            serviceName => 5,     # F
            countryCode => 7,     # H

            productType => 9,     # J
            formatType  => 9,     # J
            mediaType   => 9,     # J

            artistName => 1,      # B

            albumName => 2,       # C
            trackName => 2,       # C

            isrc => 3,            # D
            upc  => 3,            # D

            units => 11,          # L
            price => 12,          # M
        },
    };
}

my %mediaCodeMap = (
    'DRMUPGR' => {
        format_type => RPS::File::Sale::FORMAT_DOWNLOADUPGRADE,
        media_type  => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
    'DUALDIST' => {
        format_type => RPS::File::Sale::FORMAT_DUALDOWNLOAD,
        media_type  => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
    'PERMDWNL' => {
        format_type => RPS::File::Sale::FORMAT_DOWNLOAD,
        media_type  => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
    'PERMVDLD' => {
        format_type => RPS::File::Sale::FORMAT_DOWNLOAD,
        media_type  => RPS::DB::Item::MediaType::kMediaTypeVideo,
    },
    'SUBAICLD' => {
        format_type => RPS::File::Sale::FORMAT_STREAM,
        media_type  => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
    'SUBASONE' => {
        format_type => RPS::File::Sale::FORMAT_STREAM,
        media_type  => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
    'SUBASPPE' => {
        format_type => RPS::File::Sale::FORMAT_STREAM,
        media_type  => RPS::DB::Item::MediaType::kMediaTypeVideo,
    },
    'SUBVICLD' => {
        format_type => RPS::File::Sale::FORMAT_STREAM,
        media_type  => RPS::DB::Item::MediaType::kMediaTypeVideo,
    },
    'SUBVSONE' => {
        format_type => RPS::File::Sale::FORMAT_STREAM,
        media_type  => RPS::DB::Item::MediaType::kMediaTypeVideo,
    },
    'SUBVSPPE' => {
        format_type => RPS::File::Sale::FORMAT_STREAM,
        media_type  => RPS::DB::Item::MediaType::kMediaTypeVideo,
    },
    'UGMV' => {
        format_type => RPS::File::Sale::FORMAT_STREAM,
        media_type  => RPS::DB::Item::MediaType::kMediaTypeVideo,
    },
    'UGRWRMST' => {
        format_type => RPS::File::Sale::FORMAT_RINGTONE,
        media_type  => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
    'UGV' => {
        format_type => RPS::File::Sale::FORMAT_STREAM,
        media_type  => RPS::DB::Item::MediaType::kMediaTypeVideo,
    },
    'WRMST' => {
        format_type => RPS::File::Sale::FORMAT_RINGTONE,
        media_type  => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
    'WRRNGBK' => {
        format_type => RPS::File::Sale::FORMAT_RINGTONE,
        media_type  => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
    'WRSTREAM' => {
        format_type => RPS::File::Sale::FORMAT_STREAM,
        media_type  => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
);

# International delivery format mappings
#
my %deliveryFormatMap = (
    'EMASTERTONE' => {
        format_type  => RPS::File::Sale::FORMAT_RINGTONE,
        media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        product_type => RPS::File::Sale::TYPE_TRACK,
    },
    'EMDALBUM' => {
        format_type  => RPS::File::Sale::FORMAT_DOWNLOAD,
        media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        product_type => RPS::File::Sale::TYPE_ALBUM,
    },
    'EMDALBUMSTREAMING' => {
        format_type  => RPS::File::Sale::FORMAT_STREAM,
        media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        product_type => RPS::File::Sale::TYPE_ALBUM,
    },
    'EMDTRACK' => {
        format_type  => RPS::File::Sale::FORMAT_DOWNLOAD,
        media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        product_type => RPS::File::Sale::TYPE_TRACK,
    },
    'EMDTRACKSTREAMING' => {
        format_type  => RPS::File::Sale::FORMAT_STREAM,
        media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        product_type => RPS::File::Sale::TYPE_TRACK,
    },
    'ERINGBACK' => {
        format_type  => RPS::File::Sale::FORMAT_RINGTONE,
        media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        product_type => RPS::File::Sale::TYPE_TRACK,
    },
    'EVD' => {
        format_type  => RPS::File::Sale::FORMAT_DOWNLOAD,
        media_type   => RPS::DB::Item::MediaType::kMediaTypeVideo,
        product_type => RPS::File::Sale::TYPE_TRACK,
    },
    'EVDSTREAMING' => {
        format_type  => RPS::File::Sale::FORMAT_STREAM,
        media_type   => RPS::DB::Item::MediaType::kMediaTypeVideo,
        product_type => RPS::File::Sale::TYPE_TRACK,
    },
);

sub _importLines {
    my $self     = shift;
    my %args     = @_;
    my $fileObj  = $args{file};
    my $version  = $args{file}->VersionNum();
    my $fileName = $args{file}->OrigFileName();

    my $offsets = $self->_fieldMap;

    my $sheet_count = 0;
    my ( $linenum, $serviceID );

    return undef unless ( defined $args{sheets} && defined $version );

    my $sheet_names = $args{sheet_names};

    my $currencyCode = 'USD';

    foreach my $sheet ( @{ $args{sheets} } ) {

        my $sheetName = $sheet_names->[$sheet_count];

        my $sheetIndex = $self->_normalizeSheetName( lc $sheetName );

        if ( !exists $offsets->{$sheetIndex} ) {
            print STDERR "ADABase: Illegal sheet '$sheetName'\n";
            $self->errstr("Sheet '$sheetName' is not valid");
            return undef;
        }

        my $data = $offsets->{$sheetIndex};

        my ( $gDateBegin, $gDateEnd );
        if ( !defined $data->{dateBegin} ) {
            ( $gDateBegin, $gDateEnd ) = $self->_getDatesFromFileName($fileName);
        }

        $linenum = 1;
        foreach my $line ( @{$sheet} ) {

            my $sn       = $sheet_count + 1;             # sheet number (1-based)
            my $lineInfo = "Sheet $sn, line $linenum";

            my $serviceName = $line->[ $data->{serviceName} ];

            # Skipping header
            #
            if (   !$serviceName
                || ( $serviceName && '' eq $serviceName )
                || ( $serviceName && ( 'vendor' eq lc($serviceName) ) )
                || ( $serviceName && ( 'provider' eq lc($serviceName) ) ) ) {
                $linenum++;
                next;
            }

            my $countryCode;
            if ( defined $data->{countryCode} ) {
                $countryCode = $line->[ $data->{countryCode} ];
            } else {
                $countryCode = 'US';
            }

            my $productType;
            my $formatType;
            my $mediaType;

            if ( defined $data->{mediaCode} ) {

                # Domestic Sales
                #
                my $mediaCode = $line->[ $data->{mediaCode} ];
                if ($mediaCode) {
                    $formatType = $mediaCodeMap{ uc $mediaCode }->{format_type};
                    $mediaType  = $mediaCodeMap{ uc $mediaCode }->{media_type};

                    if ( !$formatType && !$mediaType ) {
                        $self->errstr("$lineInfo: Unknown media code '$mediaCode'");
                        return undef;
                    }
                } else {
                    $self->errstr("$lineInfo: Media Code not found");
                    return undef;
                }

                my $_productType = uc $line->[ $data->{productType} ];

                if ( $_productType eq 'D' || $_productType eq 'P' || $_productType eq 'T' || $_productType eq 'S' ) {
                    $productType = RPS::File::Sale::TYPE_TRACK;
                } elsif ( $_productType eq 'A' ) {
                    $productType = RPS::File::Sale::TYPE_ALBUM;
                } else {
                    $self->errstr("$lineInfo: Unknown product type '$_productType'");
                    return undef;
                }

            } else {

                # International Sales
                #
                my $deliveryFormat = $line->[ $data->{productType} ];

                $formatType  = $deliveryFormatMap{ uc $deliveryFormat }->{format_type};
                $mediaType   = $deliveryFormatMap{ uc $deliveryFormat }->{media_type};
                $productType = $deliveryFormatMap{ uc $deliveryFormat }->{product_type};

                if ( !$productType ) {
                    $self->errstr("$lineInfo: Unknown product type '$deliveryFormat'");
                    return undef;
                }

            }

            my $trackName;
            my $albumName;
            my $isrc;
            my $upc;

            if ( $productType eq RPS::File::Sale::TYPE_TRACK ) {
                $isrc = $line->[ $data->{isrc} ] if ( defined $data->{isrc} );
                $trackName = $line->[ $data->{trackName} ];

                # On the domestic sheet, album name is always included.
                #
                if ( $sheetIndex eq 'domestic' ) {
                    $albumName = $line->[ $data->{albumName} ];
                }
            } elsif ( $productType eq RPS::File::Sale::TYPE_ALBUM ) {
                $albumName = $line->[ $data->{albumName} ];
                $upc = $line->[ $data->{upc} ] if ( defined $data->{upc} );
            }

            my $artistName = $line->[ $data->{artistName} ];
            my $units      = $line->[ $data->{units} ];
            my $price      = $line->[ $data->{price} ];
            my $label      = $line->[ $data->{label} ];

            my ( $dateBegin, $dateEnd );
            if ( defined $data->{dateBegin} ) {
                my $saleDateBegin = _normalizeDate( $line->[ $data->{dateBegin} ] );
                ( $dateBegin, $dateEnd ) = $self->_getDates( date_begin => $saleDateBegin );
            } else {
                ( $dateBegin, $dateEnd ) = ( $gDateBegin, $gDateEnd );
            }

            if ( $units && $units < 0 && $price && $price > 0 ) {
                $self->errstr("$lineInfo: Negative units with revenue");
                return undef;
            }

            if ( !$units && $price && $price < 0 ) {

                # We're just going to skip this line if it has negative revenue and no units.
                $linenum++;
                next;
            }

            if ( $units != 0 ) {
                $price /= ( $units * -1 ) if ( $units < 0 );
                $price /= $units if ( $units > 0 );
                if ( $price < 0 ) {
                    if ( $units > 0 ) {
                        $units *= -1;
                    }
                    $price *= -1;
                }
            }

            if ( defined $data->{serviceName} ) {
                $serviceID = $self->getServiceID( lc($serviceName) ) || $RPS::Import::ServiceMap::SERVICE_ALIASES{ lc $serviceName };

                if ( !$serviceID ) {

                    # Trying to get the Korean names to match up...
                    my $serviceNameCopy = $serviceName;
                    $serviceNameCopy =~ s/(.|\n)/sprintf("%02lx", ord $1)/eg;
                    $serviceID = $RPS::Import::ServiceMap::SERVICE_ALIASES{ lc $serviceNameCopy };
                }
            }

            if ( $productType && $artistName && lc($artistName) ne "artist" && ( $albumName || $trackName ) ) {
                if ( defined $data->{serviceName} ) {
                    unless ($serviceID) {

                        if ( $serviceName =~ /[[:^ascii:]]/ ) {

                            # Case 15436 - defaulting service names with incompatible characters to ADA
                            $serviceID = Client::Service::DSP_ADA;
                        } else {
                            $self->errstr( "$lineInfo: Couldn't find service ID for: " . $serviceName );
                            return undef;
                        }
                    }
                }

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

                $sale->productType($productType);
                $sale->formatType($formatType);
                $sale->dateBegin($dateBegin);
                $sale->dateEnd($dateEnd);
                $sale->labelName($label) if ( defined $data->{label} && $label ne "" );
                $sale->albumName($albumName);
                $sale->trackName($trackName);
                $sale->isrc( Common::Util::normalize_isrc($isrc) ) if ($isrc);
                $sale->upc( Common::Util::normalize_upc($upc) )    if ($upc);
                $sale->serviceID($serviceID)                       if ($serviceName);
                $sale->artistName($artistName);
                $sale->units($units);
                $sale->price($price);
                $sale->countryCode($countryCode);
                $sale->currencyCode($currencyCode);
                $sale->mediaType($mediaType);
                $sale->lineNum($linenum);

                my $free = $price == 0 ? 1 : 0;
                $sale->free($free);

                $self->_insertSale( sale => $sale );
            } else {
                print STDERR "skip s: $sheetIndex l:"
                  . $linenum . " a:"
                  . $artistName . " t:"
                  . $albumName . " u:"
                  . $units . " p:"
                  . $price . "\n";
            }
            $linenum++;
        }
        $sheet_count++;
    }

    return $linenum;
}

sub _normalizeSheetName {
    my $self  = shift;
    my $sname = shift;
    my $name;

    $name = $sname;
    if ( $sname =~ /domestic digital/i ) {
        $name = "domestic";
    } elsif ( $sname =~ /int\'l digital/i ) {
        $name = "international";
    }

    return $name;
}

sub _normalizeDate {
    my ($dt) = @_;
    my $date = $dt;
    if ( $dt =~ m/^\d{5}$/ ) {
        $date = Spreadsheet::ParseExcel::Utility::ExcelFmt( "yyyy-mm-dd", $dt );
    }
    return $date;
}

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

    my ( $dateBegin, $dateEnd, $month, $year );

    if ( $date =~ m/(january|february|march|april|may|june|july|august|september|october|november|december)_(\d{4})\./i ) {
        $month = Decode_Month($1);
        $year  = $2;

        #print STDERR "DEBUG: _getDatesFromFileName: fmonth($1) month($month) year($year)\n";
        $dateBegin = sprintf( "%04d-%02d-%02d", $year, $month, 1 );
        $dateEnd = sprintf( "%04d-%02d-%02d", $year, $month, Days_in_Month( $year, $month ) );
    } elsif ( $date =~ m/(\w*)\s*(\d{4})\./ ) {

        $month = Decode_Month($1);
        $year  = $2;

        $dateBegin = sprintf( "%04d-%02d-%02d", $year, $month, 1 );
        $dateEnd = sprintf( "%04d-%02d-%02d", $year, $month, Days_in_Month( $year, $month ) );
    } else {
        return undef;
    }

    return ( $dateBegin, $dateEnd );
}

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