package RPS::Import::Curve::v1;

use strict;
use warnings;

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

use base qw/RPS::Import::MapFaceBase RPS::Import::Importer/;

sub _fieldMap {
    my $self = shift;

    my %fieldMap = (
        1 => {
            serviceID       => 'E',
            countryCode     => 'H',
            dateBegin       => 'D',
            productType     => 'B',
            formatType      => 'T',
            clientProductID => 'J',
            artistName      => 'R',
            upc             => 'I',
            albumName       => 'K',
            isrc            => 'O',
            trackName       => 'P',
            units           => 'V',
            price           => 'AR',
            mediaType       => 'T',
        },
    );

    return $fieldMap{ $self->_version };
}

sub _unverifiedFieldMap {
    {
        _altServiceID => 'F',
    }
}

sub _headerIdentifier { upc => 'Barcode' }

my %months = (
    jan => 1,
    feb => 2,
    mar => 3,
    apr => 4,
    may => 5,
    jun => 6,
    jul => 7,
    aug => 8,
    sep => 9,
    oct => 10,
    nov => 11,
    dec => 12
);


sub currencyCode { 'USD' }

sub saleDates {
    my $self = shift;

    # Sat Feb 01 2020 00:00:00 GMT+0000 (UTC)
    my $date = $self->_getByFieldName('dateBegin') || '';
    if ( my ($m, $d, $y) = $date =~ /([a-z]{3}) (\d{1,2}) (\d{4}) \d{2}:\d{2}:\d{2}/i ) {
        return $self->_getDates( date_begin => sprintf( "%04d-%02d-%02d", $y, $months{lc $m}, $d ) );
    }

    # 2020-04-01
    if ( my ($y, $m, $d) = $date =~ /(\d{4})[-\/\.](\d{1,2})[-\/\.](\d{1,2})/ ) {
        return $self->_getDates( date_begin => sprintf( "%04d-%02d-%02d", $y, $m, $d ) );
    }

    # MM/DD/YYYY
    if ( my ($m, $d, $y) = $date =~ /(\d{1,2})[-\/\.](\d{1,2})[-\/\.](\d{2,4})/ ) {
        $y = length($y) == 2 && $y >= 20 ? "20$y" : $y;
        return $self->_getDates( date_begin => sprintf( "%04d-%02d-%02d", $y, $m, $d ) );
    }

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

sub clientProductID {
    my $self = shift;

    my $id = $self->_getByFieldName('clientProductID') || 0;
    $id *= 1 if $id =~ /e\+\d+$/i;

    return $id;
}

sub upc {
    my $self = shift;

    my $upc = $self->_getByFieldName('upc') || 0;
    $upc *= 1 if $upc =~ /e\+\d+$/i;

    return '' unless $upc;
}

sub serviceID {
    my $self = shift;

    my $service = lc( $self->_getByFieldName('serviceID') || '' );
    if ( $service =~ /^Carrier Billing$/i ) {
        $service = lc( $self->_getByFieldName('_altServiceID') || '' );
    }
    my $serviceID = $self->getServiceID($service) || $RPS::Import::ServiceMap::SERVICE_ALIASES{$service};

    return $serviceID if $serviceID;
    $self->handleError( "Unknown service: '$service'", RPS::DB::Item::SaleImportError::kErrorService );
}

sub countryCode {
    my $self = shift;

    my $name = lc( $self->_getByFieldName('countryCode') || '' );

    # Unknown/Unsuported country
    return "ZZ" if $name eq "ww";

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

    $self->handleError( "Unknown country: '$name'.", RPS::DB::Item::SaleImportError::kErrorCountry );
}

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 =~ /^Release$/i;

    $self->handleError( "Unknown product type: '$type'", RPS::DB::Item::SaleImportError::kErrorProductType );
}

sub formatType {
    my $self = shift;

    my $type = $self->_getByFieldName('formatType') || '';
    return RPS::File::Sale::FORMAT_DOWNLOAD if $type =~ /\bDownload\b/i;
    return RPS::File::Sale::FORMAT_STREAM
        if $type =~ /\bStream\b/i
        || $type =~ /^90 day (?:family )?free trial$/i
        || $type =~ /^ATT 2018 Bundle$/i
        || $type =~ /^HiFi$/i
        || $type =~ /^Prime Day 2019 Echo Extended Trial$/i
        || $type =~ /^Art Track$/i
        || $type =~ /^Youtube \(Audio\)$/i
        || $type =~ /Prime Paid/i;

    $self->handleError( "Unknown format type: '$type'", RPS::DB::Item::SaleImportError::kErrorFormatType );
}

sub mediaType {
    my $self = shift;

    my $type = $self->_getByFieldName('mediaType') || '';
    # order is important (should be first)
    return RPS::DB::Item::MediaType::kMediaTypeVideo
        if $type =~ /^VIdeo Premium Stream$/i;

    return RPS::DB::Item::MediaType::kMediaTypeAudio
        if $type =~ /\bStream\b/i
        || $type =~ /\bDownload\b/i
        || $type =~ /^90 day (?:family )?free trial$/i
        || $type =~ /^ATT 2018 Bundle$/i
        || $type =~ /^HiFi$/i
        || $type =~ /^Prime Day 2019 Echo Extended Trial$/i
        || $type =~ /^Art Track$/i
        || $type =~ /^Youtube \(Audio\)$/i
        || $type =~ /Prime Paid/i;

    $self->handleError( "Unknown media_type: '$type'", RPS::DB::Item::SaleImportError::kErrorMediaType );
}

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;
    }

    # math round
    $units += .00000001 if $units =~ /^\d+\.5\d*$/;
    $units = sprintf "%.0f", $units;

    return $units;
}

sub _isValidSaleRecord {
    return defined $_[0]->price && ( $_[0]->trackName || $_[0]->albumName );
}

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

1;