package RPS::Import::INGrooves::v8;

use strict;

use lib '/app/tools/common/lib';
use Common::Date;
use Common::Country;

use lib '/app/tools/rps/lib';
use base 'RPS::Import::MapFaceBase';
use base 'RPS::Import::INGroovesBase';

use Data::Dumper;

sub _headerIdentifier { ( upc => 'UPC/EAN' ) }

sub _fieldMap {
    {
        serviceID        => 'B',
        labelName        => 'U',
        countryCode      => 'M',
        dateBegin        => 'A',
        dateEnd          => 'D',
        productType      => 'R',
        formatType       => 'V',
        artistName       => 'H',
        serviceProductID => 'K',
        upc              => 'J',
        albumName        => 'G',
        trackName        => 'E',
        isrc             => 'I',
        units            => 'N',
        price            => 'P',
    };
}

sub _unverifiedFieldMap {
    { assetType => 'Q', };
}

sub currencyCode { 'USD' }

sub countryCode {
    my $self = shift;
    my $name = $self->SUPER::countryCode();

    if ($name) {

        $name =~ s/,.*//;

        $name = $self->_getAlternateCountryName($name) || $name;

        my $country = new Common::Country( search => $name );

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

        return $name;
    }
}

sub productType {
    my $self        = shift;
    my $consumption = $self->_getByFieldName('formatType');             # col V ("CONSUMPTION")
    my $assetType   = $self->_getByFieldName('assetType') || return;    # col Q ("ASSET TYPE")
    my $service     = $self->_serviceName();

    if ( !$consumption ) {

        # if CONSUMPTION (col V) is blank, use product format mappings
        #
        my ( $serviceID, $consumption, $productType, $mediaType ) = $self->_getServiceFormat( $service, $assetType );
        return $productType if ($productType);
    } elsif ( $assetType =~ /track/i || $assetType =~ /video/i || $assetType =~ /ringtone/i ) {
        return RPS::File::Sale::TYPE_TRACK;
    } elsif ( $assetType =~ /album/i ) {
        return RPS::File::Sale::TYPE_ALBUM;
    }

    return $self->_getByFieldName('productType');
}

sub formatType {
    my $self = shift;

    my $consumption = $self->_getByFieldName('formatType');             # col V ("CONSUMPTION")
    my $assetType   = $self->_getByFieldName('assetType') || return;    # col Q ("ASSET TYPE")
    my $service     = $self->_serviceName();

    if ( !$consumption ) {

        # if CONSUMPTION (col V) is blank, use product format mappings
        #
        my ( $serviceID, $formatType, $productType, $mediaType ) = $self->_getServiceFormat( $service, $assetType );
        return $formatType if ($formatType);
    } elsif ( $consumption =~ /^(download|burn)$/i ) {
        return RPS::File::Sale::FORMAT_DOWNLOAD;
    } elsif ( $consumption =~ /^(portable|stream|client|radio|kiosk)$/i ) {
        return RPS::File::Sale::FORMAT_STREAM;
    } elsif ( $consumption =~ /^jukebox$/i ) {
        return RPS::File::Sale::FORMAT_JUKEBOX;
    } elsif ( $consumption =~ /^ringtone$/i ) {
        return RPS::File::Sale::FORMAT_RINGTONE;
    } elsif ( $consumption =~ /^tethered download$/i ) {
        return RPS::File::Sale::FORMAT_TETHERED;
    }

    return $consumption;
}

sub mediaType {
    my $self = shift;

    my $productType = $self->_getByFieldName('productType');            # col R ("PRODUCT TYPE")
    my $assetType   = $self->_getByFieldName('assetType') || return;    # col Q ("ASSET TYPE")
    my $service     = $self->_serviceName();

    if ( !$productType ) {

        # if PRODUCT TYPE (col R) is blank, use product format mappings
        #
        my ( $serviceID, $formatID, $productType, $mediaType ) = $self->_getServiceFormat( $service, $assetType );
        if ($mediaType) {
            return $mediaType;
        } else {

            #$self->fail("Cannot determine media type for service '$service' using asset type '$assetType'");
            return $assetType;
        }

    }
    if (   $productType =~ /^(audio album|master service tone\/ ringback tone|track)$/i
        || $productType =~ /^(high quality audio album)$/i ) {
        return RPS::DB::Item::MediaType::kMediaTypeAudio;
    } elsif ( $productType =~ /^(music video|video)$/i ) {
        return RPS::DB::Item::MediaType::kMediaTypeVideo;
    } elsif ( lc($productType) eq 'audio video bundle' ) {
        if   ( lc($assetType) eq 'video' ) { return RPS::DB::Item::MediaType::kMediaTypeVideo }
        else                               { return RPS::DB::Item::MediaType::kMediaTypeAudio }
    }

    return $productType;
}

sub _serviceName {
    my $self = shift;
    my $service = $self->_getByFieldName('serviceID') || return;
    $service =~ s/ (\w{3})$//;

    return $service;
}

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

    if ( $type && $service ) {
        my ( $serviceID, $formatID, $productType, $mediaType ) = $self->_getServiceFormat( $service, $type );
        return $serviceID if ($serviceID);
    }

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

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

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

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

}

sub unitPrice { abs( shift->SUPER::unitPrice ) }

## MapFace Stuff

sub _mapFaceServiceID {
    return ('serviceID');
}

sub _mapFaceCountryCode {
    return ('countryCode');
}

sub _mapFaceProductType {
    return ( 'formatType', 'assetType', 'serviceID' );
}

sub _mapFaceFormatType {
    return ( 'formatType', 'assetType', 'serviceID' );
}

sub _mapFaceMediaType {
    return ( 'productType', 'assetType', 'serviceID' );
}

###
1;    # Play nicely.
###