#---------------------------------------------------------------
# ____                   _ _         ____  _
#|  _ \ ___  _   _  __ _| | |_ _   _/ ___|| |__   __ _ _ __ ___
#| |_) / _ \| | | |/ _` | | __| | | \___ \| '_ \ / _` | '__/ _ \
#|  _ < (_) | |_| | (_| | | |_| |_| |___) | | | | (_| | | |  __/
#|_| \_\___/ \__, |\__,_|_|\__|\__, |____/|_| |_|\__,_|_|  \___|
#            |___/             |___/
#
# Copyright (c) 2013-2014 RoyaltyShare, Inc. All Rights Reserved
#---------------------------------------------------------------
package RPS::Import::Sony::v22;

use strict;

use Date::Calc qw(Days_in_Month);

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

use lib '/app/tools/rps/lib';

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

sub _fieldMap {
    {
        dateBegin   => 'K',
        countryCode => 'I',
        albumName   => 'D',
        isrc        => 'E',
        units       => 'AA',
        price       => 'AC',
        productType => 'J',
        formatType  => 'L',
    };
}

sub _unverifiedFieldMap {
    {
        productArtist => 'C',
        trackArtist   => 'G',
        trackName     => 'F',
    };
}

sub _headerIdentifier { ( 'isrc' => 'Track number' ) }

sub currencyCode { 'CAD' }

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

    if ($name) {
        my $o = Common::Country->Get($name);
        return $o->alpha2 if ($o);
    }

    return $name;    # Return original name and let MapFace deal with it

}

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

    if ( $startDate =~ /(\d{4}) H(\d)/ ) {
        my $year = $1;
        my $half = $2;
        if ( $half eq '1' ) {
            $dateBegin = sprintf( "%04d-%02d-%02d", $year, 1, 1 );
            $dateEnd   = sprintf( "%04d-%02d-%02d", $year, 6, 30 );
        } elsif ( $half eq '2' ) {
            $dateBegin = sprintf( "%04d-%02d-%02d", $year, 7,  1 );
            $dateEnd   = sprintf( "%04d-%02d-%02d", $year, 12, 31 );
        }
    }
    return ( $dateBegin, $dateEnd );
}

sub artistName {
    my $self   = shift;
    my $config = $self->_getByFieldName('productType');

    if ( $self->productType() eq RPS::File::Sale::TYPE_TRACK
        || ( !defined $self->productType() && $config =~ /track/i ) ) {
        return $self->_getByFieldName('trackArtist');
    } elsif ( $self->productType() eq RPS::File::Sale::TYPE_ALBUM
        || ( !defined $self->productType() && $config =~ /lp/i ) ) {
        return $self->_getByFieldName('productArtist');
    }
}

sub free {
    my $self  = shift;
    my $units = $self->_getByFieldName('units');
    my $price = $self->_getByFieldName('price');
    return ( $units > 0 && 0 == $price ) ? 1 : 0;
}

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

    if ( $config =~ /^audio-lp$/i ) {
        return RPS::File::Sale::TYPE_ALBUM;
    } elsif ( $config =~ /^(aud|vid)-track$/i || $config =~ /^ring(back|tone)$/i ) {
        return RPS::File::Sale::TYPE_TRACK;
    } else {
        return $self->handleError( "Unknown config: $config", RPS::DB::Item::SaleImportError::kErrorProductType );
    }
}

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

    if ( $distChannel =~ /^streamin$/i || $distChannel =~ /^BRKG-(SUB|ONL)$/i || $distChannel =~ /^\s*$/i ) {
        return RPS::File::Sale::FORMAT_STREAM;
    } elsif ( $distChannel =~ /^mobile$/i ) {
        return RPS::File::Sale::FORMAT_RINGTONE;
    } elsif ( $distChannel =~ /^download$/i ) {
        return RPS::File::Sale::FORMAT_DOWNLOAD;
    } else {
        return $self->handleError( "Unknown distChannel: $distChannel", RPS::DB::Item::SaleImportError::kErrorFormatType );
    }
}

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

    if ( $config =~ /^aud-track$/i || $config =~ /^audio-lp$/i || $config =~ /^ring(back|tone)$/i ) {
        return RPS::DB::Item::MediaType::kMediaTypeAudio;
    } elsif ( $config =~ /^vid-track$/i ) {
        return RPS::DB::Item::MediaType::kMediaTypeVideo;
    } else {
        return $self->handleError( "Unknown config: $config", RPS::DB::Item::SaleImportError::kErrorMediaType );
    }
}

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

    $units =~ s/,//;

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

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

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

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

    return $name if ( $self->productType() eq RPS::File::Sale::TYPE_ALBUM );

    if ( !defined $self->productType() ) {
        my $config = $self->_getByFieldName('productType');
        return $name if ( $config =~ /lp/i );    # if the config has 'lp', it's probably an album
    }
}

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

    $name = $self->_getByFieldName('trackName');
    $name = $self->_getByFieldName('albumName') if ( '' eq $name );

    return $name if ( $self->productType() eq RPS::File::Sale::TYPE_TRACK );

    if ( !defined $self->productType() ) {
        my $config = $self->_getByFieldName('productType');
        return $name if ( $config =~ /track/i );    # if the config has 'track', it's probably a track
    }
}

sub _isValidSaleRecord {
    my $self = shift;

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

    # In order to catch invalid product types with MapFace,
    # we'll relax the _isValidSaleRecord criteria a little --
    # if there's a config defined BUT it's not a valid RPS
    # product type, then allow the line as long as it has
    # units (the album/track name info will be empty since it
    # is populated only once we have a valid RPS product type).
    #
    return 1
      if ( defined( $self->units )
        && $config
        && $self->productType ne RPS::File::Sale::TYPE_ALBUM
        && $self->productType ne RPS::File::Sale::TYPE_TRACK );

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

#####    MapFace    #####
#

sub _mapFaceServiceID {
    return ('serviceID');
}

sub _mapFaceCountryCode {
    return ('countryCode');
}

sub _mapFaceProductType {
    return ('productType');
}

sub _mapFaceFormatType {
    return ('formatType');
}

sub _mapFaceMediaType {
    return ('productType');
}

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