package RPS::Import::UniversalTab;

use strict;

use Date::Calc qw(Days_in_Month);

use lib '/app/tools/common/lib';
use Common::Util qw(normalize_upc normalize_isrc);

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

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

my %FORMAT_MAP = ();
my %MEDIA_TYPE = ();

# some service names have strange variations or decoration so map them to our id's
my %service_map = (
    'apple digital sales'                 => Client::Service::DSP_ITUNES,
    'digital kiosk'                       => Client::Service::DSP_DIGITALKIOSKTECH,
    'full audio/musicnow'                 => Client::Service::DSP_MUSICNOW,
    'listen/rhapsody'                     => Client::Service::DSP_REAL,
    'virtual music stores'                => Client::Service::DSP_VIRTUALMUSICSTORE,
    'erricsson inc.'                      => Client::Service::DSP_ERICSSON,
    'you tube'                            => Client::Service::DSP_YOUTUBE,
    'musicgremlin'                        => Client::Service::DSP_MUSICGREMLIN,
    'alltel communications'               => Client::Service::DSP_ALLTEL,
    'boost mobile/nextel'                 => Client::Service::DSP_BOOST,
    'microsoft'                           => Client::Service::DSP_MICROSOFT,
    'lagardere active north ametica'      => Client::Service::DSP_LAGARDEREACTIVE,
    'lagardere active north ametica, inc' => Client::Service::DSP_LAGARDEREACTIVE,
    'mod systems'                         => Client::Service::DSP_MODSYSTEMS,
    'broadband instruments'               => Client::Service::DSP_BROADBANDINSTS,
    'planet a networks'                   => Client::Service::DSP_PLANETA,
    'teen hollywood com'                  => Client::Service::DSP_TEENHOLLYWOOD,
    'teenhollywood'                       => Client::Service::DSP_TEENHOLLYWOOD,
    'cricket communications'              => Client::Service::DSP_CRICKET,
);

# map their product types to ours
my %type_map = (
    'album'          => RPS::File::Sale::TYPE_ALBUM,
    'complete album' => RPS::File::Sale::TYPE_ALBUM,
    'track'          => RPS::File::Sale::TYPE_TRACK,
);

