package RPS::Import::ADA::v14;
#
# This importer is similar to v12.pm.  The difference is that the
# international digital sales tab is slightly different in this
# version (the domestic sales tab, however, is the same).
#
use strict;

use lib '/app/tools/common/lib';
use Common::Util qw(normalize_date normalize_upc);
use Date::Calc qw(Days_in_Month Decode_Month);
use Data::Dumper;

use lib '/app/tools/data_classes/lib';

use lib '/app/tools/rps/lib';
use RPS::File::Sale;
use RPS::Import::ServiceMap;

use base 'RPS::Import::MapFaceBase';
use base 'RPS::Import::ADA::ADACommon';

sub _headerIdentifier { ( units => qr/UNITS$/ ) }

sub _validateFieldMap { }

sub _fieldMap {

    my $self = shift;

    my $sheetName = $self->_normalizeSheetName( lc $self->{sheetname} );

    my %fieldMaps = (
        'domestic' => {
            label       => 28,    # AC
            serviceID   => 2,     # C
            dateBegin   => 3,     # D
            dateEnd     => 4,     # E
            productType => 17,    # R
            formatType  => 41,    # AP
            artistName  => 7,     # H
            upc         => 20,    # U
            albumName   => 22,    # W
            isrc        => 18,    # S
            trackName   => 9,     # J
            units       => 10,    # K
            price       => 15,    # P
            mediaType   => 17,    # R
        },
        'international' => {
            label       => 0,     # A
            serviceID   => 5,     # F
            countryCode => 7,     # H

            artistName => 1,      # B
            albumName  => 2,      # C
            trackName  => 2,      # C

            isrc => 3,            # D
            upc  => 3,            # D

            units => 12,          # M
            price => 13,          # N
        },
    );

    if ( $fieldMaps{$sheetName} ) {
        return $fieldMaps{$sheetName};
    }
}

sub _unverifiedFieldMap {

    my $self = shift;

    my $sheetName = $self->_normalizeSheetName( lc $self->{sheetname} );

    my %fieldMaps = (
        'domestic' => {
            mediaCode  => 41,    # AP
            streamFlag => 44,    # AS
        },
        'international' => {
            deliveryType   => 9,     # J
            deliveryFormat => 10,    # K
        },
    );

    if ( $fieldMaps{$sheetName} ) {
        return $fieldMaps{$sheetName};
    }
}

