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

use strict;

use Date::Calc qw(Days_in_Month Decode_Month);

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

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

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

    my %field_map = (
        'EU' => {
            labelName    => 'A',
            countryCode  => 'E',
            dateBegin    => 'F',
            dateEnd      => 'F',
            artistName   => 'B',
            albumName    => 'C',
            upc          => 'I',
            totalRevenue => 'N',
        },
        'NA' => {
            labelName      => 'A',
            countryCode    => 'B',
            artistName     => 'C',
            upc            => 'G',
            albumName      => 'D',
            sales          => 'I',
            salesRevenue   => 'J',
            returns        => 'K',
            returnsRevenue => 'L',
            totalRevenue   => 'N',
        },
    );
    return $field_map{$sheetType};
}

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

    my %field_map = (
        'NA' => {
            prefix    => 'E',
            suffix    => 'F',
            catalogNo => 'H',
        },
        'EU' => {
            config     => 'J',
            catalogNo  => 'H',
            netUnits   => 'K',
            netRevenue => 'N',
        },
    );
    return $field_map{$sheetType};
}

sub _headerIdentifier { ( albumName => qr/TITLE/ ) }

sub currencyCode { 'USD'; }

sub channel { RPS::File::Sale::CHANNEL_RETAIL; }

sub priceLevel { RPS::File::Sale::PLEVEL_UNKNOWN; }

sub physical { 1; }

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}) NA Physical$/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 sales {
    my $self = shift;
    my $sales;
    if ( exists $self->_fieldMap->{'sales'} ) {
        $sales = $self->_getByFieldName('sales');
    } else {
        $sales = $self->_getByFieldName('netUnits');
    }
    return ( $sales > 0 ) ? $sales : 0;
}

sub salesRevenue {
    my $self = shift;
    my $salesRevenue;
    if ( exists $self->_fieldMap->{'salesRevenue'} ) {
        $salesRevenue = $self->_getByFieldName('salesRevenue');
    } else {
        $salesRevenue = $self->_getByFieldName('netRevenue');
    }
    return ( $salesRevenue > 0 ) ? $salesRevenue : 0;
}

sub returns {
    my $self = shift;
    if ( exists $self->_fieldMap->{'returns'} ) {

        # Check for returns masquerading as sales
        #
        my $sales   = $self->_getByFieldName('sales');
        my $returns = $self->_getByFieldName('returns');
        $returns = ( $sales < 0 ) ? ( $returns + $sales ) : $returns;
        return abs($returns);
    }

    my $qty = $self->_getByFieldName('netUnits');
    return ( $qty < 0 ) ? abs($qty) : 0;
}

sub returnsRevenue {
    my $self = shift;
    if ( exists $self->_fieldMap->{'returnsRevenue'} ) {

        # Check for returns masquerading as sales
        #
        my $salesRevenue   = $self->_getByFieldName('salesRevenue');
        my $returnsRevenue = $self->_getByFieldName('returnsRevenue');
        $returnsRevenue = ( $salesRevenue < 0 ) ? ( $returnsRevenue + $salesRevenue ) : $returnsRevenue;
        return abs($returnsRevenue);
    }

    my $amt = $self->_getByFieldName('netRevenue');
    return ( $amt < 0 ) ? abs($amt) : 0;
}

sub clientProductID {
    my $self      = shift;
    my $catalogNo = $self->_getByFieldName('catalogNo');
    if ( $self->{_sheetType} eq 'NA' ) {
        my $prefix = $self->_getByFieldName('prefix');
        if ( $prefix =~ /^obr$/i ) {
            $catalogNo = $self->_getByFieldName('upc');
        }
    }
    return $catalogNo;
}

sub upc {
    my $self = shift;
    my $upc  = $self->_getByFieldName('upc');
    if ( $self->{_sheetType} eq 'NA' ) {
        my $prefix = $self->_getByFieldName('prefix');
        if ( $prefix =~ /^obr$/i ) {
            $upc = $self->_getByFieldName('catalogNo');
        }
    }
    return $upc;
}

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

    my $artistName = $name;

    if ( $name =~ /(\w+),\s+(.*)$/i )    # lastname, firstname
    {
        $artistName = $2 . " " . $1;
    }
    return $artistName;
}

sub productType {
    my $self = shift;
    my $type;
    if ( $self->{_sheetType} eq 'EU' ) {
        $type = $self->_getByFieldName('config');
    } elsif ( $self->{_sheetType} eq 'NA' ) {
        $type = $self->_getByFieldName('prefix');
        if ( $type =~ /^OBR$/i ) {

            # The suffix may be of the form NNNNN-XX, where XX is the config
            # we're looking for.
            #
            $type = $self->_getByFieldName('suffix');
            $type = $1 if ( $type =~ /(?:\w)+-(\w{2})$/ );
            return RPS::File::Sale::TYPE_CD if ( !$type or '' eq $type );    # default to CD if no explicit config
        }
    }

    if ( $type =~ /^CD$/i ) {
        return RPS::File::Sale::TYPE_CD;
    } elsif ( $type =~ /^LP$/i ) {
        return RPS::File::Sale::TYPE_LP;
    } elsif ( $type =~ /^(DVD|VD|DV)$/i ) {
        return RPS::File::Sale::TYPE_DVD;
    }
    return $self->fail("Unable to determine product type from '$type'");
}

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} =~ /na physical/i ) {
        $self->{_sheetType} = 'NA';
        return $self->SUPER::_processSheet( $sheet, $sheetnum );
    } elsif ( $self->{sheetname} =~ /eu physical/i ) {
        $self->{_sheetType} = 'EU';
        return $self->SUPER::_processSheet( $sheet, $sheetnum );
    } else {
        $self->fail( "Found unknown sheet '" . $self->{sheetname} . "'" );
    }
}

# 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 = $self->_getByFieldName('albumName');
    my $sales;
    my $returns;

    if ( $self->{_sheetType} eq 'EU' ) {
        my $units = $self->_getByFieldName('netUnits');
        $sales   = ( $units > 0 ) ? $units : 0;
        $returns = ( $units < 0 ) ? $units : 0;
    } else {
        $sales   = $self->_getByFieldName('sales');
        $returns = $self->_getByFieldName('returns');
    }

    # line is valid if it has units and a title
    #
    return ( ( $sales || $returns ) && $title );
}

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