package RPS::Import::ZojakWorlwide::v1;

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

use Client::Service;
use RPS::Import::ServiceMap;
use Date::Calc qw(Days_in_Month Add_Delta_Days Decode_Month Add_Delta_YMD);

use base qw/RPS::Import::MapFaceBase RPS::Import::Importer/;


sub _fieldMap {
    {
        labelName       => 'A',
        serviceID       => 'I',
        countryCode     => 'J',
        dateBegin       => 'A10',
        formatType      => 'F',
        artistName      => 'B',
        upc             => 'H',
        albumName       => 'E',
        isrc            => 'G',
        trackName       => 'C',
        units           => 'M',
        price           => 'R',
        mediaType       => 'F',
    };
}

sub _headerIdentifier { upc => 'UPC' }



sub currencyCode { 'USD' }

sub serviceID {
    my $self = shift;

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

    return $self->handleError( "Unknown service: $service", RPS::DB::Item::SaleImportError::kErrorService );
}

sub saleDates {
    my $self = shift;

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

sub productType {
    my $self = shift;

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

    return RPS::File::Sale::TYPE_ALBUM if $upc && !$isrc;
    return RPS::File::Sale::TYPE_TRACK if $isrc;

    $self->fail("Unable to determine product type for UPC: '$upc' and ISRC: '$isrc'");
}

sub formatType {
    my $self = shift;

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

    if ( $type =~ /^Download$/i ) {
        return RPS::File::Sale::FORMAT_DOWNLOAD;
    } elsif ( $type =~ /^(?:Streaming|Art Track|Sound Recording|Discovery mode discount|Music Video|Subscription\(subscriber play\)|Subscription)$/i ) {
        return RPS::File::Sale::FORMAT_STREAM;
    }

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

sub mediaType {
    my $self = shift;

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

    if ( $type =~ /^(?:Streaming|Art Track|Sound Recording|Discovery mode discount|Subscription\(subscriber play\)|Download|Subscription)$/i ) {
        return RPS::DB::Item::MediaType::kMediaTypeAudio;
    } elsif ( $type =~ /^Music Video$/i ) {
        return RPS::DB::Item::MediaType::kMediaTypeVideo;
    }

    $self->handleError( "Unknown media type: '$type'", RPS::DB::Item::SaleImportError::kErrorMediaType );
}
sub trackName {
    my $self= shift;

    my $trackName = $self->_getByFieldName('trackName') || '';

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

sub countryCode {
    my $self = shift;

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

    $self->handleError( "Unknown country: '$name'.", RPS::DB::Item::SaleImportError::kErrorCountry );
    return $name;
}

my %months = (
    jan => 1, feb => 2, mar => 3, apr => 4, may => 5, jun => 6,
    jul => 7, aug => 8, sep => 9, oct => 10, nov => 11, dec => 12
);

sub _getPeriod {
    my ($self, $date) = @_;

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

    # Batch Name: Royalties December 2025
    if ( $date =~ /Batch Name:\s+Royalties\s+(\w+)\s+(\d{4})/ ) {
        my $month = lc( substr($1, 0, 3) );
        my $year = $2;

        $self->{_dateBegin} = sprintf( '%04d-%02d-01', $year, $months{$month} );
        $self->{_dateEnd}   = sprintf( '%04d-%02d-%02d', $year, $months{$month}, Days_in_Month( $year, $months{$month} ) );
        return ($self->{_dateBegin}, $self->{_dateEnd});
    }

    return;
}

sub _processSheet {
    my ($self, $sheet, $sheetnum) = @_;

    # Get date period from columns A10 of the 'Statement Summary' tab
    if ( $self->{sheetname} =~ /^Statement Summary$/i ) {

        foreach my $aLine ( @$sheet[0..50] ) {
            next unless ref $aLine eq 'ARRAY';
            my $col = 0;                          # for col. A
            my $date = $aLine->[$col] || '';
            last if $self->_getPeriod($date);
        }

        unless ( $self->{_dateBegin} && $self->{_dateEnd} ) {
            $self->fail("Unable to determine date period from first 51 rows in column A");
        }
    }

    return $self->SUPER::_processSheet( $sheet, $sheetnum );
}

# digital
sub price { abs( shift->_getByFieldName('price') || 0 ) }
sub unitPrice { abs( shift->SUPER::unitPrice ) }

sub units {
    my $self = shift;

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

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

    return $units;
}

sub _isValidSaleRecord {
    my $self = shift;

    return 0 if $self->labelName =~ /^Total/i;
    return $self->units || $self->price;
}

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


1;