#---------------------------------------------------------------
# ____                   _ _         ____  _
#|  _ \ ___  _   _  __ _| | |_ _   _/ ___|| |__   __ _ _ __ ___
#| |_) / _ \| | | |/ _` | | __| | | \___ \| '_ \ / _` | '__/ _ \
#|  _ < (_) | |_| | (_| | | |_| |_| |___) | | | | (_| | | |  __/
#|_| \_\___/ \__, |\__,_|_|\__|\__, |____/|_| |_|\__,_|_|  \___|
#            |___/             |___/
#
# Copyright (C) 2013 RoyaltyShare, Inc.   All Rights Reserved
#---------------------------------------------------------------
package RPS::Import::Melodic::v2;

use List::MoreUtils qw(firstidx);

use base 'RPS::Import::Melodic::MelodicBase';

my %fieldMaps = (
    'itunes' => {
        labelName        => 'R',
        countryCode      => 'V',
        productType      => 'T',
        serviceProductID => 'O',
        artistName       => 'P',
        upc              => 'C',
        isrc             => 'D',
        albumName        => 'Q',
        trackName        => 'Q',
        units            => 'F',
        price            => 'M', # may change; see _preProcess
    },
    'apple music' => {
        labelName        => 'R',
        countryCode      => 'A',
        artistName       => 'M',
        trackName        => 'L',
        serviceProductID => 'B',
        isrc             => 'K',
        units            => 'D',
        price            => 'J',
        mediaType        => 'O',
    },
    'beats radio' => {
        labelName        => 'N',
        countryCode      => 'A',
        serviceProductID => 'B',
        isrc             => 'C',
        artistName       => 'E',
        trackName        => 'D',
        units            => 'F',
        price            => 'L',
    },
    'srd digital' => {
        labelName        => 'A',
        serviceID        => 'J',
        countryCode      => 'K',
        formatType       => 'L',
        productType      => 'E',
        artistName       => 'C',
        upc              => 'F',
        isrc             => 'G',
        albumName        => 'D',
        trackName        => 'D',
        units            => 'R',
        price            => 'Z',
    },
);

sub _fieldMap {
    my $self = shift;
    my $sheetName = lc $self->{sheetname};

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

sub _unverifiedFieldMap {
    my $self = shift;
    my $sheetName = lc $self->{sheetname};
    my %fieldMaps = (
        'statement' => {
            label => 'A',
            value => 'B',
        },
    );

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

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

    # Check for Label Share actual column on the iTUNES sheet.
    # Note: this is the only errant column; if we start seeing more
    # columns in the 'wrong' spot then we'll need to revisit this.
    # See Case 18204 for more info.
    #
    my $sheetIndex = firstidx { $_ =~ /^iTUNES$/i } @{$args{sheet_names}};
    if( $sheetIndex != -1)
    {
        my $header = $args{sheets}[$sheetIndex][0];
        my $pdx = firstidx { $_ =~ /^label share$/i } @$header;
        $fieldMaps{itunes}{price} = $pdx if( $pdx != -1 );
    }

    $self->SUPER::_preProcess(%args);
}


sub _headerIdentifier { ( price => 'Label Share' ) }

sub currencyCode { 'GBP' }

sub countryCode {
    my $self = shift;
    my $ccode = $self->_getByFieldName('countryCode');
    my %countryMap = (
        'WW' => 'GB',
        'USROW' => 'EU',
    );
    return (defined $countryMap{ uc $ccode }) ? $countryMap{ uc $ccode } : $ccode;
}

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

    # Making units follow the sign of the revenue
    if ( ($_price < 0 && $_units > 0) || ($_price > 0 && $_units < 0) ) {
        $_units *= -1;
    }
    return $_units;

}

