package RPS::Import::MVD::v5;

use strict;
use warnings;

use parent qw/RPS::Import::MapFaceBase RPS::Import::Importer/;

use RPS::Import::ServiceMap;

sub _fieldMap {
    return {
        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    => 'AF',
        free            => 'AJ',
        price           => 'AP',
        mediaType       => 'AM',
    }
}

sub _unverifiedFieldMap {
    return {
        _albumArtist => 'N',
        _trackArtist => 'Y',
        _distFee     => 'AK'
    }
}

my %media_type_map = (
    "1" => RPS::DB::Item::MediaType::kMediaTypeAudio,
    "2" => RPS::DB::Item::MediaType::kMediaTypeVideo,
    "A" => RPS::DB::Item::MediaType::kMediaTypeAudio,
    "V" => RPS::DB::Item::MediaType::kMediaTypeVideo
);

sub _headerIdentifier { ( labelName => 'VENDOR_NUM' ) }

sub saleDates {
    my $self = shift;

    my $date_begin = $self->_getByFieldName('dateBegin');
    my $date_end   = $self->_getByFieldName('dateEnd');

    $self->fail( "Unable to determine sale date." ) unless ($date_begin && $date_end);

    return $self->_getDates(
        date_begin => $date_begin,
        date_end   => $date_end
    );
}

sub upc {
    my $self = shift;

    my $upc = $self->_getByFieldName('upc') || '';
    $upc =~ s/-.*$//g;

    return $upc;
}

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;
}

sub price {
    my $self = shift;

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

    if ( $self->{_distFee} ) {
        my $distFee = $self->{_distFee};
        $distFee = ( 100 - $distFee ) * .01;
        $price *= $distFee;
    }

    return ($price < 0) ? abs($price)*-1 : $price;
}


sub mediaType    {
    my $self = shift;

    my $type = uc( $self->_getByFieldName('mediaType') || '' );
    return RPS::DB::Item::MediaType::kMediaTypeVideo unless $type;
	return $media_type_map{$type} if exists $media_type_map{$type};

    $self->handleError( "Unknown media type: '$type'", RPS::DB::Item::SaleImportError::kErrorMediaType );
}

sub serviceID {
    my $self = shift;

    my $service = lc( $self->_getByFieldName('serviceID') || '' );
    my $serviceID = $self->getServiceID($service) || $RPS::Import::ServiceMap::SERVICE_ALIASES{$service};
    $serviceID = 262 if ($service =~ /^AMAZON VIDEO DIRECT$/i);
    $serviceID = 285 if ($service =~ /^NEUROTIC MEDIA$/i);

    return $serviceID if $serviceID;

    $self->handleError( "Unknown service: '$service'", RPS::DB::Item::SaleImportError::kErrorService );
}

sub countryCode {
    my $self = shift;

    my $name = $self->_getByFieldName('countryCode') || 'US';
	my $country = Common::Country->Get($name);

    return $country->alpha2() if $country;

	$self->handleError( "Unknown country: '$name'.", RPS::DB::Item::SaleImportError::kErrorCountry );
    return $name;
}

sub artistName {
    my $self = shift;

    my $album_artist = $self->_getByFieldName('_albumArtist') || '';
    my $track_artist = $self->_getByFieldName('_trackArtist') || '';

    if ($self->productType() eq RPS::File::Sale::TYPE_ALBUM) {
        return $album_artist;
    }
    elsif ($self->productType() eq RPS::File::Sale::TYPE_TRACK) {
        return $track_artist;
    }
}

sub productType {
    my $self = shift;

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

    if ($type eq 'A') {
        return RPS::File::Sale::TYPE_ALBUM;
    }
    elsif ($type eq 'T') {
        return RPS::File::Sale::TYPE_TRACK;
    }

    $self->handleError( "Unknown product type: '$type'", RPS::DB::Item::SaleImportError::kErrorProductType );
}

sub formatType {
    my $self = shift;

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

    if ( $self->serviceID && $self->serviceID == Client::Service::DSP_SOUNDEXCHANGE ) {
        return RPS::File::Sale::FORMAT_PERFORMANCE;
    }
    elsif ( $type =~ /^D(?:ownload)?$/i ) {
        return RPS::File::Sale::FORMAT_DOWNLOAD;
    }
    elsif ( $type =~ /^S(?:tream)?$/i ) {
        return RPS::File::Sale::FORMAT_STREAM;
    }

    $self->handleError( "Unknown format type: '$type'", RPS::DB::Item::SaleImportError::kErrorFormatType );
}

sub _mapFaceCompatibleVersions { 5 }
sub _mapFaceServiceID   { 'serviceID' }
sub _mapFaceCountryCode { 'countryCode' }
sub _mapFaceProductType { 'productType' }
sub _mapFaceFormatType  { 'formatType' }
sub _mapFaceMediaType   { 'mediaType' }

1;