package RPS::Import::ThirtyTigers::v3;

use strict;
use warnings;

use lib '/app/tools/rps/lib';
use RPS::Import::ServiceMap;
use Date::Calc qw(Days_in_Month Decode_Month);

use parent 'RPS::Import::ImporterMixed';

sub _fieldMapExtended {
    {
        digital => {
            option1 => {    # US
                labelName   => 'A',
                productType => 'D',
                formatType  => 'D',
                upc         => 'G',
                albumName   => 'C',
                trackName   => 'F',
                units       => 'H',
                price       => 'I',
                mediaType   => 'D',
            },
            option2 => {    # EU
                labelName       => 'A',
                countryCode     => 'E',
                productType     => 'J',
                formatType      => 'J',
                clientProductID => 'H',
                artistName      => 'B',
                albumName       => 'C',
                isrc            => 'H',
                trackName       => 'C',
                units           => 'K',
                currencyCode    => 'N',
                price           => 'N',
                mediaType       => 'J',
            },
         },
    };
}

sub _unverifiedFieldMapExtended {
    {
        digital => {
            option1 => {
                _artist      => 'B',
                _trackArtist => 'E',
            },
        }
    };
}

sub _headerIdentifierExtended {
    {
        digital => {
            option1 => {
                upc => 'UPC',
            },
            option2 => {
                isrc => 'CATALOG NO/ISRC',
            },
        },
    };
}

sub serviceID { Client::Service::DSP_THIRTY_TIGERS }

sub countryCode {
    my $self = shift;

    return 'US' unless exists $self->_fieldMap->{countryCode};

    my $name = $self->_getByFieldName('countryCode') || '';
    return 'LA' if $name =~ /^Laos$/i;
    my $oCountry = Common::Country->Get($name);
    return $oCountry->alpha2() if $oCountry;

    $self->fail("Unable to determine countryCode from: $name");
}

sub _processHeader {
    my $self = shift;

    return unless $self->_isHeader;

    if ( $self->dataTypeOption eq 'option1' ) {
        $self->{_currencyCode} = 'USD';
    } elsif ( $self->dataTypeOption eq 'option2' ) {
        my $currencyCodeHeader = $self->_getByFieldName('currencyCode') || '';
        ( $self->{_currencyCode} ) = $currencyCodeHeader =~ /^.*\((\w{3})\)$/i;
    }

    $self->fail("Unable to determine currencyCode") unless $self->{_currencyCode};
}

sub currencyCode { shift->{_currencyCode} }

sub saleDates {
    my $self = shift;

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

    my $sheetName = $self->sheetname;
    if ( $sheetName =~ /^.*(\d{1,2})\.(\d{2}).*$/i ) {
        my ($month, $year) = ($1, $2);
        $self->{_dateBegin} = sprintf "20%02d-%02d-%02d", $year, $month, 1;
        $self->{_dateEnd}   = sprintf "20%02d-%02d-%02d", $year, $month, Days_in_Month( $year, $month );
        return $self->{_dateBegin}, $self->{_dateEnd};
    }

    $self->fail("Unable to determine salesDates from sheet: '$sheetName'");
}

