package RPS::Import::ONErpm::v2;

use strict;

use lib '/app/tools/rps/lib';
use base qw(RPS::Import::MapFaceBase RPS::Import::ImporterMixed);

use Date::Calc qw(Days_in_Month);
use RPS::Import::ServiceMap;

sub _fieldMapExtended {
    {
        digital => {
            # Masters
            option1 => {
                labelName      => 'D',
                serviceID      => 'H',
                countryCode    => 'I',
                dateBegin      => 'K',
                productType    => 'G',
                formatType     => 'J',
                artistName     => 'C',
                upc            => 'E',
                isrc           => 'F',
                trackName      => 'B',
                albumName      => 'A',
                price          => 'V',
                units          => 'R',
                currencyCode   => 'P',
                mediaType      => 'G',
            },
            # YouTube Channels
            option2 => {
                serviceID        => 'E',
                countryCode      => 'F',
                dateBegin        => 'H',
                dateEnd          => 'H',
                productType      => 'G',
                formatType       => 'G',
                serviceProductID => 'D',
                trackName        => 'A',
                units            => 'O',
                currencyCode     => 'M',
                price            => 'S',
                mediaType        => 'A',
            },
        }
    }
}

sub _headerIdentifierExtended {
    {
        digital => {
            option1 => { upc => 'UPC' },
            option2 => { trackName => 'Video Title' }
        },
    }
}
sub _unverifiedFieldMapExtended {{}}

sub serviceID {
    my $self = shift;

    my $service = lc( $self->_getByFieldName('serviceID') || '' );
    my $serviceID = $self->getServiceID($service) || $RPS::Import::ServiceMap::SERVICE_ALIASES{$service};

    $self->handleError( "Unknown service: '$service'", RPS::DB::Item::SaleImportError::kErrorService ) unless $serviceID;

    return $serviceID;
}

sub saleDates {
	my $self = shift;

    my $dt = $self->_getByFieldName('dateBegin');
    my ($startDate, $endDate);

    if ( $dt =~ /^(\d{4})-(\d{2})$/ ) {    # YYYY-MM
        my ($year, $month) = ($1, $2);

        $startDate = sprintf( "%04d-%02d-%02d", $year, $month, 1 );
        $endDate = sprintf( "%04d-%02d-%02d", $year, $month, Days_in_Month( $year, $month ) );
    }

    return ( $startDate, $endDate );
}

sub units {
    my $self  = shift;
    my $units = $self->_getByFieldName('units');
    my $price = $self->_getByFieldName('price');

    $units = 1 if ($price && !$units);

    return ( $price < 0 ) ? ( abs($units) * -1 ) : $units;
}

sub productType {
    my $self = shift;
    my $type = $self->_getByFieldName('productType') || "";

    return RPS::File::Sale::TYPE_TRACK if ($type =~ /^stream$/i && $self->dataTypeOption eq 'option2');

    if ( $self->dataTypeOption eq 'option1') {
        return RPS::File::Sale::TYPE_ALBUM if ($type =~ /^album$/i);
        return RPS::File::Sale::TYPE_TRACK if ($type =~ /^(?:video )?tracks?$/i);
    }

    $self->handleError( "Unknown product type: '$type'", RPS::DB::Item::SaleImportError::kErrorProductType );
}

sub formatType {
    my $self = shift;
    my $type = $self->_getByFieldName('formatType') || "";
    if ( $type =~ /^download$/i ) {
        return RPS::File::Sale::FORMAT_DOWNLOAD;
    } elsif ( $type =~ /^stream$/i ) {
        return RPS::File::Sale::FORMAT_STREAM;
    }
    $self->handleError( "Unknown format type: '$type'", RPS::DB::Item::SaleImportError::kErrorFormatType );
}

sub countryCode {
    my $self = shift;

    my $code = $self->_getByFieldName('countryCode') || '';
    return $code if $code;
    $self->handleError( "Unknown country code: '$code'.", RPS::DB::Item::SaleImportError::kErrorCountry );
}

sub mediaType {
    my $self = shift;
    my $type = $self->_getByFieldName('mediaType') || "";

    if ($self->dataTypeOption eq 'option2') {
        return RPS::DB::Item::MediaType::kMediaTypeVideo if ( $type =~ /video/i );
        return RPS::DB::Item::MediaType::kMediaTypeAudio;
    }

    return RPS::DB::Item::MediaType::kMediaTypeAudio if ( $type =~ /^(?:album|tracks?)$/i );
    return RPS::DB::Item::MediaType::kMediaTypeVideo if ( $type=~ /^video track$/i );

    $self->handleError( "Unknown media type: '$type'", RPS::DB::Item::SaleImportError::kErrorMediaType );
}

sub _processSheet {
    my $self = shift;

    my @valid_sheets = ("Masters", "Youtube Channels");
    my @skip_sheets = ("Summary");
    my $sheet = $self->sheetname;

    return 0 if (grep {/^$sheet$/i} @skip_sheets);
    return $self->SUPER::_processSheet(@_)      if (grep {/^$sheet$/i} @valid_sheets);

    $self->fail("Invalid sheet name: '$sheet'");
}

sub _mapFaceProductType { 'productType'}
sub _mapFaceServiceID   { 'serviceID' }
sub _mapFaceFormatType  { 'formatType' }
sub _mapFaceCountryCode { 'countryCode' }
sub _mapFaceMediaType   { 'mediaType' }

1;