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

package RPS::Import::Caroline::v10;

use strict;

use Date::Calc qw(Days_in_Month Decode_Month);

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

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

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

sub _fieldMap {
    my $self = shift;
    my $version = $self->_version;

    my %field_map = (
        10 => {
            labelName     => 'C',
            countryCode   => 'A',
            dateBegin     => 'L',
            dateEnd       => 'L',
            productType   => 'E',
            formatType    => 'D',
            artistName    => 'H',
            upc           => 'F',
            albumName     => 'G',
            isrc          => 'E',
            trackName     => 'G',
            units         => 'O',
            price         => 'S',
            mediaType     => 'J',
        },
    );
    return $field_map{$version};
}

sub _unverifiedFieldMap {
    my $self = shift;
    my $version = $self->_version;

    my %field_map = (
        10 => {
            upc_isrc   => 'E',
        },
    );
    return $field_map{$version};
}

sub _headerIdentifier { ( upc => 'Royalty UPC' ) }

sub currencyCode { 'USD' }

sub countryCode {
	my $self = shift;
	my $country = $self->_getByFieldName( 'countryCode' );
	my $obj = Common::Country->Get( $country );
	
	return $obj ? $obj->alpha2 : undef;
}

sub mediaType {
    my $self = shift;
    my $type = $self->_getByFieldName( 'mediaType' );

    if( $type =~ /^eAlbum Audio$/i                    ||
        $type =~ /^eAlbum Audio HD$/i                 ||
        $type =~ /^CD album$/i                        ||
        $type =~ /^eAlbum Audio \+ Booklet$/i         ||
        $type =~ /^eMix Bundle Album$/i               ||
        $type =~ /^eSingle Audio\/Single Track$/i     ||
        $type =~ /^vinyl album 12\" 33 rpm$/i         ||
        $type =~ /^eMix Bundle Album \+ LP$/i         ||
        $type =~ /^eMix Bundle Album \+ Booklet$/i    ||
        $type =~ /^Mastertone\/Realtone\/Ringback$/i  ||
        $type =~ /^eSingle Audio\/Multi Track$/i      ||
        $type =~ /^eSingle Audio\/Single Track HD$/i  ||
        $type =~ /^eMix Bundle Single$/i              ||
        $type =~ /^eSingle Audio\/Multi Track HD$/i   ||
        $type =~ /^eAlbum Audio \+ Booklet HD$/i      ||
        $type =~ /^\s*$/  )
    {
        return RPS::DB::Item::MediaType::kMediaTypeAudio;
    }
    elsif( $type =~ /^eSingle Video$/i || $type =~ /^eVideo Long Program$/i)
    {
        return RPS::DB::Item::MediaType::kMediaTypeVideo;
    }

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

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

    if( $format =~ /^Mobile$/i )
    {
        return RPS::File::Sale::FORMAT_RINGTONE;
    }
    elsif( $format =~ /^Digital$/i )
    {
        return RPS::File::Sale::FORMAT_DOWNLOAD;
    }
    elsif( $format =~ /^Streams$/i )
    {
        return RPS::File::Sale::FORMAT_STREAM;
    }

    $self->fail("Unable to determine format type from format($format)");
}

sub productType {
    my $self  = shift;
    my $upc_isrc = $self->_getByFieldName('upc_isrc');
    my $upc  = $self->_getByFieldName('upc');

    # the upc field is populated.  The upc_isrc field is populated with either a
    # upc or an isrc, so if they match, it's an album.
    if( $upc_isrc eq $upc )
    {
        return RPS::File::Sale::TYPE_ALBUM;
    } else {
        return RPS::File::Sale::TYPE_TRACK;
    }
}

sub saleDates {
    my $self  = shift;
    my $version = $self->_version;

    my $dateBegin;
    my $dateEnd;

    if( exists $self->_fieldMap->{'dateBegin'} )
    {
        my $date = $self->_getByFieldName('dateBegin');
        my %months = (
            'JAN' => '01',
            'FEB' => '02',
            'MAR' => '03',
            'APR' => '04',
            'MAY' => '05',
            'JUN' => '06',
            'JUL' => '07',
            'AUG' => '08',
            'SEP' => '09',
            'OCT' => '10',
            'NOV' => '11',
            'DEC' => '12',
        );

        if( $date =~ /(\d{4}).*(\w{3})/ ) # YYYY  MMM <- note the two spaces in between
        {
            $dateBegin = sprintf("%04d-%02d-%02d", $1, $months{uc($2)}, 1);
            $dateEnd =   sprintf("%04d-%02d-%02d", $1, $months{uc($2)}, Days_in_Month($1, $months{uc($2)}));
        }
    }

    return ($dateBegin, $dateEnd);

}

sub _isValidSaleRecord {
    my $self = shift;
    
    if (!$self->units && !$self->price) {
        return 0;   
    }
    
    my $country = $self->_getByFieldName( 'countryCode' );
    my $format  = $self->_getByFieldName( 'formatType' );
    if ($country =~ /^Total$/i || ('' eq $country && '' eq $format) ) {
        return 0;   
    }    
    
    # For albums, we need either a UPC or Album Name
    if ( $self->productType eq RPS::File::Sale::TYPE_ALBUM ) {
        if ( $self->albumName || $self->upc ) {
            return 1;
        } else {
            $self->fail( "Missing title and upc for album product" );
        }
    }

    # For tracks, we need either an ISRC or Track Name
    if ( $self->productType eq RPS::File::Sale::TYPE_TRACK ) {
        if ( $self->trackName || $self->isrc ) {
            return 1;
        } else {
            $self->fail( "Missing title and isrc for track product" );
        }            
    }    

    return $self->SUPER::_isValidSaleRecord();
}


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