#---------------------------------------------------------------
# ____                   _ _         ____  _
#|  _ \ ___  _   _  __ _| | |_ _   _/ ___|| |__   __ _ _ __ ___
#| |_) / _ \| | | |/ _` | | __| | | \___ \| '_ \ / _` | '__/ _ \
#|  _ < (_) | |_| | (_| | | |_| |_| |___) | | | | (_| | | |  __/
#|_| \_\___/ \__, |\__,_|_|\__|\__, |____/|_| |_|\__,_|_|  \___|
#            |___/             |___/
#
# Copyright (C) 2014 RoyaltyShare, Inc.   All Rights Reserved
#---------------------------------------------------------------

package RPS::Import::WMG::WarnerUSDigital;

use strict;

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

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

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

sub _fieldMap {
    {
        # detail
        serviceID   => 'N',
        countryCode => 'G',
        dateBegin   => 'O',
        dateEnd     => 'O',
        productType => 'H',
        formatType  => 'J',
        artistName  => 'F',
        upc         => 'B',
        albumName   => 'E',
        isrc        => 'B',
        trackName   => 'Q',
        units       => 'K',
        price       => 'P',
    };
}

sub _headerIdentifier { ( artistName => 'Artist Name' ) }

sub currencyCode { 'USD' }

sub albumName {
    my $self = shift;
    return $self->_getByFieldName('albumName')
      if ( $self->productType eq RPS::File::Sale::TYPE_ALBUM
        || ( $self->productType eq RPS::File::Sale::TYPE_TRACK && $self->_getByFieldName('trackName') ) );
}

sub upc {
    my $self = shift;
    return $self->_getByFieldName('upc') if ( $self->productType eq RPS::File::Sale::TYPE_ALBUM );
}

sub trackName {
    my $self = shift;
    my $trackName;

    if ( $self->productType eq RPS::File::Sale::TYPE_TRACK ) {
        $trackName = $self->_getByFieldName('trackName');
        if ( !$trackName ) {
            $trackName = $self->_getByFieldName('albumName');
        }
    }
    return $trackName;
}

sub isrc {
    my $self = shift;
    return $self->_getByFieldName('isrc') if ( $self->productType eq RPS::File::Sale::TYPE_TRACK );
}

sub serviceID {
    my $self    = shift;
    my $service = $self->_getByFieldName('serviceID');
    $service =~ s/ \(Download\)//;
    $service =~ s/ \(Streaming\)//;
    my $serviceID = $self->getServiceID( lc($service) ) || $RPS::Import::ServiceMap::SERVICE_ALIASES{ lc $service };
    return $serviceID if ($serviceID);
    $self->fail("Unknown service '$service'");
}

sub countryCode {
    my $self = shift;

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

    my %countryMap = (
        "argentina satellite"           => "Argentina",
        "central europe"                => "Germany",
        "columbia"                      => "Colombia",
        "greece wm"                     => "Greece",
        "denmark wea"                   => "Denmark",
        "eastern europe"                => "Poland",
        "mton kft (hungary)"            => "Hungary",
        "new zealand wm"                => "New Zealand",
        "n. ireland"                    => "United Kingdom",
        "supraphon (czech rep)"         => "Czech Republic",
        "serengeti records (ghana)"     => "Ghana",
        "serengeti records (mauritius)" => "Mauritius",
        "wm taiwan"                     => "Taiwan",
        "ivory coast"                   => "Côte d'Ivoire",
        "farol musica (portugal)"       => "Portugal",
    );

    $countryName = $countryMap{ lc $countryName } || $countryName;

    my $o = Common::Country->Get($countryName);

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

    $self->fail("Unable to determine country from '$countryName'");

}

