package RPS::Import::K7::v1;

use strict;
use warnings;

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

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

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

sub physical { 2 }

sub _fieldMapExtended {
    {
        physical => {
            option1 => {
                countryCode     => 'J',
                productType     => 'H',
                clientProductID => 'D',
                artistName      => 'F',
                upc             => 'E',
                albumName       => 'G',
                wholesalePrice  => 'M',
                sales           => 'K',
                salesRevenue    => 'T',
                returns         => 'L',
                returnsRevenue  => 'T',
                totalRevenue    => 'T',
            },
        },
        digital => {
            option1 => {
                serviceID       => 'K',
                countryCode     => 'J',
                productType     => 'D',
                formatType      => 'I',
                clientProductID => 'E',
                artistName      => 'G',
                upc             => 'F',
                albumName       => 'H',
                isrc            => 'F',
                trackName       => 'H',
                units           => 'M',
                price           => 'U',
            }
        }
    };
}

sub _unverifiedFieldMapExtended {
    {
        digital => {
            option1 => {
                _returns => 'N',
            },
        },
    };
}

sub _headerIdentifierExtended {
    {
        physical => {
            option1 => { productType => 'Format' },
        },
        digital => {
            option1 => { productType => 'Asset Type' },
        },
    };
}

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

sub _processHeader {
    my $self   = shift;

    my $file = $self->filename;
    $file =~ s/ /_/g;

    unless ($self->{_currencyCode} && $self->{_dateBegin}) {
        #Dancing_Cat___Quarterly__Jan_1_2020_commence____2021_07_01___2021_09_30_USD_(2).xlsx
        my ($dateBegin, $dateEnd, $curr) = $file =~ /_+(\d{4}_\d{2}_\d{2})_+(\d{4}_\d{2}_\d{2})_(\w{3}).*?\.\w+$/i;
        $self->{_currencyCode} = $curr;

        $self->fail( "Unable to determine date or currency code from file name. '$file'" ) unless ($curr && $dateBegin);

        $self->{_dateBegin} = $dateBegin =~ s/_/-/gr;
        $self->{_dateEnd}   = $dateEnd =~ s/_/-/gr;
    }

    return $self->SUPER::_processHeader(@_);
}

sub currencyCode { shift->{_currencyCode} }
sub saleDates { return ($_[0]->{_dateBegin}, $_[0]->{_dateEnd}) }

sub serviceID {
    my $self = shift;

    if ( $self->isDigitalProduct( $self->productType() ) ) {
        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 name from: '$service'." )
    }

    return $self->SUPER::serviceID();
}

sub countryCode {
    my $self = shift;

    my $name = $self->_getByFieldName('countryCode') || '';
    $name =~ s/^DIV$/US/i;
    my $oCountry = Common::Country->Get($name);
    return $oCountry->alpha2() if $oCountry;
}

sub productType {
    my $self = shift;

    my $type = $self->_getByFieldName('productType') || '';
    # physical
    return RPS::File::Sale::TYPE_CD if $type =~ /^CD$/i;
    return RPS::File::Sale::TYPE_LP if $type =~ /^12"|LP\s?2?$/i;
    # digital
    return RPS::File::Sale::TYPE_ALBUM if $type =~ /^Bundle$/i;
    return RPS::File::Sale::TYPE_TRACK if $type =~ /^Track$/i;

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

sub formatType {
    my $self = shift;

    my $type = $self->_getByFieldName('formatType') || '';
    return RPS::File::Sale::FORMAT_DOWNLOAD if $type =~ /^Bundle( DL)?|Track DL$/i;
    return RPS::File::Sale::FORMAT_STREAM   if $type =~ /^(?:Track )?Streams?$/i;

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

sub upc {
    my $self = shift;

    my $upc = $self->_getByFieldName('upc') || '';
    $upc =~ s/[^0-9]//g;

    # physical
    return $upc unless $self->isDigitalProduct( $self->productType );
    # digital
    return $upc if $self->productType eq RPS::File::Sale::TYPE_ALBUM;

}

sub isrc {
    my $self = shift;

    my $isrc = $self->_getByFieldName('isrc') || '';
    return $isrc if $self->productType eq RPS::File::Sale::TYPE_TRACK;
}

sub albumName {
    my $self = shift;

    my $albumName = $self->_getByFieldName('albumName') || '';
    # physical
    return $albumName unless $self->isDigitalProduct( $self->productType );
    # digital
    return $albumName if $self->productType eq RPS::File::Sale::TYPE_ALBUM;
}

sub trackName {
    my $self = shift;

    my $trackName = $self->_getByFieldName('trackName') || '';
    return $trackName if $self->productType eq RPS::File::Sale::TYPE_TRACK;
}

# digital
sub price     { abs( shift->_getByFieldName('price') || 0 ) }
sub unitPrice { abs shift->SUPER::unitPrice }
sub units {
    my $units   = $_[0]->_getByFieldName('units')    || 0;
    my $returns = $_[0]->_getByFieldName('_returns') || 0;
    my $price   = $_[0]->_getByFieldName('price')    || 0;

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

    return $units;
}

# physical
sub channel            { RPS::File::Sale::CHANNEL_RETAIL }
sub priceLevel         { RPS::File::Sale::PLEVEL_UNKNOWN }
sub netUnits           { $_[0]->sales - $_[0]->returns }
sub totalRevenue       { $_[0]->_getByFieldName('totalRevenue') || 0 }
sub sales              { abs( $_[0]->_getByFieldName('sales') || 0 ) }
sub salesRevenue       { $_[0]->totalRevenue > 0 ? $_[0]->totalRevenue     : 0 }
sub returns            { abs( $_[0]->_getByFieldName('returns') || 0 ) }
sub returnsRevenue     { $_[0]->totalRevenue < 0 ? abs $_[0]->totalRevenue : 0 }

sub _isValidSaleRecord {
    return $_[0]->_getByFieldName('trackName') || $_[0]->_getByFieldName('albumName');
}

sub _processSheet {
    my $self = shift;

    return $self->SUPER::_processSheet(@_)
        if $self->sheetname =~ /^(?:physical|digital) sales$/i;
}


1;