package RPS::Import::AWAL::v3;

use strict;
use warnings;

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

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

sub physical { 2 }

sub _fieldMapExtended {
    {
        mixed => {
            option1 => {
                labelName    => 'U',
                serviceID    => 'D',
                countryCode  => 'Y',
                dateBegin    => 'AC',
                dateEnd      => 'AD',
                formatType   => 'V',
                upc          => 'L',
                albumName    => 'I',
                isrc         => 'P',
                trackName    => 'Q',
                units        => 'AF',
                currencyCode => 'AI',
                retail       => 'AJ',
                totalRevenue => 'AO',
                price        => 'AO',
                mediaType    => 'T',
            },
        },
    };
}

sub _unverifiedFieldMapExtended {
    {
        mixed => {
            option1 => {
                _netUnits        => 'AF',
                _trackArtist     => 'S',
                _bundleArtist    => 'K',
                _productTypePhys => 'M',
                _productTypeDig  => 'F',
            },
        }
    };
}

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

sub channel       { RPS::File::Sale::CHANNEL_RETAIL }
sub priceLevel    { RPS::File::Sale::PLEVEL_UNKNOWN }
sub _getDateBegin { $_[0]->_prepareDate( $_[0]->_getByFieldName('dateBegin') ) }
sub _getDateEnd   { $_[0]->_prepareDate( $_[0]->_getByFieldName('dateEnd')   ) }

sub serviceID {
    my $self = shift;

    my $formatType = $self->_getByFieldName('formatType') || '';
    if ( $formatType =~ /^Physical Distribution\s?(?:Via a Distributor|,Kobalt Direct)$/i ) {
        return Client::Service::DSP_ORCHARD;
    }

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

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

sub countryCode {
    my $self = shift;

    my $country = $self->_getByFieldName('countryCode') || '';
    my $oCountry = Common::Country->new( search => $country );
    return $oCountry->alpha2 if $oCountry;

    $self->fail("Unable to determine country code from '$country'");
}

sub _prepareDate {
    my $self = shift;
    my $date = lc( shift // '' );

    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,
    );

    if ( $date =~ /(\d{1,2})-([a-z]{3})-(\d{2})/i ) {
        return sprintf "%04d-%02d-%02d", "20$3", $months{$2}, $1;
    } elsif ( $date =~ /(\d{1,2})[.-](\d{1,2})[.-](\d{4})/ ) { # DD.MM.YYYY
        return sprintf "%04d-%02d-%02d", "$3", $2, $1;
    } elsif ( $date =~ /^\d+$/) {
        return Common::Date->new( date => $date, type => 'excel' );
    }

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

sub productType {
    my $self = shift;

    my $productTypePhys = $self->_getByFieldName('_productTypePhys') || '';
    my $formatType = $self->_getByFieldName('formatType') || '';
    if ( $formatType =~ /^Physical Distribution\s?(?:Via a Distributor|,Kobalt Direct)$/i ) {
        return RPS::File::Sale::TYPE_CD if $productTypePhys =~ /.*CD$/i;
        return RPS::File::Sale::TYPE_LP if $productTypePhys =~ /.*LP$/i;
    }

    my $productTypeDig = $self->_getByFieldName('_productTypeDig') || '';
    if ( $productTypeDig ) {
        return RPS::File::Sale::TYPE_TRACK if $productTypeDig =~ /^Track$/i;
        return RPS::File::Sale::TYPE_ALBUM if $productTypeDig =~ /^Bundle$/i;
    } else {
        my $isrc = $self->_getByFieldName('isrc') || '';
        return $isrc ? RPS::File::Sale::TYPE_TRACK : RPS::File::Sale::TYPE_ALBUM;
    }

    $self->fail("Unable to determine product type from '$productTypePhys' or '$productTypeDig'");
}

sub formatType {
    my $self = shift;

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

    # RSD-11462
    if ( $self->serviceID == Client::Service::DSP_SOUNDEXCHANGE ) {
        return RPS::File::Sale::FORMAT_NON_EPHEMERAL;
    }

    if ( $formatType =~ /^permanent download$/i ) {
        return RPS::File::Sale::FORMAT_DOWNLOAD;
    }
    if ( $formatType =~ /^conditional download$/i ) {
       return RPS::File::Sale::FORMAT_TETHERED;
    }
    if ( $service =~ /pandora/i && $formatType =~ /^(?:non-interactive streaming)$/i) {
        return RPS::File::Sale::FORMAT_PERFORMANCE;
    }
    if ( $formatType =~ /^(?:Cable Radio|Internet Radio and Webcasting|Unidentified Public Performance and Broadcast|Public Performance|Radio Broadcast|TV Broadcast|Exclusive Rights)$/i) {
        return RPS::File::Sale::FORMAT_PERFORMANCE;
    }
    if ( $formatType =~ /^(?:(?:Unidentified )?Private Copying(?: - Audio.*?)?|Music Dubbing)$/i) {
        return RPS::File::Sale::FORMAT_EPHEMERAL;
    }
    if ( $formatType =~ /^(?:non-interactive streaming|on demand streaming|pro rata share of one-off income)$/i ) {
        return RPS::File::Sale::FORMAT_STREAM;
    }

    $self->fail("Unable to determine format type from '$formatType'");
}

sub artistName {
    my $self = shift;

    if ( $self->productType eq RPS::File::Sale::TYPE_TRACK ) {
        return $self->_getByFieldName('_trackArtist');
    } elsif ( $self->productType eq RPS::File::Sale::TYPE_ALBUM ) {
        return $self->_getByFieldName('_bundleArtist');
    }
}

sub mediaType {
    my $self = shift;

    my $mediaType = $self->_getByFieldName('mediaType') || '';
    if ( !$mediaType || $mediaType =~ /^audio$/i ) {
        return  RPS::DB::Item::MediaType::kMediaTypeAudio
    } elsif ( $mediaType =~ /^video$/i ) {
        return RPS::DB::Item::MediaType::kMediaTypeVideo;
    }

    $self->fail("Unable to determine media type from '$mediaType'");
}

# digital
sub price     { sprintf( "%.8f", 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;
}

# physical
sub netUnits           { $_[0]->_getByFieldName('_netUnits') || 0 }
sub totalRevenue       { sprintf("%.8f", $_[0]->_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 {
    return ( $_[0]->_getByFieldName('trackName') || $_[0]->_getByFieldName('albumName') )
}


1;