package RPS::Import::PIASDigital::v3;

use strict;

use lib '/app/tools/common/lib';
use Common::Date;

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

use Data::Dumper;
use Date::Calc qw(Days_in_Month Decode_Month);

sub _headerIdentifier { ( upc => 'Barcode' ) }

sub _fieldMap {
    {
        # Header
        dateBegin        => 'F',
        currencyCode     => 'B',

        # Detail
        serviceID        => 'H',
        countryCode      => 'E',

        formatType       => 'G',
        productType      => 'F',

        artistName       => 'A',
        upc              => 'D',
        isrc             => 'C',
        albumName        => 'B',
        trackName        => 'B',
        units            => 'I',
        price            => 'O',
    }
}

sub _unverifiedFieldMap {
    {
        dms              => 'H',
    }
}

sub mediaType { RPS::DB::Item::MediaType::kMediaTypeAudio }

sub currencyCode {
    my $self = shift;
    return( $self->{_currencyCode} ) if( $self->{_currencyCode} );
    $self->fail("Unable to read currency code from header");
}

sub countryCode {
    my $self = shift;
    my $name = $self->_getByFieldName('countryCode');

    my %countryMap = (
       'kazakstan' => 'kazakhstan',
    );

    my $name = $countryMap{lc $name} || $name;

    my $o = Common::Country->Get( $name );
    if( $o )
    {
        return $o->alpha2;
    }
    $self->fail("Unrecognized country '$name'");
}

sub saleDates {
    my $self = shift;
    return ($self->{_startDate}, $self->{_endDate}) if( $self->{_startDate} ); # from header; see _preProcess
}

sub serviceID {
    my $self = shift;
    my $name = $self->_getByFieldName('serviceID');
    my $serviceID = $self->getServiceID( $name ) || $RPS::Import::ServiceMap::SERVICE_ALIASES{ lc $name };
    $serviceID = Client::Service::DSP_GROOVESHARK if( !$serviceID && $name =~ /^grooveshark\(settlement\)$/i );
    $serviceID = Client::Service::DSP_LIMEWIRE if( !$serviceID && $name =~ /^limewire\(settlement\)$/i );
    $serviceID = Client::Service::DSP_24_7_MUSICSHOP if( !$serviceID && ( $name =~ /^24\/7 MUSICSHOP/i ));

    return $serviceID if( $serviceID );
    $self->fail("Unrecognized service '$name'");
}

sub albumName  {
    my $self = shift;
    my $name = $self->_getByFieldName('albumName');
    return ( $self->productType eq RPS::File::Sale::TYPE_ALBUM ) ? $name : "";
}

sub trackName  {
    my $self = shift;
    my $name = $self->_getByFieldName('trackName');
    return ( $self->productType eq RPS::File::Sale::TYPE_TRACK ) ? $name : "";
}

sub isrc  {
    my $self = shift;
    my $isrc = $self->_getByFieldName('isrc');
    $isrc =~ s/-//g;
    return ( $self->productType eq RPS::File::Sale::TYPE_TRACK ) ? $isrc : "";
}

sub formatType  {
    my $self = shift;
    my $fmt = $self->_getByFieldName('formatType');
    my $dms = $self->_getByFieldName('dms');

    if( $fmt =~ /^a la carte download product$/i )
    {
        return RPS::File::Sale::FORMAT_DOWNLOAD;
    }
    elsif( $fmt =~ /^radio streaming product$/i ||
           $fmt =~ /^discount subsc' streaming product$/i )
    {
        return RPS::File::Sale::FORMAT_STREAM;
    }
    elsif( $fmt =~ /^settlement$/i )
    {
        if( $dms =~ /^grooveshark\(settlement\)$/i )
        {
            return RPS::File::Sale::FORMAT_STREAM;
        }
        elsif( $dms =~ /^limewire\(settlement\)$/i )
        {
            return RPS::File::Sale::FORMAT_VPD; # FB265
        }
        else
        {
            $self->fail("Unable to determine format from price category($fmt), dms($dms)");
        }
    }
    elsif( $fmt =~ /^subscr' stream prod\(teth\)$/i ||
           $fmt =~ /^subscription dl product$/i ||
           $fmt =~ /^a la carte download product$/i )
    {
        return RPS::File::Sale::FORMAT_TETHERED;
    }
    elsif( $fmt =~ /^official ad-funded streaming product$/i ||
           $fmt =~ /^subscr' streaming product$/i            ||
           $fmt =~ /^subsc' stream prod \(a\)$/i             ||
           $fmt =~ /^ugc ad-funded streaming product$/i      ||
           $fmt =~ /^cloud streaming$/i                      ||
           $fmt =~ /^breakage$/i                             ||
           $fmt =~ /^streaming$/i )
    {
        return RPS::File::Sale::FORMAT_STREAM;
    }

    $self->fail("Unable to determine format from price category($fmt)");
    
}

sub trackName {
    my $self = shift;
    my $title = $self->_getByFieldName('trackName');
    return ($self->productType eq RPS::File::Sale::TYPE_TRACK) ? $title : "";
}

sub productType {
    my $self = shift;
    my $type = $self->_getByFieldName('productType');
    if( $type =~ /^digital track$/i )
    {
        return RPS::File::Sale::TYPE_TRACK;
    }
    elsif( $type =~ /^digital (album|single)$/i )
    {
        return RPS::File::Sale::TYPE_ALBUM;
    }
    $self->fail( "Unable to determine product type from '$type'" ) if ( $type );
}

sub price {
    my $price = abs( shift->SUPER::price() );
    return $price;
}

sub units {
    my $self = shift;
    my $units = $self->SUPER::units() || return;
    my $price = $self->SUPER::price();

    if( defined($price) )
    {
        return $price < 0 ? abs($units) * -1 : $units;
    }
    else
    {
        return $units;
    }
}

sub unitPrice { abs( shift->SUPER::unitPrice ) }

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

    Log->info( "Starting _preProcess" );
    $self->SUPER::_preProcess(%args);

    foreach my $line(@{ $args{lines} }) {

        $self->{line} = $line;

        # Get the date from the header
        #
        if( !$self->{_startDate} && $self->_getByFieldName('dateBegin') =~ /for period (\w+) (\d{4})/i )
        {
            my $month = Decode_Month($1);
            my $year  = $2;

            $self->{_startDate} = sprintf( "%04d-%02d-%02d", $year, $month, 1 );
            $self->{_endDate}   = sprintf( "%04d-%02d-%02d", $year, $month, Days_in_Month($year, $month) );
        }

        # Look for the currency code information
        #
        if( !$self->{_currencyCode} && $self->_getByFieldName('artistName') =~ /currency:/i )
        {
            my $ccode = $self->_getByFieldName('currencyCode');
            if( $ccode =~ /^(\w{3})/ )
            {
                $self->{_currencyCode} = $1;
            }
        }

    }
}

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