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

package RPS::Import::Puretracks::v13;

use strict;

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

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

# The same columns are used for both album and track sales, which
# appear on different sheets, however the columns are actually shifted
# over on the album sheet.  See _getOffset, below.
#
sub _fieldMap {
    {
        labelName        => 'F',
        dateBegin        => 'A',

        serviceProductID => 'E',
        mediaType        => 'B',
        artistName       => 'H',
        upc              => 'C',
        isrc             => 'D',
        units            => 'J',
    }
}

sub _unverifiedFieldMap {
    {
        wholesale       => 'L',
        publishing      => 'M',
        title           => 'I', # can be either album or track title, depending on the sheet
    }
}

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

sub currencyCode { 'USD' };  # applies to both US and CA sales

sub saleDates {
    my $self = shift;
    my $startDate = $self->_getDateBegin();

    if( $startDate =~ /^\d{5}$/ )
    {
        $startDate =  Spreadsheet::ParseExcel::Utility::ExcelFmt( "yyyy-mm-dd", $startDate );
    }
    return $self->_getDates( date_begin => $startDate );
}

sub countryCode {

    # Determined from filename (see _preProcess)
    #
    my $self = shift;
    $self->fail("Filename doesn't contain CA or US") if( !$self->{_countryCode} );
    return $self->{_countryCode};
}

sub productType {
    my $self = shift;

    # from sheet header.. see _processSheet
    #
    return $self->{_productType};
}

sub price {
    my $self = shift;
    my $wholesale  = $self->_getByFieldName('wholesale');
    my $publishing = $self->_getByFieldName('publishing');
    return $wholesale - $publishing;
}

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

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

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

sub formatType {
    my $self = shift;
    my $type = $self->_getByFieldName('mediaType');
    if( $type =~ /^mp3$/i )
    {
        return RPS::File::Sale::FORMAT_DOWNLOAD;
    }
    $self->fail("Unable to determine media type from '$type'");
}

sub mediaType {
    my $self = shift;
    my $type = $self->_getByFieldName('mediaType');
    if( $type =~ /^mp3$/i )
    {
        return RPS::DB::Item::MediaType::kMediaTypeAudio;
    }
    $self->fail("Unable to determine media type from '$type'");
}

sub _preProcess {

    my $self = shift;

    my %args = @_;
    my $fileName = $args{file}->OrigFileName();

    my $countryCode;

    # If the filename starts with "CA" or "CANADA", followed by spaces or an underscore or period,
    # then assume it's Canadian.
    # If the filename starts with "US" or "USA", followed by spaces or an underscore or period,
    # then assume it's US.
    #
    if ( $fileName =~ /^ca(nada)?(\s+|_|\.)/i )
    {
        $countryCode  = "CA";
    }
    elsif ( $fileName =~ /^us(a)?(\s+|_|\.)/i )
    {
        $countryCode  = "US";
    }
    else
    {
        return undef;
    }

    $self->{_countryCode}  = $countryCode;
}

# _processSheet is used to process a worksheet from the sales file.
#
# All we're doing here is determining the product type to be applied to all
# sales on the sheet. Also, we invoke the inherited _processSheet so that
# normal line processing occurs.
#
sub _processSheet {
    my $self     = shift;
    my $sheet    = shift;

    my $sheetnum = $self->{sheetnum};

    $self->{_productType} = "";

    # prevents shifting of album columns; we'll change this if we
    # detect that the album columns are in fact shifted over
    #
    $self->{_noshift} = 1;

    my $productType;

    if( $sheetnum > 0 )
    {
        my $headerFound;
        my $checkHeader;

        foreach my $line (@$sheet)
        {
            $self->{line} = $line;

            if( $self->_isHeader() )
            {
                $headerFound = 1;
            }

            if( !$headerFound && !$productType )
            {
                if( $line->[0] =~ /^album sales$/i )
                {
                    $productType = RPS::File::Sale::TYPE_ALBUM;
                    $checkHeader = 1;
                }
                elsif( $line->[0] =~ /^track sales$/i )
                {
                    $productType = RPS::File::Sale::TYPE_TRACK;
                }
                next;
            }

            if( $checkHeader )
            {
                # peek at the next line on the album worksheet (which should be the
                # header) and see if the header identifier is where we expect it or
                # it's one column to the right.
                #
                my ( $field, $value ) = $self->_headerIdentifier();
                if( ref($field) )
                {
                    my ($key) = keys(%$field);
                    $value    = $field->{$key};
                    $field    = $key;
                }

                my $offset = $self->_getOffset( $field );

                if( defined($line->[$offset]) && $line->[$offset] eq $value )
                {
                    #print STDERR "_preProcess: album columns are in same position as track columns\n";
                    $self->{_noshift} = 1; # no shifting required for album columns
                }
                elsif( defined($line->[$offset+1]) && $line->[$offset+1] eq $value )
                {
                    #print STDERR "_preProcess: album columns are shifted relative to track columns\n";
                    $self->{_noshift} = 0; # shifting required for album columns
                }

                undef $checkHeader;

            }
        }
    }

    $self->{_productType} = $productType if( $productType );

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


# The album sheet (sheet #2) has the same column headings as the track sheet (sheet #3),
# however its columns MIGHT be shifted over by one because the 'DATE' column (column A) has
# been merged with column B.  E.g., the date is in column A on the track sheet, but takes
# up A + B on the album sheet.  The rest of the columns ('MEDIA TYPE', 'UPC', etc.) are
# in the same relative position after the DATE column.
#
# To accomodate the shift, we override _getOffset and adjust the index values for
# sheet #2.  This allows the same fieldMap to be used for both the album and track sheets.
#
sub _getOffset {
    my $self = shift;
    my $field = shift;

    my $offset = $self->SUPER::_getOffset( $field );

    return undef if( !defined $offset );

    # noshift is set if we previously detected that the album
    # columns are in the same location at the track columns.
    # If it isn't set, then shift the columns on sheet #2. 
    #
    return $offset if( $self->{_noshift} );

    my $sheetnum = $self->sheetnum;

    my $_offset = ( $sheetnum == 2) ? ($offset + 1 ) : $offset;

    return $_offset;
}

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