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

use strict;

use Date::Calc qw(Days_in_Month Decode_Month);

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

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

sub _fieldMap {
    my $self      = shift;
    my $sheetType = $self->{_sheetType};

    my %field_map = (
        'EU' => {
            labelName   => 'A',
            serviceID   => 'D',
            countryCode => 'E',
            dateBegin   => 'F',
            dateEnd     => 'F',
            artistName  => 'B',
            units       => 'K',
            isrc        => 'H',    # can be ISRC or catalogID
            price       => 'N',
        },
        'US' => {
            labelName => 'A',
            upc       => 'I',
            albumName => 'C',
            isrc      => 'G',
            trackName => 'F',
        },
    );
    return $field_map{$sheetType};
}

sub _unverifiedFieldMap {
    my $self      = shift;
    my $sheetType = $self->{_sheetType};

    my %field_map = (
        'US' => {
            config              => 'D',
            downloadQT          => 'K',
            downloadAM          => 'L',
            streamPremiumQT     => 'M',
            streamPremiumAM     => 'N',
            streamAdSupportedQT => 'O',
            streamAdSupportedAM => 'P',
            lockerQT            => 'Q',
            lockerAM            => 'R',
            otherQT             => 'S',
            otherAM             => 'T',
            trackArtist         => 'E',
            albumArtist         => 'B',
        },
        'EU' => {
            format => 'J',
            title  => 'C',    # album or track title
        },
    );
    return $field_map{$sheetType};
}

sub _headerIdentifier { ( isrc => qr/ISRC/ ) }

sub serviceID {
    my $self = shift;
    return undef if ( !exists $self->_fieldMap->{'serviceID'} );

    my $service = $self->_getByFieldName('serviceID');
    my $serviceID = $self->getServiceID( lc($service) ) || $RPS::Import::ServiceMap::SERVICE_ALIASES{ lc $service };

    return $serviceID if ($serviceID);
    return $self->fail("Unknown service: $service");
}

sub countryCode {
    my $self = shift;
    if ( exists $self->_fieldMap->{'countryCode'} ) {
        my $cname = $self->_getByFieldName('countryCode');
        my $o     = Common::Country->Get($cname);
        return ( defined $o ) ? $o->alpha2() : $cname;
    }
    return 'US';
}

sub saleDates {
    my $self = shift;
    my $dateBegin;
    my $dateEnd;

    if ( exists $self->_fieldMap->{'dateBegin'} ) {
        my $sDate = $self->_getByFieldName('dateBegin');
        my $eDate = $self->_getByFieldName('dateEnd');
        ( $dateBegin, $dateEnd ) = $self->_getDates( date_begin => $sDate, date_end => $eDate );
    } else {
        if ( !$self->{_dateBegin} ) {
            my $sheetName = $self->{sheetname};
            if ( $sheetName =~ /^(\d{2})\.(\d{2}) US Digital$/i ) {
                my ( $month, $year ) = ( $1, $2 );
                $year += 2000;
                $dateBegin = sprintf( "%04d-%02d-%02d", $year, $month, 1 );
                $dateEnd = sprintf( "%04d-%02d-%02d", $year, $month, Days_in_Month( $year, $month ) );
            }
            $self->{_dateBegin} = $dateBegin;
            $self->{_dateEnd}   = $dateEnd;
        }
        ( $dateBegin, $dateEnd ) = ( $self->{_dateBegin}, $self->{_dateEnd} );
    }
    return ( $dateBegin, $dateEnd );
}

sub serviceProductID {
    my $self = shift;
    if ( $self->{_sheetType} eq 'EU' ) {
        my $catalogNo = $self->_getByFieldName('isrc');
        return ( $self->productType eq RPS::File::Sale::TYPE_ALBUM ) ? $catalogNo : undef;
    }
}

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

sub _processHeader {
    my $self = shift;

    unless ( $self->{_currencyCode} ) {
        if ( $self->{_sheetType} eq 'EU' ) {
            my $st = $self->_getByFieldName('price');
            if ( $st =~ /^NET SALES (\w{3})$/i ) {
                $self->{_currencyCode} = $1;
            }
        } elsif ( $self->{_sheetType} eq 'US' ) {
            $self->{_currencyCode} = 'USD';
        }
    }
}

sub currencyCode {
    shift->{_currencyCode};    # set in _processHeader
}

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

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

