package RPS::Import::Liberator::v1;

use strict;
use warnings;

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

use parent 'RPS::Import::ImporterMixed';

sub physical { 2 }

sub _fieldMapExtended {
    {
        mixed => {
            option1 => {
                serviceID       => 'J',
                countryCode     => 'K',
                dateBegin       => 'I',
                dateEnd         => 'I',
                formatType      => 'L',
                clientProductID => 'M',
                artistName      => 'N',
                upc             => 'M',
                albumName       => 'O',
                isrc            => 'M',
                trackName       => 'O',
                units           => 'Q',
                totalRevenue    => 'S',
                price           => 'S',
            },
        },
    };
}

sub _unverifiedFieldMapExtended {
    {
        mixed => {
            option1 => {
                productTypePhys => 'L',
                productTypeDig  => 'M',
                netUnits        => 'Q',
            },
        }
    };
}

sub _headerIdentifierExtended {
    {
        mixed => {
            option1 => { upc => 'PRODUCT USERCODE' }
        },
    };
}

sub currencyCode { 'AUD' }
sub channel      { RPS::File::Sale::CHANNEL_RETAIL }
sub priceLevel   { RPS::File::Sale::PLEVEL_UNKNOWN }

sub serviceID {
    my $self = shift;

    my $service = lc( $self->_getByFieldName('serviceID') || '' );

    return Client::Service::DSP_APPLE_MUSIC if $service =~ /^Apple$/i;
    return Client::Service::DSP_LIBERATOR   if $service =~ /^Flat Fee Income$/i;
    return Client::Service::DSP_LIBERATOR   if $service =~ /^Digital Music Distribution$/i;

    my $serviceID = $self->getServiceID($service) || $RPS::Import::ServiceMap::SERVICE_ALIASES{$service};
    return $serviceID if $serviceID;

    $self->fail("Unknown service: $service");
}

sub countryCode {
    my $self = shift;

    my $name = $self->_getByFieldName('countryCode');
    my $oCountry = Common::Country->Get($name);
    return $oCountry->alpha2() if $oCountry;

    $self->fail("Unknown country: $name");
}

sub dateBegin {
    my $self = shift;

    my $dateBegin = $self->_getDateBegin();
    return ($dateBegin) = $dateBegin =~ s/\//-/g;
}

sub dateEnd { shift->dateBegin }

sub productType {
    my $self = shift;

    my $type = $self->_getByFieldName('productTypePhys') || '';
    $type =~ s/^[\s-]*|[\s-]*$//g;
    return RPS::File::Sale::TYPE_CD if $type =~ /^Physical$/i;

    $type = $self->_getByFieldName('productTypeDig') || '';
    $type =~ s/^[\s-]*|[\s-]*$//g;
    return length $type == 12
        ? RPS::File::Sale::TYPE_TRACK
        : RPS::File::Sale::TYPE_ALBUM;

    $self->fail( "Unable to determine product type: $type" );
}

sub formatType {
    my $self = shift;

    my $type = $self->_getByFieldName('formatType') || '';
    return RPS::File::Sale::FORMAT_DOWNLOAD    if $type =~ /^Downloads$/i;
    return RPS::File::Sale::FORMAT_PERFORMANCE if $type =~ /^Public Performance$/i;
    return RPS::File::Sale::FORMAT_STREAM      if $type =~ /^Streaming$/i;

    $self->fail( "Unable to determine format type: $type" );
}

sub clientProductID {
    return ( grep { $_[0]->productType eq $_ } RPS::File::Sale::TYPE_CD, RPS::File::Sale::TYPE_ALBUM )
        ? $_[0]->_getByFieldName('clientProductID') : undef;
}

sub upc {
    return $_[0]->productType eq RPS::File::Sale::TYPE_ALBUM
        ? $_[0]->_getByFieldName('upc') : undef;
}

sub isrc {
    return $_[0]->productType eq RPS::File::Sale::TYPE_TRACK
        ? $_[0]->_getByFieldName('isrc') : undef;
}

sub albumName {
    return ( grep { $_[0]->productType eq $_ } RPS::File::Sale::TYPE_CD, RPS::File::Sale::TYPE_ALBUM )
        ? $_[0]->_getByFieldName('albumName') : undef;
}

sub trackName {
    return $_[0]->productType eq RPS::File::Sale::TYPE_TRACK
        ? $_[0]->_getByFieldName('trackName') : undef;
}

sub price     { abs( shift->_getByFieldName('price') || 0 ) }
sub unitPrice { abs shift->SUPER::unitPrice }
sub units {
    my $self = shift;

    my $units = $self->_getByFieldName('units') || 0;
    my $price = $self->_getByFieldName('price') || 0;
    return $price < 0 ? abs($units) * -1 : $units;
}

# physical
sub netUnits       { shift->_getByFieldName('netUnits')     || 0 }
sub totalRevenue   { shift->_getByFieldName('totalRevenue') || 0 }
sub sales          { $_[0]->netUnits > 0     ? $_[0]->netUnits         : 0 }
sub salesRevenue   { $_[0]->totalRevenue > 0 ? $_[0]->totalRevenue     : 0 }
sub returns        { $_[0]->netUnits < 0     ? abs $_[0]->netUnits     : 0 }
sub returnsRevenue { $_[0]->totalRevenue < 0 ? abs $_[0]->totalRevenue : 0 }
sub _isValidSaleRecord {
    my $self = shift;

    return ( $self->_getByFieldName('trackName') || $self->_getByFieldName('albumName') )
           && defined $self->netUnits
}

1;