package RPS::Import::INGrooves::v11;

use strict;

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

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

use Data::Dumper;

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

sub _fieldMap {
    {
        serviceID        => 'B',
        labelName        => 'L',
        countryCode      => 'J',
        dateBegin        => 'A',
        productType      => 'O',    # PRODUCT TYPE
        formatType       => 'N',    # ASSET TYPE
        mediaType        => 'M',    # SALES TYPE
        artistName       => 'C',
        serviceProductID => 'I',    # CATALOG
        upc              => 'E',
        albumName        => 'D',
        trackName        => 'F',
        isrc             => 'G',
        units            => 'P',
        price            => 'R',
    };
}

sub currencyCode { 'USD' }

sub countryCode {
    my $self = shift;
    my $name = $self->SUPER::countryCode();

    $self->fail("Country not set") unless ($name);

    $name =~ s/,.*//;

    $name = $self->_getAlternateCountryName($name) || $name;

    my $country = new Common::Country( search => $name );

    $self->fail("Could not determine country from '$name'") unless ($country);
    return $country->alpha2();
}

sub preProcessLine {
    my $self = shift;

    $self->{preLine} = undef;

    my $units;
    my $price;
    my $unitPrice;
    my $serviceID;
    my $productType;
    my $formatType;
    my $mediaType;

    my $INGretailer    = $self->_serviceName();
    my $INGproductType = $self->_getByFieldName('productType');
    my $INGassetType   = $self->_getByFieldName('formatType');
    my $INGsalesType   = $self->_getByFieldName('mediaType');

    ( $serviceID, $formatType, $productType, $mediaType ) =
      $self->_getServiceFormat( $INGretailer, $INGsalesType, $INGassetType, $INGproductType );

    $units = $self->_getByFieldName('units');
    $price = $self->_getByFieldName('price');

    if ( $price < 0 ) {
        $units = -abs($units);
    }

    # for BeatPort, multi-unit "track" sales are really albums, so we'll coerce units to 1
    # and change the product type to reflect that. awesome.
    if (   $serviceID == Client::Service::DSP_BEATPORT
        && $productType eq RPS::File::Sale::TYPE_TRACK
        && abs($units) > 1
        && !$self->_getByFieldName('isrc')
        && !$self->_getByFieldName('trackName') ) {
        $units /= $units;
        $productType = RPS::File::Sale::TYPE_ALBUM;
    }

    if ($units) {
        $unitPrice = $price / $units;
    }

    # coerce downloads and ringtones to streams if they seem too "cheap" and only if we're talking US $
    if ($formatType) {
        if ( $self->currencyCode eq 'USD' ) {
            if ($unitPrice) {
                if ( $formatType eq RPS::File::Sale::FORMAT_DOWNLOAD ) {
                    if ( $productType eq RPS::File::Sale::TYPE_TRACK && $unitPrice < .20 ) {
                        $formatType = RPS::File::Sale::FORMAT_STREAM;
                    } elsif ( $productType eq RPS::File::Sale::TYPE_ALBUM && $unitPrice < 2 ) {
                        $formatType = RPS::File::Sale::FORMAT_STREAM;
                    }
                } elsif ( $formatType eq RPS::File::Sale::FORMAT_RINGTONE ) {
                    if ( $unitPrice < .50 ) {
                        $formatType = RPS::File::Sale::FORMAT_STREAM;
                    }
                }
            }
        }
    }

    $self->{preLine}{serviceID}   = $serviceID;
    $self->{preLine}{productType} = $productType;
    $self->{preLine}{formatType}  = $formatType;
    $self->{preLine}{mediaType}   = $mediaType;
    $self->{preLine}{units}       = $units;
    $self->{preLine}{price}       = $price;
}

sub productType {
    my $self         = shift;
    my $_productType = $self->_getByFieldName('productType');

    return $self->{preLine}{productType} if ( $self->{preLine}{productType} );

    $self->fail("Unknown product type '$_productType'");
}

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

    return $self->{preLine}{formatType} if ( $self->{preLine}{formatType} );

    $self->fail("Unknown asset type '$assetType'");
}

sub mediaType {
    my $self      = shift;
    my $salesType = $self->_getByFieldName('mediaType');

    return $self->{preLine}{mediaType} if ( $self->{preLine}{mediaType} );

    $self->fail("Unknown media type '$salesType'");
}

sub _serviceName {
    my $self = shift;
    my $service = $self->_getByFieldName('serviceID') || return;
    $service =~ s/ (\w{3})$//;

    return $service;
}

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

    return $self->{preLine}{serviceID} if ( $self->{preLine}{serviceID} );

    $self->fail("Unknown service '$service'");
}

sub price {
    return shift->{preLine}{price};
}

sub units {
    return shift->{preLine}{units};
}

sub _isValidSaleRecord {
    my $self = shift;

    # Ignore blank lines.
    my $blankLine = 1;
    foreach my $cell ( @{ $self->line } ) {
        if ( $cell ne '' ) {
            $blankLine = 0;
        }
    }
    if ( $blankLine == 1 ) { return 0; }

    # Ignore the total line
    my $formatType = $self->_getByFieldName('formatType');
    if ( $formatType =~ /total/i ) { return 0; }

    # For albums, we need either a UPC or Album Name
    if ( $self->productType eq RPS::File::Sale::TYPE_ALBUM ) {
        if ( $self->albumName || $self->upc ) {
            return 1;
        } else {
            $self->fail("Missing title and upc for album product");
        }
    }

    # For tracks, we need either an ISRC or Track Name
    if ( $self->productType eq RPS::File::Sale::TYPE_TRACK ) {
        if ( $self->trackName || $self->isrc ) {
            return 1;
        } else {
            $self->fail("Missing title and isrc for track product");
        }
    }

    return $self->SUPER::_isValidSaleRecord();
}

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