sub artistName {
    my $self = shift;
    return $self->SUPER::artistName() if ( exists $self->_fieldMap->{'artistName'} );    # EU sales

    # US sales
    my $albumArtist = $self->_getByFieldName('albumArtist');
    my $trackArtist = $self->_getByFieldName('trackArtist');
    return ( $self->productType eq RPS::File::Sale::TYPE_ALBUM ) ? $albumArtist : $trackArtist;
}

sub productType {
    my $self = shift;
    my $type;
    if ( exists $self->_unverifiedFieldMap->{format} )                                   # EU sales
    {
        $type = $self->_getByFieldName('format');
        if (   $type =~ /^AD-FUNDED STREAM$/i
            || $type =~ /^DIGITAL (SINGLE|STREAM|TRACK|VIDEO)$/i
            || $type =~ /^PREMIUM STREAM$/i ) {
            return RPS::File::Sale::TYPE_TRACK;
        } elsif ( $type =~ /^DIGITAL ALBUM$/i ) {
            return RPS::File::Sale::TYPE_ALBUM;
        }
    } elsif ( exists $self->_unverifiedFieldMap->{config} )                              # US sales
    {
        $type = $self->_getByFieldName('config');
        if (   $type =~ /^Digital Audio Extended Play$/i
            || $type =~ /^Digital Audio LongPlay$/i ) {
            return RPS::File::Sale::TYPE_ALBUM;
        } elsif ( $type =~ /^Digital (Audio|Video) Track$/i ) {
            return RPS::File::Sale::TYPE_TRACK;
        }
    }
    return $self->fail("Unable to determine product type from '$type'");
}

sub formatType {
    my $self = shift;

    if ( $self->{_sheetType} eq 'EU' ) {
        my $type;
        if ( exists $self->_unverifiedFieldMap->{format} )    # EU sales
        {
            $type = $self->_getByFieldName('format');

            if (   $type =~ /^AD-FUNDED STREAM$/i
                || $type =~ /^DIGITAL (STREAM|VIDEO)$/i
                || $type =~ /^PREMIUM STREAM$/i ) {
                return RPS::File::Sale::FORMAT_STREAM;
            } elsif ( $type =~ /^DIGITAL (ALBUM|SINGLE|TRACK)$/i ) {
                return RPS::File::Sale::FORMAT_DOWNLOAD;
            }
        }
        return $self->fail("Unable to determine format type from '$type'");
    }
    return $self->{_formatType};    # set in _saveLine for US sales (below)
}

sub mediaType {
    my $self = shift;

    if ( $self->{_sheetType} eq 'EU' ) {
        my $type = $self->_getByFieldName('format');

        if (   $type =~ /^AD-FUNDED STREAM$/i
            || $type =~ /^DIGITAL (ALBUM|SINGLE|STREAM|TRACK)$/i
            || $type =~ /^PREMIUM STREAM$/i ) {
            return RPS::DB::Item::MediaType::kMediaTypeAudio;
        } elsif ( $type =~ /^DIGITAL VIDEO$/i ) {
            return RPS::DB::Item::MediaType::kMediaTypeVideo;
        }
        return $self->fail("Unable to determine media type from '$type'");
    } else {

        # (US) sales
        my $type = $self->_getByFieldName('config');
        if (   $type =~ /^Digital Audio Extended Play$/i
            || $type =~ /^Digital Audio LongPlay$/i
            || $type =~ /^Digital Audio Track$/i ) {
            return RPS::DB::Item::MediaType::kMediaTypeAudio;
        } elsif ( $type =~ /^Digital Video Track$/i ) {
            return RPS::DB::Item::MediaType::kMediaTypeVideo;
        }
    }
}

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

    my $num = scalar @$sheet;

    # If we have a physical tab, make sure it doesn't have any lines in it.
    # if it's empty then we'll skip it and go on processing the rest of the
    # file, otherwise we'll error out.
    #
    if ( $self->{sheetname} =~ /us digital/i ) {
        $self->{_sheetType} = 'US';
        return $self->SUPER::_processSheet( $sheet, $sheetnum );
    } elsif ( $self->{sheetname} =~ /eu digital/i ) {
        $self->{_sheetType} = 'EU';
        return $self->SUPER::_processSheet( $sheet, $sheetnum );
    } else {
        $self->fail( "Found unknown sheet '" . $self->{sheetname} . "'" );
    }
}

sub _unitPrice {
    my $self = shift;
    return $self->SUPER::_unitPrice() if ( exists $self->_fieldMap->{units} );    # EU
    return $self->{_unitPrice};                                                   # set in _saveLine (below)
}

sub units {
    my $self = shift;
    return $self->_getByFieldName('units') if ( exists $self->_fieldMap->{units} );    # EU
    return $self->{_units};                                                            # set in _saveLine (below)
}

