package RPS::Import::Mtheory::v2;

use strict;
use warnings;

use lib '/app/tools/rps/lib';
use RPS::Import::ServiceMap;
use Date::Calc qw(Decode_Month Days_in_Month);

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

sub physical { 2 }

sub _fieldMapExtended {
    {
        digital => {
            option1 => {
                labelName   => 'Q',
                serviceID   => 'J',
                countryCode => 'C',
                productType => 'H',
                formatType  => 'G',
                artistName  => 'B',
                upc         => 'M',
                albumName   => 'A',
                isrc        => 'E',
                trackName   => 'K',
                units       => 'L',
                price       => 'I',
                mediaType   => 'F',
            },
         },
    };
}

sub _unverifiedFieldMapExtended {
    {
        digital => {
            option1 => {
                _sale_month => 'W',
                _sale_year  => 'X',
            },
        },
    };
}

sub _headerIdentifierExtended {
    {
        digital => {
            option1 => {
                upc => 'upc_ean',
            },
        },
    };
}

sub currencyCode { 'USD' }

sub countryCode {
    my $self = shift;

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

    my $country = Common::Country->Get($name);
    return $country ? $country->alpha2 : undef ;
}

sub serviceID {
    my $self    = shift;
    my $service = $self->_getByFieldName('serviceID');

    return Client::Service::DSP_UNKNOWN unless ($service);

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

    $self->fail("Unable to determine service id from '$service'") unless ($serviceID);

    return $serviceID;
}

sub saleDates {
    my $self = shift;

    my $sale_month = $self->_getByFieldName('_sale_month');
    my $sale_year  = $self->_getByFieldName('_sale_year');;
    my ($startDate, $endDate);

    if ( $sale_month && $sale_year ) {
        $startDate = sprintf( "%04d-%02d-%02d", $sale_year, $sale_month, 1 );
        $endDate = sprintf( "%04d-%02d-%02d", $sale_year, $sale_month, Days_in_Month( $sale_year, $sale_month ) );
    }
    return ( $startDate, $endDate );

    $self->fail("Can't determine sales date from 'Month: $sale_month, Year: $sale_year'.");
}

sub productType {
    my $self = shift;

    my $type = $self->_getByFieldName('productType') || '';
    if ( $type =~ /^(?:album|A)$/i ) {
        return RPS::File::Sale::TYPE_ALBUM;
    } elsif ( $type =~ /^(?:track|T)$/i ) {
        return RPS::File::Sale::TYPE_TRACK;
    }

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

sub formatType {
    my $self = shift;

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

    return RPS::File::Sale::FORMAT_PERFORMANCE if $self->serviceID == Client::Service::DSP_SOUNDEXCHANGE;
    return RPS::File::Sale::FORMAT_STREAM   if $type eq 'DS';
    return RPS::File::Sale::FORMAT_DOWNLOAD if $type eq 'D';

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

sub mediaType {
    my $self = shift;

    my $type = $self->_getByFieldName('mediaType') || '';
    return RPS::DB::Item::MediaType::kMediaTypeAudio if $type eq 'A';
    return RPS::DB::Item::MediaType::kMediaTypeVideo if $type eq 'V';

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

sub units {
    my $self = shift;

    my $units = $self->_getByFieldName('units') || 1;
    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;
}

sub _isValidSaleRecord {
    return ( $_[0]->_getByFieldName('units') || $_[0]->_getByFieldName('price') )
}


1;