sub serviceID {
    my $self = shift;
    my $sheetName = lc $self->{sheetname};
    my %svcMaps = (
        'itunes'       => Client::Service::DSP_ITUNES,
        'apple music'  => Client::Service::DSP_APPLE_MUSIC,
        'beats radio'  => Client::Service::DSP_BEATSDIGITAL,
    );
    if ($svcMaps{$sheetName})
    {
        return $svcMaps{$sheetName};
    }
    elsif( exists $self->_fieldMap->{serviceID} )
    {
        my $service = $self->_getByFieldName('serviceID');
        my $serviceID = $self->getServiceID(lc ($service)) || $RPS::Import::ServiceMap::SERVICE_ALIASES{ lc $service };
        return $serviceID;
    }
}

my %iTunesMappings = (
    'v' => {
        product_type => RPS::File::Sale::TYPE_TRACK,
        format_type  => RPS::File::Sale::FORMAT_DOWNLOAD,
        media_type   => RPS::DB::Item::MediaType::kMediaTypeVideo,
    },
    'j' => {
        check_isrc => 1,
        format_type  => RPS::File::Sale::FORMAT_DOWNLOADPREMIUM,
        media_type   => RPS::DB::Item::MediaType::kMediaTypeVideo,
    },
    'x' => {
        product_type => RPS::File::Sale::TYPE_TRACK,
        format_type  => RPS::File::Sale::FORMAT_DOWNLOADUPGRADE,
        media_type   => RPS::DB::Item::MediaType::kMediaTypeVideo,
    },
    'p' => {
        product_type => RPS::File::Sale::TYPE_ALBUM,
        format_type  => RPS::File::Sale::FORMAT_DOWNLOAD,
        media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
    's' => {
        product_type => RPS::File::Sale::TYPE_TRACK,
        format_type  => RPS::File::Sale::FORMAT_DOWNLOAD,
        media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
    'h' => {
        product_type => RPS::File::Sale::TYPE_TRACK,
        format_type  => RPS::File::Sale::FORMAT_DOWNLOADPREMIUM,
        media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
    'i' => {
        product_type => RPS::File::Sale::TYPE_ALBUM,
        format_type  => RPS::File::Sale::FORMAT_DOWNLOADPREMIUM,
        media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
    'u' => {
        product_type => RPS::File::Sale::TYPE_TRACK,
        format_type  => RPS::File::Sale::FORMAT_DOWNLOADUPGRADE,
        media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
    'w' => {
        product_type => RPS::File::Sale::TYPE_ALBUM,
        format_type  => RPS::File::Sale::FORMAT_DOWNLOADUPGRADE,
        media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
    'r' => {
        product_type => RPS::File::Sale::TYPE_TRACK,
        format_type  => RPS::File::Sale::FORMAT_RINGTONE,
        media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
    'e' => {
        product_type => RPS::File::Sale::TYPE_TRACK,
        format_type  => RPS::File::Sale::FORMAT_DOWNLOAD,
        media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
    'f' => {
        product_type => RPS::File::Sale::TYPE_TRACK,
        format_type  => RPS::File::Sale::FORMAT_TETHERED,
        media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
    'pr' => {
        product_type => RPS::File::Sale::TYPE_TRACK,
        format_type  => RPS::File::Sale::FORMAT_RINGTONE,
        media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
    'm' => {
        product_type => RPS::File::Sale::TYPE_ALBUM,
        format_type  => RPS::File::Sale::FORMAT_DOWNLOAD,
        media_type   => RPS::DB::Item::MediaType::kMediaTypeVideo,
    },
    'd' => {
        product_type => RPS::File::Sale::TYPE_ALBUM,
        format_type  => RPS::File::Sale::FORMAT_TETHERED,
        media_type   => RPS::DB::Item::MediaType::kMediaTypeVideo,
    },
    'h3' => {
        product_type => RPS::File::Sale::TYPE_TRACK,
        format_type  => RPS::File::Sale::FORMAT_DOWNLOADPREMIUM,
        media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
);

sub _getiTunesMappings
{
    my $self = shift;
    my $type = $self->_getByFieldName('productType');
    my $attr = $iTunesMappings{lc($type)};

    my $product_type = $attr->{product_type};
    my $format_type  = $attr->{format_type};
    my $media_type   = $attr->{media_type};

    if( defined $attr->{check_isrc} )
    {
        if( $self->_getByFieldName('isrc') )
        {
            $product_type = RPS::File::Sale::TYPE_TRACK;
        }
        else
        {
            $product_type = RPS::File::Sale::TYPE_ALBUM;
        }
    }
    return($format_type, $product_type, $media_type);
}

sub _processLine {
    my $self = shift;
    my $sheetName = lc $self->{sheetname};
    if( 'itunes' eq $sheetName )
    {
        ( $self->{_formatType}, $self->{_productType}, $self->{_mediaType} ) = $self->_getiTunesMappings();
    }
    return $self->SUPER::_processLine(@_);
}

sub productType {
    my $self = shift;
    my $sheetName = lc $self->{sheetname};

    if( 'itunes' eq $sheetName )
    {
        return $self->{_productType};
    }
    elsif( 'srd digital' eq $sheetName )
    {
        my $type = $self->_getByFieldName('productType');
        if( $type =~ /^(single|album|ep)$/i )
        {
            return RPS::File::Sale::TYPE_ALBUM
        }
        elsif( $type =~ /^track$/i )
        {
            return RPS::File::Sale::TYPE_TRACK;
        }
        return if( '' eq $type );
        $self->fail("Unable to get product type from '$type'");
    }
    elsif( 'apple music' eq $sheetName ||
           'beats radio' eq $sheetName )
    {
        return RPS::File::Sale::TYPE_TRACK;
    }
}

sub formatType {
    my $self = shift;
    my $sheetName = lc $self->{sheetname};

    if( 'itunes' eq $sheetName )
    {
        return $self->{_formatType} if( $self->{_formatType} );
        $self->fail("Unable to get format from '". $self->_getByFieldName('productType') . "'");
    }
    elsif( 'srd digital' eq $sheetName )
    {
        my $type = $self->_getByFieldName('formatType');
        if( $type =~ /^(download|mp3|wav)$/i )
        {
            return RPS::File::Sale::FORMAT_DOWNLOAD;
        }
        elsif( $type =~ /^stream$/i )
        {
            return RPS::File::Sale::FORMAT_STREAM;
        }
        elsif( $type =~ /^subscription$/i )
        {
            return RPS::File::Sale::FORMAT_TETHERED;
        }
        return if( '' eq $type );
        $self->fail("Unable to get format from '$type'");
    }
    elsif( 'apple music' eq $sheetName ||
           'beats radio' eq $sheetName )
    {
        return RPS::File::Sale::FORMAT_STREAM;
    }
}

sub mediaType {
    my $self = shift;
    my $sheetName = lc $self->{sheetname};

    if( 'itunes' eq $sheetName )
    {
        return $self->{_mediaType} if( $self->{_mediaType} );
        $self->fail("Unable to get media type from '". $self->_getByFieldName('productType') . "'");
    }
    elsif( 'srd digital' eq $sheetName ||
           'beats radio' eq $sheetName )
    {
        return RPS::DB::Item::MediaType::kMediaTypeAudio;
    }
    elsif( 'apple music' eq $sheetName )
    {
        my $type = $self->_getByFieldName('mediaType');
        if( '1' eq $type )
        {
            return RPS::DB::Item::MediaType::kMediaTypeAudio;
        }
        $self->fail("Unable to get media type from '$type'");
    }
}

sub trackName {
    my $self = shift;
    return $self->productType eq RPS::File::Sale::TYPE_ALBUM ? undef : $self->SUPER::trackName;
}

sub albumName {
    my $self = shift;
    return $self->productType eq RPS::File::Sale::TYPE_TRACK ? undef : $self->SUPER::albumName;
}

sub saleDates {
    my $self  = shift;
    return( $self->{_dateBegin}, $self->{_dateEnd} );  # see _preProcess
}

sub _isValidSaleRecord {
    my $self = shift;

    return ( defined($self->units) && ($self->trackName || $self->albumName || $self->artistName || $self->upc ) );
}

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