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

package RPS::Import::Sony::v14;

use strict;

use Date::Calc qw(Days_in_Month);

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

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

sub _fieldMap {
    {
        dateBegin  => 'A',
        dateEnd    => 'A',
        artistName => 'C',
        upc        => 'B',
        albumName  => 'D',
        isrc       => 'B',
        trackName  => 'D',
        units      => 'I',    # Digital Net Qty
    };
}

sub _unverifiedFieldMap {
    {
        configurationType  => 'E',
        distributionManner => 'H',
        commission         => 'K',    # Commission %
        digitalNetValue    => 'J',    # Digital Net Value

        # The following are shifted on the NZ tab
        #
        unitsNZ           => 'J',    # Digital Net Qty
        digitalNetValueNZ => 'K',    # Digital Net Value
        commissionNZ      => 'L',    # Commission %
    };
}

sub _headerIdentifier { ( 'upc' => 'Catalog' ) }

sub countryCode {
    my $self = shift;
    return $self->{_countryCode};
}

sub currencyCode { 'AUD' }

sub saleDates {
    my $self  = shift;
    my $begin = $self->_getByFieldName('dateBegin');
    my $end   = $self->_getByFieldName('dateEnd');
    if ( $begin =~ /(\d{4})(\d{1,2})/ ) {
        $begin = sprintf( "%04d-%02d-%02d", $1, $2, 1 );
    } else {
        $self->fail("Unexpected date begin format: $begin");
    }
    if ( $end =~ /(\d{4})(\d{1,2})/ ) {
        $end = sprintf( "%04d-%02d-%02d", $1, $2, Days_in_Month( $1, $2 ) );
    } else {
        $self->fail("Unexpected date end format: $end");
    }

    return ( $begin, $end ) if ($begin);
}

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

    if (   $config =~ /^digital\s+(audio|video) track$/i
        || $config =~ /^mastertone$/i
        || $config =~ /^digital download (single|video) track$/i
        || $config =~ /^ringback tone$/i ) {
        return RPS::File::Sale::TYPE_TRACK;
    } else {
        return RPS::File::Sale::TYPE_ALBUM;
    }

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

