package RPS::Import::EMIUK::Digital;

use strict;

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

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

use Data::Dumper;

sub _headerIdentifier { ( price => 'NDS Value' ) }

sub currencyCode { 'GBP' }

sub _productTypes {
    {
        'album download' => {
            formatType => RPS::File::Sale::FORMAT_DOWNLOAD,
            mediaType  => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'bundle download' => {
            formatType => RPS::File::Sale::FORMAT_DOWNLOAD,
            mediaType  => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'longform download' => {
            formatType => RPS::File::Sale::FORMAT_DOWNLOAD,
            mediaType  => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'video download' => {
            formatType => RPS::File::Sale::FORMAT_DOWNLOAD,
            mediaType  => RPS::DB::Item::MediaType::kMediaTypeVideo,
        },
        'track ringtune' => {
            formatType => RPS::File::Sale::FORMAT_RINGTONE,
            mediaType  => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'track ringback' => {
            formatType => RPS::File::Sale::FORMAT_RINGTONE,
            mediaType  => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'track download' => {
            formatType => RPS::File::Sale::FORMAT_DOWNLOAD,
            mediaType  => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'single download' => {
            formatType => RPS::File::Sale::FORMAT_DOWNLOAD,
            mediaType  => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'subscr download' => {
            formatType => RPS::File::Sale::FORMAT_TETHERED,
            mediaType  => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'track stream' => {
            formatType => RPS::File::Sale::FORMAT_STREAM,
            mediaType  => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'single stream' => {
            formatType => RPS::File::Sale::FORMAT_STREAM,
            mediaType  => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'album stream' => {
            formatType => RPS::File::Sale::FORMAT_STREAM,
            mediaType  => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'bundle stream' => {
            formatType => RPS::File::Sale::FORMAT_STREAM,
            mediaType  => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'clip download' => {
            formatType => RPS::File::Sale::FORMAT_DOWNLOAD,
            mediaType  => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'clip stream' => {
            formatType => RPS::File::Sale::FORMAT_STREAM,
            mediaType  => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
    };
}

# both of the following functions are super awesome because
# they rely on private member functions of the base class.
# we'll just call them "protected"...

sub _overloadedIdentifier {
    my $self = shift;

    my $map = $self->_fieldMap();

    return ( $map->{upc} eq $map->{isrc} );
}

sub _overloadedTitle {
    my $self = shift;

    my $map = $self->_fieldMap();

    return ( $map->{albumName} eq $map->{trackName} );
}

# by default, productType is ambiguous and can't siply be determined by
# grokking EMI's format. rather, we must look at the single identifier
# provided. if it looks like a UPC, it's an album, otherwise a track

sub productType {
    my $self = shift;

    my $productType;

    if ( $self->_overloadedIdentifier() ) {
        my $identifier = $self->SUPER::upc();
        if ( length($identifier) >= 12 && $identifier =~ m/^\d+$/ ) {
            $productType = RPS::File::Sale::TYPE_ALBUM;
        } else {
            $productType = RPS::File::Sale::TYPE_TRACK;
        }
    } else {
        die "Must be overloaded";
    }

    return $productType;
}

sub upc {
    my $self = shift;

    my $upc;
    if ( $self->productType() eq RPS::File::Sale::TYPE_ALBUM
        || !$self->_overloadedIdentifier() ) {
        $upc = $self->SUPER::upc();
    }

    return $upc;
}

sub isrc {
    my $self = shift;

    my $isrc;

    if ( $self->productType() eq RPS::File::Sale::TYPE_TRACK ) {
        $isrc = $self->SUPER::isrc();
    }

    return $isrc;
}

sub albumName {
    my $self = shift;

    my $albumName;

    if ( $self->productType() eq RPS::File::Sale::TYPE_ALBUM
        || !$self->_overloadedTitle() ) {
        $albumName = $self->SUPER::albumName();
    }

    return $albumName;
}

sub trackName {
    my $self = shift;

    my $trackName;

    if ( $self->productType() eq RPS::File::Sale::TYPE_TRACK ) {
        $trackName = $self->SUPER::trackName();
    }

    return $trackName;
}

sub countryCode {
    my $self        = shift;
    my $country     = $self->SUPER::countryCode() || return;
    my $origCountry = $country;

    $country =~ s/EMI //i;
    $country =~ s/Virgin India/India/i;
    $country =~ s/^Arabia$/Saudi Arabia/i;
    $country =~ s/Taiwan \(Gold Typhoon\)/Taiwan/i;

    my $c = new Common::Country( search => $country =~ /Records UK/ ? 'GB' : $country );

    $self->fail("Unable to determine country code from '$origCountry'") unless ($c);

    return $c->alpha2;
}

sub _processHeader {
    my $self = shift;

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

    my $date = $self->SUPER::_getDateBegin() || return;

    if ( $date =~ /(\w{3} \d{4}$)/ ) {
        my $d = new Common::Date($1);
        $self->{_dateBegin} = $d->monthBegin();
        $self->{_dateEnd}   = $d->monthEnd();
    } elsif ( $date =~ /(\d{4}-\d{2}-\d{2}$)/ ) {
        my $d = new Common::Date($1);
        $self->{_dateBegin} = $d->monthBegin();
        $self->{_dateEnd}   = $d->monthEnd();
    } else {
        print STDERR "DEBUG: _processHeader: Unable to decode date '$date'\n";
    }
}

sub _getDateBegin { shift->{_dateBegin} }
sub _getDateEnd   { shift->{_dateEnd} }

sub _isValidSaleRecord {
    my $self = shift;

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

    # There are summary lines in this file that do not have a format set.
    # These need to be ignored.
    return unless ( $self->_getByFieldName('type') );

    # We want to throw an error if we have zero units and non-zero revenue.
    # case 15801
    if ( $self->price && !$self->units ) {
        $self->fail( "Price " . $self->price . " found with zero units" );
    }

    # sales file includes lines with 0 units or 0 price.  We need to ignore these
    return $self->units || $self->price ? 1 : undef;
}

# For some reason we have negative units and a positive price.  We need to accept
# this value, so we disable the validation.  case 13867
sub _validatePrice {
    my ( $self, $saleRec ) = @_;
    my $price = $saleRec->price || return;

    # 0 | 0.0 | .00 |0.
    if ( $price !~ /^-?(?:(?:\d+)?\.\d+|\d+(?:\.)?(?:\d+)?)$/ ) {
        die Import::ValidationError->new( $saleRec, "Price $price is in an incorrect format" );
    }

}

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