sub units {
    my $self  = shift;
    my $units = $self->_getByFieldName('units');
    my $price = $self->_getByFieldName('price');

    # Follow the sign of the revenue.
    if ( $price > 0 ) {
        $units = abs($units);
    } elsif ( $price < 0 ) {
        $units = abs($units) * -1;
    }

    return $units;
}

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

    my ( $_productType, $_formatType, $_mediaType ) = $self->_getMappings();

    $self->fail("Could not determine product type from $productType / $formatType") if ( !$_productType );

    return $_productType;
}

sub formatType {
    my $self = shift;

    my $productType = lc( $self->_getByFieldName('productType') ) || return;
    my $formatType  = lc( $self->_getByFieldName('formatType') )  || return;

    my ( $_productType, $_formatType, $_mediaType ) = $self->_getMappings();

    $self->fail("Could not determine format type from $productType / $formatType") if ( !$_formatType );

    return $_formatType;
}

sub mediaType {
    my $self = shift;

    my $productType = lc( $self->_getByFieldName('productType') ) || return;
    my $formatType  = lc( $self->_getByFieldName('formatType') )  || return;

    my ( $_productType, $_formatType, $_mediaType ) = $self->_getMappings();

    $self->fail("Could not determine media type from $productType / $formatType") if ( !$_mediaType );

    return $_mediaType;
}

my %gProductFormatMap = (
    'cloud sales' => {
        'stream' => {
            product_type => RPS::File::Sale::TYPE_TRACK,
            format       => RPS::File::Sale::FORMAT_STREAM,
            media        => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
    },
    'digital sales' => {
        'digital album' => {
            product_type => RPS::File::Sale::TYPE_ALBUM,
            format       => RPS::File::Sale::FORMAT_DOWNLOAD,
            media        => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'digital download' => {
            product_type => RPS::File::Sale::TYPE_TRACK,
            format       => RPS::File::Sale::FORMAT_DOWNLOAD,
            media        => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'stream' => {
            product_type => RPS::File::Sale::TYPE_TRACK,
            format       => RPS::File::Sale::FORMAT_STREAM,
            media        => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'video stream' => {
            product_type => RPS::File::Sale::TYPE_TRACK,
            format       => RPS::File::Sale::FORMAT_STREAM,
            media        => RPS::DB::Item::MediaType::kMediaTypeVideo,
        },
    },
    'promotional' => {
        'stream' => {
            product_type => RPS::File::Sale::TYPE_TRACK,
            format       => RPS::File::Sale::FORMAT_STREAM,
            media        => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'video stream' => {
            product_type => RPS::File::Sale::TYPE_TRACK,
            format       => RPS::File::Sale::FORMAT_STREAM,
            media        => RPS::DB::Item::MediaType::kMediaTypeVideo,
        },
    },
    'tethered' => {
        'digital download' => {
            product_type => RPS::File::Sale::TYPE_ALBUM,
            format       => RPS::File::Sale::FORMAT_TETHERED,
            media        => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
    },
);

sub _getMappings {
    my $self        = shift;
    my $productType = lc( $self->_getByFieldName('productType') ) || return;
    my $formatType  = lc( $self->_getByFieldName('formatType') ) || return;

    my $_productType;
    my $_formatType;
    my $_mediaType;

    foreach my $_pType ( keys %gProductFormatMap ) {
        if ( $productType =~ /^$_pType$/i ) {
            foreach my $_fType ( keys %{ $gProductFormatMap{$_pType} } ) {
                if ( $formatType =~ /^$_fType$/i ) {
                    $_productType = $gProductFormatMap{$_pType}{$_fType}{product_type};
                    $_formatType  = $gProductFormatMap{$_pType}{$_fType}{format};
                    $_mediaType   = $gProductFormatMap{$_pType}{$_fType}{media};
                    last;
                }
            }
        }
    }
    return ( $_productType, $_formatType, $_mediaType );
}

sub _processSheet {
    my $self     = shift;
    my $sheet    = shift;
    my $sheetnum = shift;

    return $self->SUPER::_processSheet( $sheet, $sheetnum ) if ( $self->{sheetname} !~ /^pivot/i );
}

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