my %formatMediaMap = (
    'digital audio longplay' => {
        'n' => {
            format => RPS::File::Sale::FORMAT_STREAM,
            media  => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'y' => {
            format => RPS::File::Sale::FORMAT_DOWNLOAD,
            media  => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
    },

    # there are intentionally two spaces between digital and audio in the next line
    'digital  audio longplay' => {
        'n' => {
            format => RPS::File::Sale::FORMAT_STREAM,
            media  => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'y' => {
            format => RPS::File::Sale::FORMAT_DOWNLOAD,
            media  => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
    },
    'digital audio track' => {
        'n' => {
            format => RPS::File::Sale::FORMAT_STREAM,
            media  => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'y' => {
            format => RPS::File::Sale::FORMAT_DOWNLOAD,
            media  => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
    },
    'digital video track' => {
        'n' => {
            format => RPS::File::Sale::FORMAT_STREAM,
            media  => RPS::DB::Item::MediaType::kMediaTypeVideo,
        },
    },
    'digital video longform' => {
        'n' => {
            format => RPS::File::Sale::FORMAT_STREAM,
            media  => RPS::DB::Item::MediaType::kMediaTypeVideo,
        },
        'y' => {
            format => RPS::File::Sale::FORMAT_DOWNLOAD,
            media  => RPS::DB::Item::MediaType::kMediaTypeVideo,
        },
    },
    'digital combo longform' => {
        'y' => {
            format => RPS::File::Sale::FORMAT_DOWNLOAD,
            media  => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
    },
    'mastertone' => {
        'n' => {
            format => RPS::File::Sale::FORMAT_STREAM,
            media  => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'y' => {
            format => RPS::File::Sale::FORMAT_RINGTONE,
            media  => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
    },
    'digital audio extended play' => {
        'y' => {
            format => RPS::File::Sale::FORMAT_DOWNLOAD,
            media  => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
    },
    'digital maxi single' => {
        'y' => {
            format => RPS::File::Sale::FORMAT_DOWNLOAD,
            media  => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
    },
    'digital combo' => {
        'y' => {
            format => RPS::File::Sale::FORMAT_DOWNLOAD,
            media  => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
    },
    'digital download longplay' => {
        'y' => {
            format => RPS::File::Sale::FORMAT_DOWNLOAD,
            media  => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'n' => {
            format => RPS::File::Sale::FORMAT_STREAM,
            media  => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
    },
    'digital audio bundle' => {
        'y' => {
            format => RPS::File::Sale::FORMAT_DOWNLOAD,
            media  => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
    },
    'digital download single track' => {
        'y' => {
            format => RPS::File::Sale::FORMAT_DOWNLOAD,
            media  => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'n' => {
            format => RPS::File::Sale::FORMAT_STREAM,
            media  => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
    },
    'digital download maxi single' => {
        'y' => {
            format => RPS::File::Sale::FORMAT_DOWNLOAD,
            media  => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
    },
    'digital download combo' => {
        'y' => {
            format => RPS::File::Sale::FORMAT_DOWNLOAD,
            media  => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
    },
    'ringback tone' => {
        'n' => {
            format => RPS::File::Sale::FORMAT_RINGTONE,
            media  => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
    },
    'digital download video track' => {
        'y' => {
            format => RPS::File::Sale::FORMAT_DOWNLOAD,
            media  => RPS::DB::Item::MediaType::kMediaTypeVideo,
        },
        'n' => {
            format => RPS::File::Sale::FORMAT_STREAM,
            media  => RPS::DB::Item::MediaType::kMediaTypeVideo,
        },
    },
);

sub _getFormatMedia {
    my $self   = shift;
    my $config = shift;
    my $dist   = shift;
    foreach my $_config ( keys %formatMediaMap ) {
        next if ( $config !~ /^$_config$/i );

        foreach my $_dist ( keys %{ $formatMediaMap{$_config} } ) {
            next if ( $dist !~ /^$_dist$/i );
            return ( $formatMediaMap{$_config}{$_dist}->{format}, $formatMediaMap{$_config}{$_dist}->{media} );
            last;
        }
    }
}

sub formatType {
    my $self   = shift;
    my $config = $self->_getByFieldName('configurationType');
    my $dist   = $self->_getByFieldName('distributionManner');

    my ( $formatType, $mediaType ) = $self->_getFormatMedia( $config, $dist );

    $self->fail("Unable to determine format type from config($config) distributionManner($dist)") if ( !$formatType );

    return $formatType;
}

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

    my ( $formatType, $mediaType ) = $self->_getFormatMedia( $config, $dist );

    $self->fail("Unable to determine media type from config($config) distributionManner($dist)") if ( !$mediaType );

    return $mediaType;
}

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

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

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

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

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

    if ( $self->{_countryCode} =~ /^nz$/i ) {
        $commission      = $self->_getByFieldName('commissionNZ');
        $digitalNetValue = $self->_getByFieldName('digitalNetValueNZ');
    }

    return $digitalNetValue * ( 1 - $commission );
}

sub units {
    my $self = shift;
    my $units;
    my $price;

    if ( $self->{_countryCode} =~ /^nz$/i ) {
        $units = $self->_getByFieldName('unitsNZ') || return;
        $price = $self->_getByFieldName('digitalNetValueNZ');
    } else {
        $units = $self->_getByFieldName('units') || return;
        $price = $self->_getByFieldName('digitalNetValue');
    }

    # The 'sign' of the units is driven by the price.
    # If the price is negative, we'll store negative units,
    # regardless of whether the units were positive or negative
    # in the sale file.  Accordingly, the price is always
    # positive.  This ensures that returns are recorded correctly.
    #
    if ( defined($price) ) {
        return $price < 0 ? abs($units) * -1 : $units;
    } else {
        return $units;
    }
}

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

# _processSheet is used to process a tab from the spreadsheet.
# Here, we're extracting the sale date and label information
# from the cells called out in the template.
#
sub _processSheet {
    my $self     = shift;
    my $sheet    = shift;
    my $sheetnum = shift;

    if ( $self->{sheetname} =~ /^digital sales (\w+)\s*$/i ) {
        $self->{_countryCode} = $1;

        return $self->SUPER::_processSheet( $sheet, $sheetnum );
    }
}

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