package RPS::Import::Merlin::v7;

use strict;

use lib '/app/tools/common/lib';
use Common::Date;

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

use Data::Dumper;

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

sub _fieldMap {
    {
        dateBegin   => 'C', 
        dateEnd     => 'D',                      
        serviceID   => 'E',
        countryCode => 'F',
        formatType  => 'G',
        productType => 'I',
        mediaType   => 'I',
        units       => 'J',
        isrc        => 'K',
        upc         => 'L',
        artistName  => 'N',
        trackName   => 'O',
        albumName   => 'P',
        labelName   => 'Q',
        price       => 'AE',
    }
}

sub _unverifiedFieldMap {
    {
        distFee     => 'AF',
    }
}

sub currencyCode { 'USD' }

sub productType
{
    my $self = shift;
    my $type = $self->_getByFieldName( 'productType' ) || return;

    if( $type =~ /^track$/i )
    {
        $type = RPS::File::Sale::TYPE_TRACK;
    }
    elsif( $type =~ /^bundle$/i )
    {
        $type = RPS::File::Sale::TYPE_ALBUM;
    }
    else
    {
        $self->fail( "Unknown product type '$type'" );
    }

    return $type;
}

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

    if( $format =~ /^download$/i )
    {
        $format = RPS::File::Sale::FORMAT_DOWNLOAD;
    }
    elsif( $format =~ /^stream$/i )
    {
        $format = RPS::File::Sale::FORMAT_STREAM
    }
    else
    {
        $self->fail( "Unknown format type '$format'" );
    }
    return $format;
}

sub mediaType
{
    my $self = shift;
    my $media = $self->_getByFieldName( 'productType' ) || return;

    if( $media =~ /^track|bundle$/i )
    {
        $media = RPS::DB::Item::MediaType::kMediaTypeAudio;
    }
    else
    {
        $self->fail( "Unknown to determine media type from product type '$media'" );
    }

    return $media;
}

sub _normalizeDate
{
    my $self = shift;
    my $dt = shift;
    #             DAY     MON      YEAR
    if( $dt =~ /(\d{2})\/(\d{2})\/(\d{2})/ )
    {
        $dt = join("-",  "20" . $3, $2, $1 );
    }
    return $dt;
}

sub price
{
    my $self = shift;

    my $price = $self->_getByFieldName('price');
    
    $self->fail( "Unable to determine distribution fee" ) unless( $self->{_distFee} );
    
    my $distFee = $self->{_distFee};
    $distFee = (100 - $distFee) * .01;
    $price *= $distFee;

    return $price;
}

sub serviceID
{
    my $self = shift;
    my $service = $self->_getByFieldName('serviceID');

    $self->fail( "Service name not defined" ) unless( $service );
    
    my $serviceID = $self->getServiceID(lc ($service)) || $RPS::Import::ServiceMap::SERVICE_ALIASES{ lc $service };

    $self->fail( "Unable to determine service id from '$service'" ) unless( $serviceID );

    return $serviceID;
}

sub _preProcess
{
    my $self = shift;
    my %args = @_;

    Log->info( "Starting _preProcess" );
    $self->SUPER::_preProcess(%args);

    my $lookForDates; # set once we find the first header

    # Scan the entire file.  Extract the admin fee (located in the footer)
    # along with the date begin/end information (located in the header).
    #
    foreach my $line(@{ $args{lines} })
    {
        $self->{line} = $line;

        # Look for the distribution fee, located in the footer
        #
        my $distFee = $self->_getByFieldName('distFee');
        
        if ($distFee =~ /LESS Merlin ADMIN FEE \((.+?)%\)/)
        {    
            $self->{_distFee} = $1;
            last;
        }


        # Look for the date begin/end information, located
        # in the "first header".
        #
        my $sdate = $self->_getByFieldName('dateBegin');
        my $edate = $self->_getByFieldName('dateEnd');

        if( $sdate =~ /report startdate/i )
        {
            $lookForDates = 1;
        }
        elsif( $lookForDates && !$self->{_dateBegin} && !$self->{_dateEnd} )
        {
            $self->{_dateBegin} = $self->_normalizeDate( $sdate );
            $self->{_dateEnd}   = $self->_normalizeDate( $edate );
        }

        
    }
}

# Method _processLine is overloaded so we can detect blank detail lines
#
# See Import::Importer under sale_import/lib.
#
sub _processLine
{
    my $self = shift;

    my $labelName = $self->line->[$self->_getOffset( 'labelName' )];

    # Process line if there's data defined
    #
    if( $labelName && $labelName =~ /\S/ ) {
        return $self->SUPER::_processLine(@_);
    }

    # Otherwise we skip blank lines.
}


# Methods _getDateBegin and _getDateEnd are overloaded so that we can use
# the date information extracted from the header, rather than the dates
# from each detail line.
#
# See Import::Importer under sale_import/lib.
#
sub _getDateBegin
{
    my $self = shift;
    return $self->{_dateBegin};
}

sub _getDateEnd
{
    my $self = shift;
    return $self->{_dateEnd};
}

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