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.
###