my %typeMap = (
    option1 => {
        'ad-supported audio streams' => {
            product_type => RPS::File::Sale::TYPE_TRACK,
            format_type  => RPS::File::Sale::FORMAT_STREAM,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'ad-supported video streams' => {
            product_type => RPS::File::Sale::TYPE_TRACK,
            format_type  => RPS::File::Sale::FORMAT_STREAM,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeVideo,
        },
        'cloud match units' => {
            product_type => RPS::File::Sale::TYPE_TRACK,
            format_type  => RPS::File::Sale::FORMAT_STREAM,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'download albums' => {
            product_type => RPS::File::Sale::TYPE_ALBUM,
            format_type  => RPS::File::Sale::FORMAT_DOWNLOAD,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'download tracks' => {
            product_type => RPS::File::Sale::TYPE_TRACK,
            format_type  => RPS::File::Sale::FORMAT_DOWNLOAD,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'mid-tier subscription audio streams' => {
            product_type => RPS::File::Sale::TYPE_TRACK,
            format_type  => RPS::File::Sale::FORMAT_STREAM,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'non-interactive radio' => {
            product_type => RPS::File::Sale::TYPE_TRACK,
            format_type  => RPS::File::Sale::FORMAT_PERFORMANCE,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'subscription audio streams' => {
            product_type => RPS::File::Sale::TYPE_TRACK,
            format_type  => RPS::File::Sale::FORMAT_STREAM,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'subscription video streams' => {
            product_type => RPS::File::Sale::TYPE_TRACK,
            format_type  => RPS::File::Sale::FORMAT_STREAM,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeVideo,
        },
    },
    option2 => {
        'ad-supported audio streams' => {
            product_type => RPS::File::Sale::TYPE_TRACK,
            format_type  => RPS::File::Sale::FORMAT_STREAM,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'ad-supported video streams' => {
            product_type => RPS::File::Sale::TYPE_TRACK,
            format_type  => RPS::File::Sale::FORMAT_STREAM,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeVideo,
        },
        'cloud match units' => {
            product_type => RPS::File::Sale::TYPE_TRACK,
            format_type  => RPS::File::Sale::FORMAT_STREAM,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'download albums' => {
            product_type => RPS::File::Sale::TYPE_ALBUM,
            format_type  => RPS::File::Sale::FORMAT_DOWNLOAD,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'download tracks' => {
            product_type => RPS::File::Sale::TYPE_TRACK,
            format_type  => RPS::File::Sale::FORMAT_DOWNLOAD,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'mid-tier subscription audio streams' => {
            product_type => RPS::File::Sale::TYPE_TRACK,
            format_type  => RPS::File::Sale::FORMAT_STREAM,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'non-interactive radio' => {
            product_type => RPS::File::Sale::TYPE_TRACK,
            format_type  => RPS::File::Sale::FORMAT_PERFORMANCE,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'subscription audio streams' => {
            product_type => RPS::File::Sale::TYPE_TRACK,
            format_type  => RPS::File::Sale::FORMAT_STREAM,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
        },
        'subscription video streams' => {
            product_type => RPS::File::Sale::TYPE_TRACK,
            format_type  => RPS::File::Sale::FORMAT_STREAM,
            media_type   => RPS::DB::Item::MediaType::kMediaTypeVideo,
        },
    },
);

sub productType {
    my $self = shift;

    my $type = lc( $self->_getByFieldName('productType') || '' );

    my $option = $self->dataTypeOption;
    if ( exists $typeMap{$option}{$type} ) {
        return $typeMap{$option}{$type}{product_type};
    }

    $self->fail("Unable to determine productType from: '$type'");
}

sub formatType {
    my $self = shift;

    my $type = lc( $self->_getByFieldName('formatType') || '' );

    my $option = $self->dataTypeOption;
    if ( exists $typeMap{$option}{$type} ) {
        return $typeMap{$option}{$type}{format_type};
    }

    $self->fail("Unable to determine formatType from: '$type'");
}

sub mediaType {
    my $self = shift;

    my $type = lc( $self->_getByFieldName('mediaType') || '' );

    my $option = $self->dataTypeOption;
    if ( exists $typeMap{$option}{$type} ) {
        return $typeMap{$option}{$type}{media_type};
    }

    $self->fail("Unable to determine madiaType from: '$type'");
}

sub albumName {
    my $self = shift;

    my $name = $self->_getByFieldName('albumName') || '';
    return $name if $self->dataTypeOption eq 'option1';

    return $name if $self->productType eq RPS::File::Sale::TYPE_ALBUM;
}

sub trackName {
    my $self = shift;

    my $name = $self->_getByFieldName('trackName') || '';
    return $name if $self->dataTypeOption eq 'option1';

    return $name if $self->productType eq RPS::File::Sale::TYPE_TRACK;
}

sub isrc {
    my $self = shift;

    my $isrc = $self->_getByFieldName('isrc') || '';
    return if $self->dataTypeOption eq 'option1';

    return $isrc if $self->productType eq RPS::File::Sale::TYPE_TRACK;
}

sub artistName {
    my $self = shift;

    if ( $self->dataTypeOption eq 'option2' ) {
        return $self->_getByFieldName('artistName');
    }

    my $_artist      = $self->_getByFieldName('_artist')      || ''; #B
    my $_trackArtist = $self->_getByFieldName('_trackArtist') || ''; #E
    if ( $self->productType eq RPS::File::Sale::TYPE_TRACK ) {
        $_trackArtist =~ s/\(blank\)//gi;
        return $_trackArtist ? $_trackArtist : $_artist;
    }

    return $_artist;
}

sub units {
    my $self = shift;

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

    if ( $price > 0 ) {
        $units = $units ? abs($units) : 1;
    } elsif ( $price < 0 ) {
        $units = $units ? -1 * abs($units) : -1;
    }

    return $units;
}

sub _isValidSaleRecord {
    my $self = shift;

    return unless defined $self->units && defined $self->price && $self->artistName;
    return 1;
}

1;