package RPS::Import::Redeye::v4;

use strict;

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

use base 'RPS::Import::Importer';

sub _fieldMap {
    {
        dateBegin        => 'B',
        dateEnd          => 'C',
        labelName        => 'H',
        serviceID        => 'A',
        countryCode      => 'D',
        productType      => 'M', # Method
        formatType       => 'N', # Format
        upc              => 'E',
        isrc             => 'F',
        trackName        => 'K',
        albumName        => 'J',
        units            => 'O',
        price            => 'R',
    }
};

sub _unverifiedFieldMap {
    {
        trackArtist      => 'L',
        albumArtist      => 'I',
    }
}


sub currencyCode { 'USD' }

sub _headerIdentifier { ( dateBegin => 'Start Date' ) }

my %methodFormatMap = (
    'breakage' => {
        'track' => {
            'product' => RPS::File::Sale::TYPE_TRACK,
            'format'  => RPS::File::Sale::FORMAT_STREAM,
            'media'   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
    },
    'download' => {
        'album' => {
            'product' => RPS::File::Sale::TYPE_ALBUM,
            'format'  => RPS::File::Sale::FORMAT_DOWNLOAD,
            'media'   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'track' => {
            'product' => RPS::File::Sale::TYPE_TRACK,
            'format'  => RPS::File::Sale::FORMAT_DOWNLOAD,
            'media'   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'ringtone' => {
            'product' => RPS::File::Sale::TYPE_TRACK,
            'format'  => RPS::File::Sale::FORMAT_RINGTONE,
            'media'   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
    },
    'stream' => {
        'album' => {
            'product' => RPS::File::Sale::TYPE_ALBUM,
            'format'  => RPS::File::Sale::FORMAT_STREAM,
            'media'   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'performance income' => {
            'product' => RPS::File::Sale::TYPE_TRACK,
            'format'  => RPS::File::Sale::FORMAT_PERFORMANCE,
            'media'   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'track' => {
            'product' => RPS::File::Sale::TYPE_TRACK,
            'format'  => RPS::File::Sale::FORMAT_STREAM,
            'media'   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'video' => {
            'product' => RPS::File::Sale::TYPE_TRACK,
            'format'  => RPS::File::Sale::FORMAT_STREAM,
            'media'   => RPS::DB::Item::MediaType::kMediaTypeVideo,
        },
    },
    'nrights' => {
        'performance income' => {
            'product' => RPS::File::Sale::TYPE_TRACK,
            'format'  => RPS::File::Sale::FORMAT_PERFORMANCE,
            'media'   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'track' => {
            'product' => RPS::File::Sale::TYPE_TRACK,
            'format'  => RPS::File::Sale::FORMAT_STREAM,
            'media'   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
    },
);

sub countryCode {
    my $self = shift;
    my $name = $self->_getByFieldName('countryCode');

    # Apparently RedEye is consistently reporting incorrect Territory codes for the service Wimp.
    # Until they get their act together, we'll map the following country codes.
    # See Case 8311.
    $name = 'PL' if( $name =~ /^Po$/ );
    $name = 'SE' if( $name =~ /^Sw$/ );

    $name = 'US' if( '' eq $name );

    return $name;
}

sub saleDates {
    my $self = shift;
    my $startDate = $self->_getByFieldName('dateBegin');

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

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

    $self->fail( "Service name not defined" ) unless( $serviceName );
    
    if ($serviceName =~ /^Beats$/i) {
        $serviceName = "BeatsDigital";
    }

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

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

    return $serviceID;
}

sub artistName {
    my $self = shift;
    my $trackArtist = $self->_getByFieldName('trackArtist');
    my $albumArtist = $self->_getByFieldName('albumArtist');

    return $self->productType eq RPS::File::Sale::TYPE_TRACK ? $trackArtist : $albumArtist;
}

sub mediaType {
    my $self = shift;
    my $method = lc $self->_getByFieldName('productType');
    my $format = lc $self->_getByFieldName('formatType');
    my $service = $self->serviceID();

    if( $method =~ /^stream$/i && $format =~ /^video$/i && $service == Client::Service::DSP_YOUTUBE )
    {
        return RPS::DB::Item::MediaType::kMediaTypeAudio;  # override the methodFormatMap for stream/video
    }

    if( exists $methodFormatMap{$method}{$format} )
    {
        return $methodFormatMap{$method}{$format}{media};
    }
    else
    {
        $self->fail( "Could not get media type from method '$method' format '$format'" );
    }
}

sub productType {
    my $self = shift;
    my $method = lc $self->_getByFieldName('productType');
    my $format = lc $self->_getByFieldName('formatType');

    my $trackName = $self->_getByFieldName('trackName');

    my $_productType;
    if( exists $methodFormatMap{$method}{$format} )
    {
        my $_type = $methodFormatMap{$method}{$format}{product};

        if( $_type eq RPS::File::Sale::TYPE_ALBUM )
        {
            # Override album product if track name is present
            #
            return ( $trackName && '' ne $trackName ) ? RPS::File::Sale::TYPE_TRACK : $_type;
        }
        else
        {
            return $_type;
        }
    }
    else
    {
        $self->fail( "Could not get product type from method '$method' format '$format'" );
    }
}

sub formatType {
    my $self = shift;
    my $method = lc $self->_getByFieldName('productType');
    my $format = lc $self->_getByFieldName('formatType');
    my $service = $self->serviceID();

    if( $method =~ /^stream$/i && $format =~ /^track$/i && $service == Client::Service::DSP_SOUNDEXCHANGE )
    {
        return RPS::File::Sale::FORMAT_PERFORMANCE; # override default stream/track mapping
    }
    elsif( exists $methodFormatMap{$method}{$format} )
    {
        return $methodFormatMap{$method}{$format}{format};
    }
    else
    {
        $self->fail( "Could not get format type from method '$method' format '$format'" );
    }
}

sub price {
    my $price = abs( shift->SUPER::price() );
    return $price;
}

sub units {
    my $self = shift;
    my $units = $self->SUPER::units() || return;
    my $price = $self->SUPER::price();

    if( defined($price) ) {
        return $price < 0 ? abs($units) * -1 : $units;
    } else {
        return $units;
    }
}

sub unitPrice { abs( shift->SUPER::unitPrice ) }
###
1;# Play nicely.
###