my %field_map = (
    2 => {
        'album' => {
            service => 0,
            format  => 1,
            type    => 2,
            upc     => 3,
            artist  => 4,
            album   => 5,
            period  => 8,
            label   => 9,

            #blank          => 10,
            price    => 11,
            units    => 12,
            extprice => 13,
        },
        'track' => {
            service => 0,
            format  => 1,
            type    => 2,
            isrc    => 3,
            upc     => 4,
            artist  => 5,
            track   => 6,
            period  => 9,
            label   => 10,

            #blank          => 11,
            #price           => 12,
            #units           => 13,
            #extprice        => 14,
            price    => 11,
            units    => 12,
            extprice => 13,
        },
    },
    3 => {    # same as above but no blank col
        'album' => {
            service  => 0,
            format   => 1,
            type     => 2,
            upc      => 3,
            artist   => 4,
            album    => 5,
            period   => 8,
            label    => 9,
            price    => 10,
            units    => 11,
            extprice => 12,
        },
        'track' => {
            service  => 0,
            format   => 1,
            type     => 2,
            isrc     => 3,
            upc      => 4,
            artist   => 5,
            track    => 6,
            period   => 9,
            label    => 10,
            price    => 11,
            units    => 12,
            extprice => 13,
        },
    },
    4 => {
        'album' => {
            service  => 0,
            format   => 1,
            type     => 2,
            upc      => 3,
            artist   => 4,
            album    => 5,
            period   => 8,
            label    => 9,
            price    => 11,
            units    => 12,
            extprice => 13,
        },
        'track' => {
            service  => 0,
            format   => 1,
            type     => 2,
            isrc     => 3,
            upc      => 4,
            artist   => 5,
            track    => 6,
            period   => 9,
            label    => 10,
            price    => 11,
            units    => 12,
            extprice => 13,
        },

    },
);

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

    my $retval     = undef;
    my $sheets     = $args{sheets};
    my $sheetNames = $args{sheet_names};
    my $version    = $self->_version();

    $self->_setup();

    my %errors = ();
    for ( my $i = 0 ; $i < @$sheets ; $i++ ) {
        my $sheet     = $sheets->[$i];
        my $sheetName = $sheetNames->[$i];
        my $offsets;
        if ( $sheetName =~ /Album/i ) {
            $offsets = $field_map{$version}{'album'};
        } elsif ( $sheetName =~ /Track/i ) {
            $offsets = $field_map{$version}{'track'};
        }
        next unless defined($offsets);

        my $linenum = 0;
        foreach my $line (@$sheet) {
            if ( $sheetName !~ /Summary/i ) {
                $linenum++;

                if ( $linenum == 1 && $sheetName =~ /Track/ && ( $version == 4 || $version == 3 ) ) {
                    my @fields = @$line;
                    foreach ( my $x = 0 ; $x < @fields ; $x++ ) {
                        $offsets->{units}    = $x if ( $fields[$x] =~ /Track Sales Units/i );
                        $offsets->{extprice} = $x if ( $fields[$x] =~ /Track Sales Revenue/i );
                    }
                }

                my $raw_type = lc( $line->[ $offsets->{'type'} ] );
                my $type     = $type_map{$raw_type};
                my $isrc     = normalize_isrc( $line->[ $offsets->{'isrc'} ] ) if exists( $offsets->{'isrc'} );
                my $upc      = normalize_upc( $line->[ $offsets->{'upc'} ] );
                my $artist   = $line->[ $offsets->{'artist'} ];
                my $album    = $line->[ $offsets->{'album'} ] if exists( $offsets->{'album'} );
                my $track    = $line->[ $offsets->{'track'} ] if exists( $offsets->{'track'} );
                my ( $dateBegin, $dateEnd ) = $self->_getDates( $line->[ $offsets->{'period'} ] );
                my $label    = $line->[ $offsets->{'label'} ];
                my $units    = $line->[ $offsets->{'units'} ];
                my $extprice = $line->[ $offsets->{'extprice'} ];
                my $price;

                if ( defined $offsets->{extprice} ) {
                    $price = $extprice / $units if ( $units != 0 );
                    $price = $extprice          if ( $units == 0 );
                }
                my $free = 0;
                $free = 1 if ( $price == 0 );

                if ( $artist && ( $album || $track ) && ( $price != 0 || $units != 0 ) && $linenum > 1 ) {
                    my $mediaType = $line->[ $offsets->{'format'} ] =~ /video/i ? $MEDIA_TYPE{video} : $MEDIA_TYPE{audio};
                    my $serviceNm = lc $line->[ $offsets->{'service'} ];
                    $serviceNm =~ s/ \(.*[^\)]\)//;
                    $serviceNm =~ s/\,?\s+(inc|llc|corp|usa)\.?$//i;
                    $serviceNm =~ s/\.com//i;
                    $serviceNm =~ s/\s+(americas|broadcasting|entertainment|networks?|solutions|technologies)$//;

                    my $serviceID = $self->getServiceID( lc($serviceNm) ) || $RPS::Import::ServiceMap::SERVICE_ALIASES{ lc $serviceNm };

                    my $format   = $self->getFormatID( $line->[ $offsets->{'format'} ] );
                    my $raw_type = lc( $line->[ $offsets->{'type'} ] );
                    my $type     = $type_map{$raw_type};
                    my $isrc     = normalize_isrc( $line->[ $offsets->{'isrc'} ] ) if exists( $offsets->{'isrc'} );
                    my $upc      = normalize_upc( $line->[ $offsets->{'upc'} ] );
                    if ( !$serviceID ) {
                        $serviceID = $service_map{$serviceNm};
                    }
                    if ( !$serviceID ) {
                        my $service = $line->[ $offsets->{'service'} ];
                        if ( !$errors{$service} ) {
                            $self->warning();
                            print STDERR "unknown service: l:" . $linenum . " s:" . $service . "\n";
                            $errors{$service} = 1;
                        }
                    }

                    if ( !$format ) {
                        $self->errstr("unknown format");
                        print STDERR "unknown format: l: " . $linenum . " |->" . $line->[ $offsets->{format} ] . "<-|\n";
                        return undef;
                    }

                    if ( $sheetName =~ /album/i ) {
                        $type = RPS::File::Sale::TYPE_ALBUM;
                    } elsif ( $sheetName =~ /track/i ) {
                        $type = RPS::File::Sale::TYPE_TRACK;
                    }

                    if ( !( $dateBegin || $dateEnd ) ) {
                        $self->errstr("can't get dates");
                        print STDERR "invalid dates: $line->[$offsets->{period}]\n";
                        return undef;
                    }

                    my $has_no_sale = 0;
                    if ( $units == 0 && $price != 0 ) {
                        $has_no_sale = 1;
                        $units = ( $price < 0 ) ? -1 : 1;
                    }
                    $price *= -1 if ( $price < 0 && $units < 0 );

                    my $sale = RPS::Import::SaleRec->new();
                    $sale->serviceID($serviceID);
                    $sale->productType($type);
                    $sale->formatType($format);
                    $sale->dateBegin($dateBegin);
                    $sale->dateEnd($dateEnd);
                    $sale->upc($upc);
                    $sale->isrc($isrc);
                    $sale->labelName($label);
                    $sale->artistName($artist);
                    $sale->albumName($album);
                    $sale->trackName($track);
                    $sale->units($units);
                    $sale->price($price);
                    $sale->free($free);
                    $sale->lineNum($linenum);
                    $sale->countryCode('US');
                    $sale->mediaType($mediaType) unless $self->is_wmg;

                    $self->_insertSale( sale => $sale );

                    if ( $has_no_sale > 0 ) {
                        my $sale = RPS::Import::SaleRec->new();
                        $sale->serviceID($serviceID);
                        $sale->productType($type);
                        $sale->formatType($format);
                        $sale->dateBegin($dateBegin);
                        $sale->dateEnd($dateEnd);
                        $sale->upc($upc);
                        $sale->isrc($isrc);
                        $sale->labelName($label);
                        $sale->artistName($artist);
                        $sale->albumName($album);
                        $sale->trackName($track);
                        $sale->free($free);
                        $sale->lineNum($linenum);
                        $sale->mediaType($mediaType) unless $self->is_wmg;
                        $sale->units(-1) if ( $units == 1 );
                        $sale->units(1)  if ( $units == -1 );
                        $sale->price(0);
                        $sale->countryCode('US');
                        $self->_insertSale( sale => $sale );
                    }
                }

                #else { print STDERR "skip sn:".$sheetName." l: $linenum r: $artist (a: $album or t: $track) u: $units p: $price\n"; }
            }
        }
    }

    return 1;
}