my %mediaCodeMap = (
    'DRMUPGR' => {
        format_type => RPS::File::Sale::FORMAT_DOWNLOADUPGRADE,
        media_type  => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
    'DUALDIST' => {
        format_type => RPS::File::Sale::FORMAT_DUALDOWNLOAD,
        media_type  => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
    'PERMDWNL' => {
        format_type => RPS::File::Sale::FORMAT_DOWNLOAD,
        media_type  => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
    'PERMVDLD' => {
        format_type => RPS::File::Sale::FORMAT_DOWNLOAD,
        media_type  => RPS::DB::Item::MediaType::kMediaTypeVideo,
    },
    'SUBAICLD' => {
        format_type => RPS::File::Sale::FORMAT_STREAM,
        media_type  => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
    'SUBASONE' => {
        format_type => RPS::File::Sale::FORMAT_STREAM,
        media_type  => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
    'SUBASPPE' => {
        format_type => RPS::File::Sale::FORMAT_STREAM,
        media_type  => RPS::DB::Item::MediaType::kMediaTypeVideo,
    },
    'SUBVICLD' => {
        format_type => RPS::File::Sale::FORMAT_STREAM,
        media_type  => RPS::DB::Item::MediaType::kMediaTypeVideo,
    },
    'SUBVOLYR' => {
        format_type => RPS::File::Sale::FORMAT_STREAM,
        media_type  => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
    'SUBVSONE' => {
        format_type => RPS::File::Sale::FORMAT_STREAM,
        media_type  => RPS::DB::Item::MediaType::kMediaTypeVideo,
    },
    'SUBVSPPE' => {
        format_type => RPS::File::Sale::FORMAT_STREAM,
        media_type  => RPS::DB::Item::MediaType::kMediaTypeVideo,
    },
    'UGMV' => {
        format_type => RPS::File::Sale::FORMAT_STREAM,
        media_type  => RPS::DB::Item::MediaType::kMediaTypeVideo,
    },
    'UGRWRMST' => {
        format_type => RPS::File::Sale::FORMAT_RINGTONE,
        media_type  => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
    'UGV' => {
        format_type => RPS::File::Sale::FORMAT_STREAM,
        media_type  => RPS::DB::Item::MediaType::kMediaTypeVideo,
    },
    'WRMST' => {
        format_type => RPS::File::Sale::FORMAT_RINGTONE,
        media_type  => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
    'WRRNGBK' => {
        format_type => RPS::File::Sale::FORMAT_RINGTONE,
        media_type  => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
    'WRSTREAM' => {
        format_type => RPS::File::Sale::FORMAT_STREAM,
        media_type  => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
);

# International delivery format mappings
#
# $deliveryFormatMap{$deliveryFormat}{$deliveryType}
#
my %deliveryFormatMap = (
    'emastertone' => {
        'download' => {
            product_type => RPS::File::Sale::TYPE_ALBUM,
            format_type  => RPS::File::Sale::FORMAT_RINGTONE,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'wireless' => {
            product_type => RPS::File::Sale::TYPE_TRACK,
            format_type  => RPS::File::Sale::FORMAT_RINGTONE,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
    },
    'emdalbum' => {
        'download' => {
            product_type => RPS::File::Sale::TYPE_ALBUM,
            format_type  => RPS::File::Sale::FORMAT_DOWNLOAD,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'downloads' => {
            product_type => RPS::File::Sale::TYPE_ALBUM,
            format_type  => RPS::File::Sale::FORMAT_DOWNLOAD,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
    },
    'emdalbumstreaming' => {
        'stream' => {
            product_type => RPS::File::Sale::TYPE_ALBUM,
            format_type  => RPS::File::Sale::FORMAT_STREAM,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'streaming' => {
            product_type => RPS::File::Sale::TYPE_ALBUM,
            format_type  => RPS::File::Sale::FORMAT_STREAM,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
    },
    'emdalbumstreamingstreamingstreaming' => {
        'streaming' => {
            product_type => RPS::File::Sale::TYPE_ALBUM,
            format_type  => RPS::File::Sale::FORMAT_STREAM,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
    },
    'emdtrack' => {
        'download' => {
            product_type => RPS::File::Sale::TYPE_TRACK,
            format_type  => RPS::File::Sale::FORMAT_DOWNLOAD,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'downloads' => {
            product_type => RPS::File::Sale::TYPE_TRACK,
            format_type  => RPS::File::Sale::FORMAT_STREAM,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
    },
    'emdtrackstreaming' => {
        'stream' => {
            product_type => RPS::File::Sale::TYPE_TRACK,
            format_type  => RPS::File::Sale::FORMAT_STREAM,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'streaming' => {
            product_type => RPS::File::Sale::TYPE_TRACK,
            format_type  => RPS::File::Sale::FORMAT_STREAM,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
    },
    'eringback' => {
        'download' => {
            product_type => RPS::File::Sale::TYPE_TRACK,
            format_type  => RPS::File::Sale::FORMAT_RINGTONE,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'wireless' => {
            product_type => RPS::File::Sale::TYPE_TRACK,
            format_type  => RPS::File::Sale::FORMAT_RINGTONE,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
    },
    'evd' => {
        'download' => {
            product_type => RPS::File::Sale::TYPE_TRACK,
            format_type  => RPS::File::Sale::FORMAT_DOWNLOAD,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeVideo,
        },
        'downloads' => {
            product_type => RPS::File::Sale::TYPE_TRACK,
            format_type  => RPS::File::Sale::FORMAT_DOWNLOAD,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeVideo,
        },
    },
    'evdstreaming' => {
        'stream' => {
            product_type => RPS::File::Sale::TYPE_TRACK,
            format_type  => RPS::File::Sale::FORMAT_STREAM,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeVideo,
        },
        'streaming' => {
            product_type => RPS::File::Sale::TYPE_TRACK,
            format_type  => RPS::File::Sale::FORMAT_STREAM,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeVideo,
        },
    },
    'mobile' => {
        'download' => {    # FB2929
            product_type => RPS::File::Sale::TYPE_TRACK,
            format_type  => RPS::File::Sale::FORMAT_DOWNLOAD,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'stream' => {      # FB2929
            product_type => RPS::File::Sale::TYPE_TRACK,
            format_type  => RPS::File::Sale::FORMAT_STREAM,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
    },
    'otherdig' => {
        'download' => {    # FB2929
            product_type => RPS::File::Sale::TYPE_TRACK,
            format_type  => RPS::File::Sale::FORMAT_DOWNLOAD,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'stream' => {      # FB2929
            product_type => RPS::File::Sale::TYPE_TRACK,
            format_type  => RPS::File::Sale::FORMAT_STREAM,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
    },
    'stream' => {
        'emdtrackstreaming' => {
            product_type => RPS::File::Sale::TYPE_TRACK,
            format_type  => RPS::File::Sale::FORMAT_STREAM,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
    },
    'unknown' => {
        'download' => {
            product_type => RPS::File::Sale::TYPE_TRACK,                 # only if ISRC present, album otherwise
            format_type  => RPS::File::Sale::FORMAT_DOWNLOAD,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
    },
    'usergenmastertone' => {
        'wireless' => {
            product_type => RPS::File::Sale::TYPE_TRACK,
            format_type  => RPS::File::Sale::FORMAT_STREAM,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
    },
    'web' => {
        'download' => {    # FB2929
            product_type => RPS::File::Sale::TYPE_TRACK,
            format_type  => RPS::File::Sale::FORMAT_DOWNLOAD,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'stream' => {      # FB2929
            product_type => RPS::File::Sale::TYPE_TRACK,
            format_type  => RPS::File::Sale::FORMAT_STREAM,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
    },
    'wireless' => {
        'download' => {    # FB2929
            product_type => RPS::File::Sale::TYPE_TRACK,
            format_type  => RPS::File::Sale::FORMAT_DOWNLOAD,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'stream' => {      # FB2929
            product_type => RPS::File::Sale::TYPE_TRACK,
            format_type  => RPS::File::Sale::FORMAT_STREAM,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
    },
);

# Doing this so that version that inherit from this one can pull stuff out of the hash.
sub _getMediaType {
    my $self = shift;
    my %args = @_;

    my $deliveryType   = $args{deliveryType};
    my $deliveryFormat = $args{deliveryFormat};
    return $deliveryFormatMap{$deliveryFormat}{$deliveryType}{media_type};
}

sub currencyCode { 'USD' }

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

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

    my $fileName = $args{file}->OrigFileName();
    my ( $dateBegin, $dateEnd ) = $self->_getDatesFromFileName($fileName);
    $self->{_fileDateBegin} = $dateBegin;
    $self->{_fileDateEnd}   = $dateEnd;
}

sub _getDateBegin {
    my $self = shift;

    if ( defined $self->_getByFieldName('dateBegin') ) {
        my $saleDateBegin = _normalizeDate( $self->_getByFieldName('dateBegin') );
        my ( $dateBegin, $dateEnd ) = $self->_getDates( date_begin => $saleDateBegin );
        return $dateBegin;
    } else {
        return $self->{_fileDateBegin};
    }
}

sub _getDateEnd {
    my $self = shift;

    if ( defined $self->_getByFieldName('dateBegin') ) {
        my $saleDateBegin = _normalizeDate( $self->_getByFieldName('dateBegin') );
        my ( $dateBegin, $dateEnd ) = $self->_getDates( date_begin => $saleDateBegin );
        return $dateEnd;
    } else {
        return $self->{_fileDateEnd};
    }
}

sub countryCode {
    my $self = shift;

    if ( defined $self->_getByFieldName('countryCode') ) {
        my $name = $self->_getByFieldName('countryCode');
        return $name;
    } else {
        return 'US';
    }
}

sub formatType {
    my $self = shift;
    my $formatType;

    if ( defined $self->_getByFieldName('mediaCode') ) {
        my $mediaCode = $self->_getByFieldName('mediaCode');
        if ( !$mediaCode ) {
            return $self->handleError( "Media code missing", RPS::DB::Item::SaleImportError::kErrorNonqualifying );
        }

        $formatType = $mediaCodeMap{ uc $mediaCode }->{format_type};
        if ($formatType) {
            return $formatType;
        } else {
            return $self->handleError( "Unknown mediaCode: $mediaCode", RPS::DB::Item::SaleImportError::kErrorFormatType );
        }
    } else {
        my $deliveryType = lc $self->_getByFieldName('deliveryType');
        if ( !$deliveryType ) {
            return $self->handleError( "Delivery type missing", RPS::DB::Item::SaleImportError::kErrorNonqualifying );
        }

        my $deliveryFormat = lc $self->_getByFieldName('deliveryFormat');
        if ( !$deliveryFormat ) {
            return $self->handleError( "Delivery format missing", RPS::DB::Item::SaleImportError::kErrorNonqualifying );
        }

        $formatType = $deliveryFormatMap{$deliveryFormat}{$deliveryType}{format_type};
        if ($formatType) {
            return $formatType;
        } else {
            return $self->handleError( "Unknown deliveryType($deliveryType) deliveryFormat($deliveryFormat)",
                RPS::DB::Item::SaleImportError::kErrorFormatType );
        }
    }
}

sub mediaType {
    my $self = shift;
    my $mediaType;

    if ( defined $self->_getByFieldName('mediaCode') ) {
        my $mediaCode = $self->_getByFieldName('mediaCode');
        if ( !$mediaCode ) {
            return $self->handleError( "Media code missing", RPS::DB::Item::SaleImportError::kErrorNonqualifying );
        }

        $mediaType = $mediaCodeMap{ uc $mediaCode }->{media_type};
        if ($mediaType) {
            return $mediaType;
        } else {
            return $self->handleError( "Unknown mediaCode: $mediaCode", RPS::DB::Item::SaleImportError::kErrorMediaType );
        }
    } else {
        my $deliveryType = lc $self->_getByFieldName('deliveryType');
        if ( !$deliveryType ) {
            return $self->handleError( "Delivery type missing", RPS::DB::Item::SaleImportError::kErrorNonqualifying );
        }

        my $deliveryFormat = lc $self->_getByFieldName('deliveryFormat');
        if ( !$deliveryFormat ) {
            return $self->handleError( "Delivery format missing", RPS::DB::Item::SaleImportError::kErrorNonqualifying );
        }

        $mediaType = $deliveryFormatMap{$deliveryFormat}{$deliveryType}{media_type};
        if ($mediaType) {
            return $mediaType;
        } else {
            return $self->handleError( "Unknown deliveryType($deliveryType) deliveryFormat($deliveryFormat)",
                RPS::DB::Item::SaleImportError::kErrorMediaType );
        }
    }
}

sub productType {
    my $self = shift;
    my $productType;

    if ( defined $self->_getByFieldName('mediaCode') ) {
        $productType = $self->_getByFieldName('productType');

        if ( !$productType ) {
            return $self->handleError( "Product type missing", RPS::DB::Item::SaleImportError::kErrorNonqualifying );
        } elsif ( $productType eq 'D' || $productType eq 'P' || $productType eq 'T' || $productType eq 'S' || $productType eq 'DL' ) {
            $productType = RPS::File::Sale::TYPE_TRACK;
        } elsif ( $productType eq 'A' ) {
            $productType = RPS::File::Sale::TYPE_ALBUM;
        } else {
            return $self->handleError( "Unknown product type: $productType", RPS::DB::Item::SaleImportError::kErrorProductType );
        }
    } else {
        my $deliveryType = lc $self->_getByFieldName('deliveryType');
        if ( !$deliveryType ) {
            return $self->handleError( "Delivery type missing", RPS::DB::Item::SaleImportError::kErrorNonqualifying );
        }

        my $deliveryFormat = lc $self->_getByFieldName('deliveryFormat');
        if ( !$deliveryFormat ) {
            return $self->handleError( "Delivery format missing", RPS::DB::Item::SaleImportError::kErrorNonqualifying );
        }

        $productType = $deliveryFormatMap{$deliveryFormat}{$deliveryType}{product_type};
        if ($productType) {

            # Adding an exception for the unknown.
            if ( $deliveryType =~ /unknown/i && $deliveryFormat =~ /download/i && !$self->isrc() ) {
                return RPS::File::Sale::TYPE_ALBUM;
            } else {
                return $productType;
            }
        } else {
            return $self->handleError( "Unknown deliveryType($deliveryType) deliveryFormat($deliveryFormat)",
                RPS::DB::Item::SaleImportError::kErrorProductType );
        }
    }
}

sub free {
    my $self  = shift;
    my $price = $self->price;
    return ( $price == 0 ) ? 1 : 0;
}

sub price {
    my $self = shift;

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

    if ( $price =~ /e-/ ) {

        # Note: the high precision is so that we can capture revenue like .00000000003
        # Effectively we'll store this as a zero since the DB only has 8 digits, but
        # for calculation purposes it'll let us assign a unit to a "zero" revenue line.
        #
        $price = sprintf( "%.18f", $price );    # convert scientific notation to decimal
    }

    if ( $price =~ /^\((\d*\.?\d*)\)$/ ) {
        $price = $1 * -1;
    }

    return $price;
}

sub units {
    my $self = shift;
    my $units = $self->_getByFieldName('units') || return;
    $units =~ s/,//g;
    $units =~ s/\s+//g;
    if ( $units =~ /^\((\d*\.?\d*)\)$/ ) {
        $units = $1 * -1;
    }

    my $price = $self->price;

    # For this importer, We'll follow the sign of the revenue to determine
    # the sign of the units (FB1168).
    #
    if ( $price && $units ) {
        if ( $price < 0 ) {
            $units = 0 - $units if ( $units > 0 );    # price is negative, force negative units
        } else {
            $units = abs($units) if ( $units < 0 );    # price is positive, force positive units
        }
    }

    return $units;
}

sub unitPrice {
    my $self = shift;
    return 0 if ( $self->price == 0 );
    return $self->SUPER::unitPrice();
}

sub isrc {
    my $self = shift;

    my $isrc = $self->_getByFieldName('isrc');

    if ($isrc) {
        $isrc = Common::Util::normalize_isrc($isrc);
        if ( $isrc =~ /^\w/ ) {
            return $isrc;
        }
    }
}

sub upc {
    my $self = shift;

    my $upc = $self->_getByFieldName('upc');

    if ($upc) {
        $upc = Common::Util::normalize_upc($upc);
        if ( $upc =~ /^\d/ ) {
            return $upc;
        }
    }

    # This also catches UPC eq '0', which we don't
    # want either (FBoD15108). Besides, it's always
    # good to return something explicitly.
    return undef;
}

sub albumName {
    my $self      = shift;
    my $isrc      = $self->isrc();
    my $name      = $self->_getByFieldName('albumName');
    my $sheetName = lc $self->{sheetname};

    # On the domestic sheet, album name is always included.
    #
    if ( !$isrc || $sheetName eq 'domestic' ) {
        return $name;
    }
}

sub trackName {
    my $self = shift;
    my $isrc = $self->isrc();
    my $name = $self->_getByFieldName('trackName');
    if ($isrc) {
        return $name;
    }
}

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

    my $serviceID = $self->getServiceID( lc($serviceName) );    # See ADACommon

    if ( !$serviceID && $serviceName =~ /[[:^ascii:]]/ ) {

        # Case 15436 - defaulting service names with incompatible characters to ADA
        $serviceID = Client::Service::DSP_ADA;
    }

    if ( !$serviceID ) {
        return $self->handleError( "Unknown service: $serviceName", RPS::DB::Item::SaleImportError::kErrorService );
    } else {
        return $serviceID;
    }
}

sub _normalizeSheetName {
    my $self  = shift;
    my $sname = shift;
    my $name;

    $name = $sname;
    if ( $sname =~ /domestic digital/i ) {
        $name = "domestic";
    } elsif ( $sname =~ /int\'l digital/i ) {
        $name = "international";
    }

    return $name;
}

sub _normalizeDate {
    my ($dt) = @_;
    my $date = $dt;
    if ( $dt =~ m/^\d{5}$/ ) {
        $date = Spreadsheet::ParseExcel::Utility::ExcelFmt( "yyyy-mm-dd", $dt );
    }
    return $date;
}

sub _getDatesFromFileName {
    my $self = shift;
    my $date = shift;

    my ( $dateBegin, $dateEnd, $month, $year );

    if ( $date =~ m/(january|february|march|april|may|june|july|august|september|october|november|december)[_ ](\d{4})/i ) {
        $month = Decode_Month($1);
        $year  = $2;

        #print STDERR "DEBUG: _getDatesFromFileName: fmonth($1) month($month) year($year)\n";
        $dateBegin = sprintf( "%04d-%02d-%02d", $year, $month, 1 );
        $dateEnd = sprintf( "%04d-%02d-%02d", $year, $month, Days_in_Month( $year, $month ) );
    } elsif ( $date =~ m/([a-z]+)\s*(\d{4})\./i ) {

        $month = Decode_Month($1);
        $year  = $2;

        $dateBegin = sprintf( "%04d-%02d-%02d", $year, $month, 1 );
        $dateEnd = sprintf( "%04d-%02d-%02d", $year, $month, Days_in_Month( $year, $month ) );
    } elsif ( $date =~ m/(\d{4})-(\d{1,2})/ ) {
        $year  = $1;
        $month = $2;

        $dateBegin = sprintf( "%04d-%02d-%02d", $year, $month, 1 );
        $dateEnd = sprintf( "%04d-%02d-%02d", $year, $month, Days_in_Month( $year, $month ) );
    } elsif ( $date =~ m/(\d{2})-(\w{3})/ ) {

        $month = Decode_Month($2);
        $year  = "20" . $1;

        $dateBegin = sprintf( "%04d-%02d-%02d", $year, $month, 1 );
        $dateEnd = sprintf( "%04d-%02d-%02d", $year, $month, Days_in_Month( $year, $month ) );
    } else {
        return undef;
    }

    return ( $dateBegin, $dateEnd );
}

sub _isValidSaleRecord {
    my $self  = shift;
    my $units = $self->units;
    my $price = $self->price;

    return undef if ( !$units && $price && $price < 0 );

    # We're going to skip the tabs we don't care about.
    my $sheetName = $self->_normalizeSheetName( lc $self->{sheetname} );
    return undef if ( $sheetName ne 'domestic' && $sheetName ne 'international' );
    return $self->SUPER::_isValidSaleRecord();
}

## MapFace Stuff

sub _mapFaceServiceID {
    return ( 'serviceID', 'countryCode' );
}

sub _mapFaceCountryCode {
    return ('countryCode');
}

sub _mapFaceProductType {
    return ( 'productType', 'deliveryType', 'deliveryFormat' );
}

sub _mapFaceFormatType {
    return ( 'mediaCode', 'deliveryType', 'deliveryFormat' );
}

sub _mapFaceMediaType {
    return ( 'mediaCode', 'deliveryType', 'deliveryFormat' );
}

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