package RPS::Import::JamsterWireless;

use strict;

use Date::Calc qw(Decode_Month Days_in_Month);

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 = (
    4 => {
        year_row  => 3,
        year_col  => 1,
        month_row => 4,
        month_col => 1,
        prod_id   => 0,
        artist    => 1,
        track     => 2,
        format    => 3,
        units     => 5,
        retail    => 6,
        ppd_rate  => 7,
        price     => 9,
    },
);

#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

    if ( $self->{clientID} == RPS::Import::Importer::WMG )    # warner
    {
        # check for warner specific stuff
        require RPS::Import::WMG::Util;

        my @billTo = RPS::Import::WMG::Util::getWirelessBillto( $self->{fileServiceID} );
        if ( $billTo[0] ) {
            unless ( RPS::Import::WMG::Util::getWirelessSellto( $self->{fileServiceID}, $billTo[0] ) ) {
                $self->warning();
                print STDERR "unknown sellto mapping: $billTo[0]\n";
            }
        } else {
            $self->warning();
            print STDERR "unknown billto mapping: $self->{fileServiceID}\n";
        }

        $fileObj->Atomic(1);
        $fileObj->Save();
    }

    my $offsets = $field_map{$version};

    return 0 unless ($lines);

    my ( $dateBegin, $dateEnd ) = $self->_getDates( $lines->[ $offsets->{month_row} ]->[ $offsets->{month_col} ],
        $lines->[ $offsets->{year_row} ]->[ $offsets->{year_col} ] );
    unless ( $dateBegin && $dateEnd ) {
        $self->errstr("couldn't get dates");
        print STDERR "date cell: "
          . $lines->[ $offsets->{month_row} ]->[ $offsets->{month_col} ] . " "
          . $lines->[ $offsets->{year_row} ]->[ $offsets->{year_col} ] . "\n";
        return undef;
    }

    my %errors  = ();
    my $linenum = 1;    ## starting off after header

    foreach my $line (@$lines) {
        my $priceType = '';
        my $prodtype  = RPS::File::Sale::TYPE_TRACK;

        my $prodID    = $line->[ $offsets->{prod_id} ];
        my $artist    = $line->[ $offsets->{artist} ];
        my $track     = $line->[ $offsets->{track} ];
        my ($units)   = $line->[ $offsets->{units} ] =~ /^(\d+)$/;
        my $price     = $line->[ $offsets->{price} ];
        my $retail    = $line->[ $offsets->{retail} ];
        my ($ppdRate) = $line->[ $offsets->{ppd_rate} ] =~ /^(\d+\.\d+)$/;

        if ( $units && $price && $artist && $track ) {

            my $format;
            my $mediaType = RPS::DB::Item::MediaType::kMediaTypeAudio;

            my $fmt = $line->[ $offsets->{format} ];
            if ( $self->{clientID} == RPS::Import::Importer::WMG )    # warner
            {
                if ( $track =~ m/voice\s*ringer/i && $fmt !~ m/sms/i ) {
                    $fmt = "voiceringer";
                } elsif ( $track =~ m/sms.tone/i ) {
                    $fmt = "smstone";
                }

                unless ( $priceType = RPS::Import::WMG::Util::getWirelessPriceType($fmt) ) {
                    $self->warning();
                    print STDERR "unknown format mapping: $fmt ($linenum)\n" unless ( $errors{$fmt} );
                    $errors{$fmt} = 1;
                }
                $format = RPS::Import::WMG::Util::getWirelessFormatTypeID($fmt);
            } else {
                if ( $fmt =~ /video ringtone/i ) {
                    $format    = RPS::File::Sale::FORMAT_RINGTONE;            # was FORMAT_VIDEORINGER (FB1324)
                    $mediaType = RPS::DB::Item::MediaType::kMediaTypeAudio;
                } elsif ( $fmt =~ /ringtone/i ) {
                    $format    = RPS::File::Sale::FORMAT_RINGTONE;            # was FORMAT_MASTERTONE (FB1324)
                    $mediaType = RPS::DB::Item::MediaType::kMediaTypeVideo;
                }
            }
            unless ($format) {
                print STDERR "unknown format: $line->[$offsets->{format}]\n" unless ( $errors{$fmt} );
                $errors{$fmt} = 1;
            }

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

            $sale->productType($prodtype);
            $sale->formatType($format);
            $sale->mediaType($mediaType);
            $sale->dateBegin($dateBegin);
            $sale->dateEnd($dateEnd);
            $sale->clientProductID($prodID);
            $sale->artistName($artist);
            $sale->trackName($track);
            $sale->units($units);
            $sale->price($price);
            $sale->wholesaleRate($ppdRate);
            $sale->retail($retail);
            $sale->priceType($priceType);
            $sale->lineNum($linenum);

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

        #else { print STDERR "skip: u: $units p: $price a: $artist t: $track ($linenum)\n"; }
        $linenum++;
    }

    $self->warning() if ( keys %errors );
    return $linenum;
}

#
# Private methods
#

sub _getDates {
    my $self  = shift;
    my $month = Decode_Month(shift);
    my $year  = shift;

    return ( sprintf( "%d-%02d-01", $year, $month ), sprintf( "%d-%02d-%d", $year, $month, Days_in_Month( $year, $month ) ) );
}

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