package RPS::Import::WMG::WarnerCADMixed;

use strict;
use warnings;

use Date::Calc qw(Days_in_Month Add_Delta_Days Decode_Month);

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

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

sub physical { 2 }

sub _fieldMapExtended {
    {
        digital => {
            option1 => {
                serviceID      => 'E',
                dateBegin      => 'B',
                dateEnd        => 'B',
                productType    => 'J',
                formatType     => 'J',
                artistName     => 'H',
                upc            => 'K',
                albumName      => 'I',
                trackName      => 'I',
                units          => 'Q',
                priceLevel     => 'M',
                sales          => 'O',
                salesRevenue   => 'W',
                returns        => 'P',
                returnsRevenue => 'X',
                totalRevenue   => 'Y',
                price          => 'Y',
                mediaType      => 'J',
            },
         },
    };
}

sub _unverifiedFieldMapExtended {
    {
        digital => {
            option1 => {
                _netUnits => 'Q',
            },
        }
    };
}

sub _headerIdentifierExtended {
    {
        digital => {
            option1 => {
                upc => 'UPC/EAN',
            },
        },
    };
}

sub countryCode  { 'CA' }
sub currencyCode { 'CAD' }
sub channel      { RPS::File::Sale::CHANNEL_RETAIL }

sub saleDates {
    my $self      = shift;
    my $startDate = $self->_getDateBegin();

    if ( $startDate =~ /^\d{5}$/ ) {
        $startDate = Spreadsheet::ParseExcel::Utility::ExcelFmt( "yyyy-mm-dd", $startDate );
    }
    return $self->_getDates( date_begin => $startDate );
}

sub serviceID {
    my $self = shift;

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

    if ( $service =~ /^sunrise/i ) {
        return Client::Service::DSP_SUNRISE;
    } elsif ( $service =~ /^archambault/i ) {
        return Client::Service::DSP_ARCHAMBAULT_INC;
    }

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

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

sub productType {
    my $self = shift;

    my $type = $self->_getByFieldName('productType') || '';

    # physical
    return RPS::File::Sale::TYPE_CD if $type =~ /^CD - Compact Disc$/i;
    return RPS::File::Sale::TYPE_LP if $type =~ /^A  - Albums$/i;

    # digital
    return RPS::File::Sale::TYPE_TRACK;
}

sub formatType {
    my $self = shift;

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

    if ( $type =~ /^(?:SA|TA|TV|SV|IS|MM) - (?:Subscription|Stream|Digital|Mobile) (?:Video|Audio|Single|Mastertone)$/i ) {
        return RPS::File::Sale::FORMAT_STREAM;
    }

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

sub artistName {
    my $self = shift;

    my $artistName = $self->_getByFieldName('artistName') || '';
    $artistName =~ s/^(.*)\s*,\s*(.*)$/$2 $1/;
    return $artistName;
}

sub upc {
    my $self = shift;

    return $self->isDigitalProduct( $self->productType )
        ? undef
        : $self->_getByFieldName('upc');
}

sub albumName {
    my $self = shift;

    return $self->isDigitalProduct( $self->productType )
        ? undef
        : $self->_getByFieldName('albumName');
}

sub priceLevel {
    my $self = shift;

    my $level = $self->_getByFieldName('priceLevel') || '';
    if ( $level =~ /^Budget|Supersaver$/i ) {
        return RPS::File::Sale::PLEVEL_BUDGET;
    } elsif ( $level =~ /^Full Price$/i ) {
        return RPS::File::Sale::PLEVEL_FULL;
    } elsif ( $level =~ /^E.P./i ) {
        return RPS::File::Sale::PLEVEL_UNKNOWN;
    }

    $self->fail( "Unable to determine price level: $level" );
}

sub mediaType {
    my $self = shift;

    my $type = $self->_getByFieldName('mediaType') || '';
    if ( $type =~ /^(?:SA - Subscription Audio|TA - Stream Audio|CD - Compact Disc|A  - Albums|IS - Digital Single|MM - Mobile Mastertone)$/i ) {
        return RPS::DB::Item::MediaType::kMediaTypeAudio;
    } elsif ( $type =~ /^(?:TV - Stream|SV - Subscription) Video$/i ) {
        return RPS::DB::Item::MediaType::kMediaTypeVideo;
    }

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

# 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 > 0 ) {
        $units = abs($units) * -1
    } elsif ( $price > 0 && $units < 0 ) {
        $units = abs($units);
    }

    return $units;
}

## physical
sub netUnits           { $_[0]->_getByFieldName('_netUnits')    || 0 }
sub totalRevenue       { $_[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') )
    && $_[0]->netUnits
}


1;