#
# Private methods
#

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

    my $dateBegin;
    my $dateEnd;

    my ( $month, $year ) = $period =~ m/^UMG P(\d\d?) (\d\d) /i;

    if ( $month && $year ) {
        $year += 2000;

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

    return ( $dateBegin, $dateEnd );
}

=stop
sub getServiceID
{
    my $self = shift;
    my $serviceName = lc shift;

    # strip useless decoration
    $serviceName =~ s/\,?\s+(inc|llc|corp|usa)\.?$//i;
    $serviceName =~ s/\s+(americas|broadcasting|entertainment|networks?|solutions|technologies)$//;
    return $self->SUPER::getServiceID($serviceName) || $service_map{$serviceName};

}
=cut

sub getFormatID {
    my $self   = shift;
    my $format = lc shift;
    $format =~ s/\s\(.*[^\)]\)//;

    if ( $self->{clientID} == RPS::Import::Importer::WMG ) {
        return RPS::Import::WMG::Util::getWirelessFormatTypeID($format) || $FORMAT_MAP{$format};
    }

    # else
    return $FORMAT_MAP{$format};
}

sub _setup {
    my $self = shift;

    # some format names have strange variations or decoration
    %FORMAT_MAP = (
        'ad supported streams' => RPS::File::Sale::FORMAT_STREAM,
        'kiosk'                => RPS::File::Sale::FORMAT_DOWNLOAD,

        #'ota permanent downloads'           => RPS::File::Sale::FORMAT_DOWNLOAD,
        'permanent downloads'            => RPS::File::Sale::FORMAT_DOWNLOAD,
        'portable sub client plays'      => RPS::File::Sale::FORMAT_TETHERED,
        'portable sub device plays'      => RPS::File::Sale::FORMAT_TETHERED,
        'portable sub streams'           => RPS::File::Sale::FORMAT_STREAM,
        'programmed streaming'           => RPS::File::Sale::FORMAT_STREAM,
        'subscription mastertones'       => RPS::File::Sale::FORMAT_RINGTONE,
        'streams'                        => RPS::File::Sale::FORMAT_STREAM,
        'tethered/conditional downloads' => RPS::File::Sale::FORMAT_TETHERED,
        'standard mobile ringsounds'     => RPS::File::Sale::FORMAT_RINGTONE,
        'ota permanent downloads'        => RPS::File::Sale::FORMAT_RINGTONE,
    );

    # map the rest based on WMG or non-WMG
    if ( $self->is_wmg ) {
        require RPS::Import::WMG::Util;
        $FORMAT_MAP{'standard mobile ringsounds'} = RPS::File::Sale::FORMAT_RINGTONE,

          # the rest are handled by getWirelessFormatTypeID in Util
    } else {
        $FORMAT_MAP{'video downloads'}              = RPS::File::Sale::FORMAT_DOWNLOAD,    # was FORMAT_VIDEO (FB1324)
          $FORMAT_MAP{'video streams'}              = RPS::File::Sale::FORMAT_STREAM,      # was FORMAT_VIDEOSTREAM (FB1324)
                                                                                           # force all mobile types to ringtone
          $FORMAT_MAP{'mastertones'}                = RPS::File::Sale::FORMAT_RINGTONE,
          $FORMAT_MAP{'mobile images'}              = RPS::File::Sale::FORMAT_RINGTONE,
          $FORMAT_MAP{'mobile video streaming'}     = RPS::File::Sale::FORMAT_RINGTONE,
          $FORMAT_MAP{'ota video downloads'}        = RPS::File::Sale::FORMAT_RINGTONE,
          $FORMAT_MAP{'polyphonic ringtones'}       = RPS::File::Sale::FORMAT_RINGTONE,
          $FORMAT_MAP{'ringbacks'}                  = RPS::File::Sale::FORMAT_RINGTONE,
          $FORMAT_MAP{'standard mobile ringsounds'} = RPS::File::Sale::FORMAT_RINGTONE,

          eval {
            use lib '/app/tools/rps/lib';
            require RPS::DB::Item::MediaType;

            %MEDIA_TYPE = (
                video => RPS::DB::Item::MediaType::kMediaTypeVideo(),
                audio => RPS::DB::Item::MediaType::kMediaTypeAudio(),
            );
          };

    }
}

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