sub price {
    my $self = shift;
    return $self->_getByFieldName('price') if ( exists $self->_fieldMap->{price} );    # EU
    return $self->{_price};                                                            # set in _saveLine (below)
}

# We can have units from two different columns so we need to override
# _isValidSaleRecord to process lines with units in either location.
#
sub _isValidSaleRecord {
    my $self = shift;
    my $title;
    my $revenue = 0;
    my $units   = 0;

    if ( $self->{_sheetType} eq 'EU' ) {
        $revenue = $self->_getByFieldName('price');
        $units   = $self->_getByFieldName('units');
        $title   = $self->_getByFieldName('title');
    } else {

        # gather units...
        my $downloadQT          = $self->_getByFieldName('downloadQT');
        my $streamPremiumQT     = $self->_getByFieldName('streamPremiumQT');
        my $streamAdSupportedQT = $self->_getByFieldName('streamAdSupportedQT');
        my $lockerQT            = $self->_getByFieldName('lockerQT');
        my $otherQT             = $self->_getByFieldName('otherQT');

        # gather revenue...
        my $downloadAM          = $self->_getByFieldName('downloadAM');
        my $streamPremiumAM     = $self->_getByFieldName('streamPremiumAM');
        my $streamAdSupportedAM = $self->_getByFieldName('streamAdSupportedAM');
        my $lockerAM            = $self->_getByFieldName('lockerAM');
        my $otherAM             = $self->_getByFieldName('otherAM');

        $units   = $downloadQT + $streamPremiumQT + $streamAdSupportedQT + $lockerQT + $otherQT;
        $revenue = $downloadAM + $streamPremiumAM + $streamAdSupportedAM + $lockerAM + $otherAM;
        $title   = $self->_getByFieldName('albumName') || $self->_getByFieldName('trackName');
    }

    # line is valid if it has units and/or revenue, and a title
    #
    return ( ( $revenue || $units ) && $title );
}

# By default, _saveLine will create a single sale record.  The 'US'
# tab may have multiple formats on a single line, so we'll need to create
# multiple sale records for a line (one per format) in order to capture
# those sales.
#
sub _saveLine {
    my $self = shift;

    # For the EU tab, just call normal _saveLine, otherwise we'll have to do a
    # little juggling before we save anything (this is so we can create separate
    # sale records records for download and/or stream sales).
    #
    if ( $self->{_sheetType} eq 'EU' ) {
        $self->SUPER::_saveLine();
    } else {

        # gather units...
        my $downloadQT          = $self->_getByFieldName('downloadQT');
        my $streamPremiumQT     = $self->_getByFieldName('streamPremiumQT');
        my $streamAdSupportedQT = $self->_getByFieldName('streamAdSupportedQT');
        my $lockerQT            = $self->_getByFieldName('lockerQT');
        my $otherQT             = $self->_getByFieldName('otherQT');

        my $downloadUnits = $downloadQT;
        my $streamUnits   = $streamPremiumQT + $streamAdSupportedQT + $lockerQT + $otherQT;

        # gather revenue...
        my $downloadAM          = $self->_getByFieldName('downloadAM');
        my $streamPremiumAM     = $self->_getByFieldName('streamPremiumAM');
        my $streamAdSupportedAM = $self->_getByFieldName('streamAdSupportedAM');
        my $lockerAM            = $self->_getByFieldName('lockerAM');
        my $otherAM             = $self->_getByFieldName('otherAM');

        my $downloadRevenue = $downloadAM;
        my $streamRevenue   = $streamPremiumAM + $streamAdSupportedAM + $lockerAM + $otherAM;

        if ( $downloadUnits || $downloadRevenue ) {
            $self->{_formatType} = RPS::File::Sale::FORMAT_DOWNLOAD;
            $self->{_units}      = $downloadUnits;
            $self->{_price}      = $downloadRevenue;
            my $unitPrice = ($downloadUnits) ? $downloadRevenue / $downloadUnits : $downloadRevenue;
            $self->{_unitPrice} = $unitPrice;
            $self->SUPER::_saveLine();
        }

        if ( $streamUnits || $streamRevenue ) {
            $self->{_formatType} = RPS::File::Sale::FORMAT_STREAM;
            $self->{_units}      = $streamUnits;
            $self->{_price}      = $streamRevenue;
            my $unitPrice = ($streamUnits) ? $streamRevenue / $streamUnits : $streamRevenue;
            $self->{_unitPrice} = $unitPrice;
            $self->SUPER::_saveLine();
        }
    }
}

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