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

use strict;

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

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

# Tech Note: There are three ever-so-slightly different Zvook headers covered by
# this importer version: subscription/streaming, download/tracks and
# download/releases.  The first two are mostly the same -- just some slight
# differences in the column header text.  The last one (download/releases) takes
# it a step further and puts the artist and units data in different columns,
# hence the extra logic in the artistName() and units() methods.
#
sub _fieldMap {
    {
        dateBegin   => 'A5',
        productType => 'A6',
        formatType  => 'A6',
        artistName  => 'E',
        isrc        => 'B',
        upc         => 'B',
        trackName   => 'C',
        albumName   => 'C',
        units       => 'F',
        price       => 'K',
    },
    ;
}

sub _unverifiedFieldMap {
    {
        # The following are for the download/releases tab only.
        # All others use the 'artistName' and 'units' column.
        #
        altArtistName => 'D',
        altUnits      => 'E',
    };
}

sub _headerIdentifier { ( price => qr/^Total Sum for Licensor/i ) }

sub countryCode { 'RU' }
sub mediaType   { RPS::DB::Item::MediaType::kMediaTypeAudio }

sub currencyCode { shift->{_currencyCode} }    # See _isHeader

sub artistName {
    my $self = shift;
    return $self->{_isDownloadReleasesSheet} ? $self->_getByFieldName('altArtistName') : $self->_getByFieldName('artistName');
}

sub productType {
    my $self = shift;

    return $self->{_productType} if ( $self->{_productType} );

    my $type = $self->_getByFieldName('productType');
    if ( $type =~ /^(streaming|subscription|download\: tracks)$/i ) {
        $self->{_productType} = RPS::File::Sale::TYPE_TRACK;
    } elsif ( $type =~ /^download\: releases$/i ) {
        $self->{_productType} = RPS::File::Sale::TYPE_ALBUM;
    } else {
        $self->fail("Could not parse product type from '$type'");
    }
}

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

    return $self->{_formatType} if ( $self->{_formatType} );

    my $type = $self->_getByFieldName('formatType');
    if ( $type =~ /^streaming$/i ) {
        $self->{_formatType} = RPS::File::Sale::FORMAT_STREAM;
    } elsif ( $type =~ /^subscription$/i ) {
        $self->{_formatType} = RPS::File::Sale::FORMAT_TETHERED;
    } elsif ( $type =~ /^download\: (tracks|releases)$/i ) {
        $self->{_formatType} = RPS::File::Sale::FORMAT_DOWNLOAD;
    } else {
        $self->fail("Could not parse format type from '$type'");
    }
}

sub saleDates {
    my $self = shift;

    return ( $self->{_dateBegin}, $self->{_dateEnd} ) if ( $self->{_dateBegin} );

    my $dt = $self->_getByFieldName('dateBegin');

    my ( $startDate, $endDate ) = $self->_getDates( date_begin => $dt );

    if ( $startDate && $endDate ) {
        ( $self->{_dateBegin}, $self->{_dateEnd} ) = ( $startDate, $endDate );
    } else {
        $self->fail("Could not date from '$dt'");
    }
}

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

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

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

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

sub units {
    my $self = shift;

    my $units = $self->{_isDownloadReleasesSheet} ? $self->_getByFieldName('altUnits') : $self->_getByFieldName('units');
    my $price = $self->_getByFieldName('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() );
}

sub _isHeader {
    my $self = shift;

    # Grab the currency code from the header if we haven't already done so
    #
    if ( !$self->{_currencyCode} ) {
        my $price = $self->_getByFieldName('price');
        if ( $price =~ /Total Sum For Licensor \((\w{3})\)/i ) {
            $self->{_currencyCode} = $1;
        }
    }
    return $self->SUPER::_isHeader();
}

sub _processSheet {
    my $self     = shift;
    my $sheet    = shift;
    my $sheetnum = shift;
    my $version  = $self->_version;

    # Reset our custom attributes for each sheet. These can vary from
    # sheet to sheet, so we reset them before we process the sheet.
    #
    $self->{_currencyCode}            = undef;
    $self->{_productType}             = undef;
    $self->{_formatType}              = undef;
    $self->{_dateBegin}               = undef;
    $self->{_dateEnd}                 = undef;
    $self->{_isDownloadReleasesSheet} = undef;

    # Check if we're dealing with the 'Releases' tab of a download file.
    # If so, then flag it so we know where to find the artist and units info.
    #
    $self->{_isDownloadReleasesSheet} = 1 if ( $self->{sheetname} =~ /^releases$/i );

    # Process the detail lines
    #
    $self->RPS::Import::Importer::_processSheet( $sheet, $sheetnum );
}
###
1;    # Play nicely.
###