package RPS::Import::RoyaltyShareLabel::v2;

use strict;
use warnings;

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

use parent 'RPS::Import::ImporterMixed';
use Date::Calc qw(Add_Delta_Days Days_in_Month);

sub physical { 0 }

sub _fieldMapExtended {
    {
        digital => {
            option1 => {
                labelName       => 'A',
                serviceID       => 'C',
                countryCode     => 'E',
                dateBegin       => 'F',
                dateEnd         => 'G',
                productType     => 'H',
                formatType      => 'I',
                clientProductID => 'J',
                upc             => 'K',
                albumName       => 'M',
                isrc            => 'T',
                trackNum        => 'W',
                trackName       => 'X',
                units           => 'AC',
                currencyCode    => 'AL1',
                free            => 'AJ',
                price           => 'AL',
                mediaType       => 'AM',
            },
        },
    };
}

sub _unverifiedFieldMapExtended {
    {
        digital => {
            option1 => {
                _albumArtistName => 'N',
                _trackArtistName => 'Y',
            },
        },
    }
}

sub _headerIdentifierExtended {
    {
        digital => {
            option1 => {
                isrc => 'isrc',
            },
        },
    };
}

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;

    $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 saleDates {
    my $self = shift;

    my ($dBegin, $dEnd);
    my $dateBegin = $self->_getByFieldName('dateBegin') || '';
    my $dateEnd   = $self->_getByFieldName('dateEnd')   || '';

    # convert date in ExcelFormat
    if ( $dateBegin =~ /^\d{5}(\.\d)*$/ && $dateBegin > 38716 ) {
        $dateBegin = Spreadsheet::ParseExcel::Utility::ExcelFmt( "yyyy-mm-dd", $dateBegin );
    }
    if ( $dateEnd =~ /^\d{5}(\.\d)*$/ && $dateEnd > 38716 ) {
        $dateEnd = Spreadsheet::ParseExcel::Utility::ExcelFmt( "yyyy-mm-dd", $dateEnd );
    }

    # YYYY-MM
    if ( $dateBegin =~ /^(\d{4})[-](\d{1,2})/ ) {
        $dBegin = sprintf( "%04d-%02d-%02d", $1, $2, 1 );
    }
    if ( $dateEnd =~ /^(\d{4})[-](\d{1,2})/ ) {
        $dEnd = sprintf( "%04d-%02d-%02d", $1, $2, Days_in_Month( $1, $2 ) );
    }

    # DD-MM-YYYY
    if ( $dateBegin =~/^(\d{1,2})[-](\d{1,2})[-](\d{4})/ ) {
        $dBegin = sprintf( "%04d-%02d-%02d", $3, $1, 1 );
    }
    if ( $dateEnd =~ /^(\d{1,2})[-](\d{1,2})[-](\d{4})/ ) {
        $dEnd = sprintf( "%04d-%02d-%02d", $3, $1, Days_in_Month( $3, $1 ) );
    }

    return $dBegin, $dEnd if $dBegin && $dEnd;

    $self->fail("Unable to determine sale date from '$dateBegin' and '$dateEnd'.");
}

sub productType {
    my $self = shift;

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

    return RPS::File::Sale::TYPE_ALBUM if $type =~ /^A$/i;
    return RPS::File::Sale::TYPE_TRACK if $type =~ /^T$/i;

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

my %formatMap = (
    'D' => RPS::File::Sale::FORMAT_DOWNLOAD,
    'H' => RPS::File::Sale::FORMAT_DOWNLOADPREMIUM,
    'I' => RPS::File::Sale::FORMAT_DOWNLOADUPGRADE,
    'S' => RPS::File::Sale::FORMAT_STREAM,
    'T' => RPS::File::Sale::FORMAT_TETHERED,
    'R' => RPS::File::Sale::FORMAT_RINGTONE,
    'J' => RPS::File::Sale::FORMAT_JUKEBOX,
    'E' => RPS::File::Sale::FORMAT_DUALDOWNLOAD,
    'B' => RPS::File::Sale::FORMAT_BACKGROUNDMUSIC,
    'P' => RPS::File::Sale::FORMAT_VPD,
    '1' => RPS::File::Sale::FORMAT_RINGBACK,
    'O' => RPS::File::Sale::FORMAT_PERFORMANCE,
    'L' => RPS::File::Sale::FORMAT_EPHEMERAL,
    '!' => RPS::File::Sale::FORMAT_EPHEMERAL_WEBCAST,
    '@' => RPS::File::Sale::FORMAT_EPHEMERAL_SDARS,
    '#' => RPS::File::Sale::FORMAT_EPHEMERAL_BES,
    '$' => RPS::File::Sale::FORMAT_EPHEMERAL_CABLERAD,
    '%' => RPS::File::Sale::FORMAT_EPHEMERAL_PES,
    '[' => RPS::File::Sale::FORMAT_EPHEMERAL_ATU,
    ']' => RPS::File::Sale::FORMAT_EPHEMERAL_IP,
    ':' => RPS::File::Sale::FORMAT_EPHEMERAL_SETTLEMENT,
    'N' => RPS::File::Sale::FORMAT_NON_EPHEMERAL,
    '&' => RPS::File::Sale::FORMAT_NON_EPHEMERAL_WEBCAST,
    '*' => RPS::File::Sale::FORMAT_NON_EPHEMERAL_SDARS,
    '(' => RPS::File::Sale::FORMAT_NON_EPHEMERAL_BES,
    ')' => RPS::File::Sale::FORMAT_NON_EPHEMERAL_CABLERAD,
    '_' => RPS::File::Sale::FORMAT_NON_EPHEMERAL_PES,
    '{' => RPS::File::Sale::FORMAT_NON_EPHEMERAL_ATU,
    '}' => RPS::File::Sale::FORMAT_NON_EPHEMERAL_IP,
    ';' => RPS::File::Sale::FORMAT_NON_EPHEMERAL_SETTLEMENT,
);

sub formatType {
    my $self = shift;

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

    if ( exists $formatMap{$type} ) {
        return $formatMap{$type}
    }

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

sub artistName {
    my $self = shift;

    my $albumArtistName = $self->_getByFieldName('_albumArtistName') || '';
    my $trackArtistName = $self->_getByFieldName('_trackArtistName') || '';

    return $albumArtistName if $self->productType eq RPS::File::Sale::TYPE_ALBUM;
    return $trackArtistName if $self->productType eq RPS::File::Sale::TYPE_TRACK;

}

sub currencyCode {
    my $self = shift;

    my $code = $self->_getByFieldName('currencyCode') || '';

    if ( $code =~ /^([a-z]{3})-net-price$/i ) {
        return uc $1;
    }

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

sub mediaType {
    my $self = shift;

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

    return RPS::DB::Item::MediaType::kMediaTypeAudio if $type == 1;
    return RPS::DB::Item::MediaType::kMediaTypeVideo if $type == 2;

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

sub free {
    my $self = shift;

    my $free = $self->_getByFieldName('free') || 0;

    return $free =~ /^N$/i ? 0 : 1;
}

sub price {
    my $self = shift;

    my $price = $self->_getByFieldName('price') || 0;
    $price =  sprintf("%.8f", abs $price);

    return $price;
}

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 sprintf("%.0f", $units);
}

sub _isValidSaleRecord {
    my $self = shift;

    return $self->units * 1 || $self->price * 1;
}


1;