package RPS::Import::Sony::v51;

use strict;
use warnings;

use lib '/app/tools/rps/lib';
use Date::Calc qw(Days_in_Month Add_Delta_Days Decode_Month);

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

sub physical { 0 }

sub _fieldMapExtended {
    {
        digital => {
            option1 => {
                serviceID        => 'AB',
                countryCode      => 'AA',
                dateBegin        => 'H',
                dateEnd          => 'I',
                productType      => 'P',
                formatType       => 'Y',
                serviceProductID => 'J',
                artistName       => 'M',
                albumName        => 'K',
                isrc             => 'S',
                trackName        => 'T',
                units            => 'AJ',
                currencyCode     => 'G',
                price            => 'AM',
                mediaType        => 'R',
            },
         },
    };
}

sub _unverifiedFieldMapExtended { {} }

sub _headerIdentifierExtended {
    {
        digital => {
            option1 => {
                price => 'Total Payable',
            },
        },
    };
}

my %formatMap = (
    'digital ad supported streaming'                 => RPS::File::Sale::FORMAT_STREAM,
    'digital breakage streaming ad supported'        => RPS::File::Sale::FORMAT_STREAM,
    'digital breakage streaming paid'                => RPS::File::Sale::FORMAT_STREAM,
    'digital broadcast ephemeral'                    => RPS::File::Sale::FORMAT_EPHEMERAL,
    'digital download conditional'                   => RPS::File::Sale::FORMAT_TETHERED,
    'digital downloads permanent'                    => RPS::File::Sale::FORMAT_DOWNLOAD,
    'digital locker downloads'                       => RPS::File::Sale::FORMAT_DOWNLOAD,
    'digital metadata'                               => RPS::File::Sale::FORMAT_STREAM,
    'digital paid subscription streaming'            => RPS::File::Sale::FORMAT_STREAM,
    'digital settlement ad supported streaming'      => RPS::File::Sale::FORMAT_STREAM,
    'digital settlement paid subscription streaming' => RPS::File::Sale::FORMAT_STREAM,
);

sub dateBegin {
    my $self = shift;

    my $date = $self->_getByFieldName('dateBegin') || '';
    # YYYYMMDD
    if ( $date =~ /(\d{4})(\d{2})(\d{2})/ ) {
        return sprintf "%04d-%02d-%02d", $1, $2, $3;
    }

    $self->fail("Unable to determine dateBegin from: '$date'");
}

sub dateEnd {
    my $self = shift;

    my $date = $self->_getByFieldName('dateEnd') || '';
    # YYYYMMDD
    if ( $date =~ /(\d{4})(\d{2})(\d{2})/ ) {
        return sprintf "%04d-%02d-%02d", $1, $2, $3;
    }

    $self->fail("Unable to determine dateEnd from: '$date'");
}

sub serviceID {
    my $self = shift;

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

    return $self->handleError("Unable to determine serviceID from: '$service'.", RPS::DB::Item::SaleImportError::kErrorService );
}

sub countryCode {
    my $self = shift;

    my $name = $self->_getByFieldName('countryCode') || '';
    $name =~ s/^\s+|\s+$//g;

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

    $self->handleError("Unable to determine countryCode from: '$name'.", RPS::DB::Item::SaleImportError::kErrorCountry );
    return $name;
}

sub productType {
    my $self = shift;

    my $type = $self->_getByFieldName('productType') || '';
    return RPS::File::Sale::TYPE_TRACK if $type =~ /^track$/i;
    return RPS::File::Sale::TYPE_ALBUM if $type =~ /^album$/i;

    return $self->handleError( "Unable to determine productType from: '$type'.", RPS::DB::Item::SaleImportError::kErrorProductType );
}

sub formatType {
    my $self = shift;

    my $type = lc( $self->_getByFieldName('formatType') || '' );
    return $formatMap{$type} if exists $formatMap{$type};

    return $self->handleError( "Unable to determine formatType from: '$type'.", RPS::DB::Item::SaleImportError::kErrorFormatType);
}

sub mediaType {
    my $self = shift;

    my $type = $self->_getByFieldName('mediaType') || '';
    return RPS::DB::Item::MediaType::kMediaTypeAudio if $type =~ /^Digital Audio (?:Track|Longplay)$/i;

    return $self->handleError( "Unable to determine mediaType from: '$type'.", RPS::DB::Item::SaleImportError::kErrorMediaType);
}

# digital
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;

    if ( $price > 0 ) {
        $units = $units ? abs($units) : 1;
    } elsif ( $price < 0 ) {
       $units = $units ? -1 * abs($units) : -1;
    }

    return $units;
}

sub _isValidSaleRecord {
    my $self = shift;

    if ( !$self->_getByFieldName('trackName') && !$self->_getByFieldName('albumName') ) {
        $self->fail("The track name or album name is not filled in.");
    }

    return $self->units || $self->revenue;
}

# mapFace
sub _mapFaceServiceID   { 'serviceID' }
sub _mapFaceCountryCode { 'countryCode' }
sub _mapFaceProductType { 'productType' }
sub _mapFaceFormatType  { 'formatType' }
sub _mapFaceMediaType   { 'mediaType' }


1;