package RPS::Import::VidZoneDigital::v5;

use strict;
use Data::Dumper;

use lib '/app/tools/common/lib';
use Common::Util qw(normalize_date);
use Common::Consts;
use Common::Country;

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

use base 'RPS::Import::Importer';

sub _fieldMap {
    {
        # header
        currencyCode => 'P',

        # detail
        dateBegin    => 'L',
        serviceID    => 'H',
        countryCode  => 'G',
        productType  => 'K',
        upc          => 'A',
        albumName    => 'F',
        isrc         => 'B',
        trackName    => 'D',
        units        => 'M',
        price        => 'P',
    }
}

sub _unverifiedFieldMap {
    {
        trackArtist => 'C',
        albumArtist => 'E',
    }
}

my %gProductFormatMediaMap = (
    "real tune" => {
        product_type => RPS::File::Sale::TYPE_TRACK,
        format_type  => RPS::File::Sale::FORMAT_RINGTONE,
        media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
    "music video" => {
        product_type => RPS::File::Sale::TYPE_TRACK,
        format_type  => RPS::File::Sale::FORMAT_DOWNLOAD,
        media_type   => RPS::DB::Item::MediaType::kMediaTypeVideo,
    },
    "audio track" => {
        product_type => RPS::File::Sale::TYPE_TRACK,
        format_type  => RPS::File::Sale::FORMAT_DOWNLOAD,
        media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
    "dial tune" => {
        product_type => RPS::File::Sale::TYPE_TRACK,
        format_type  => RPS::File::Sale::FORMAT_RINGTONE,
        media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
    "on demand stream" => {
        product_type => RPS::File::Sale::TYPE_TRACK,
        format_type  => RPS::File::Sale::FORMAT_STREAM,
        media_type   => RPS::DB::Item::MediaType::kMediaTypeVideo,
    },
    "tv channel stream" => {
        product_type => RPS::File::Sale::TYPE_TRACK,
        format_type  => RPS::File::Sale::FORMAT_STREAM, # was FORMAT_VIDEOSTREAM (FB1324).
        media_type   => RPS::DB::Item::MediaType::kMediaTypeVideo,
    },
    "product" => {
        product_type => RPS::File::Sale::TYPE_ALBUM,
        format_type  => RPS::File::Sale::FORMAT_DOWNLOAD,
        media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
    "streaming audio pc" => {
        product_type => RPS::File::Sale::TYPE_TRACK,
        format_type  => RPS::File::Sale::FORMAT_STREAM,
        media_type   => RPS::DB::Item::MediaType::kMediaTypeAudio,
    },
    "streaming video pc" => {
        product_type => RPS::File::Sale::TYPE_TRACK,
        format_type  => RPS::File::Sale::FORMAT_STREAM,
        media_type   => RPS::DB::Item::MediaType::kMediaTypeVideo,
    },
);

sub _headerIdentifier { ( upc => 'UPC' ) }

sub currencyCode {
    my $self = shift;
    return $self->{_currencyCode} if( $self->{_currencyCode} ); # from header; see _preProcess
}

sub artistName {
    my $self = shift;

    if( $self->productType() eq RPS::File::Sale::TYPE_ALBUM )
    {
        return $self->_getByFieldName('albumArtist');
    }
    else
    {
        return $self->_getByFieldName('trackArtist');
    }
}

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

    if( ! exists  $gProductFormatMediaMap{ lc $type }{product_type} )
    {
        $self->fail("Unable to get product type from '$type'");
    }
    return $gProductFormatMediaMap{ lc $type }{product_type};
}

sub formatType {
    my $self = shift;
    my $type = $self->_getByFieldName('productType');
    my $service = $self->_getByFieldName('serviceID');
    
    if( $type =~ /^audio track$/i && $service =~ /^itunes match$/i )
    {
        # If the content type shows 'audio track' and the vendor
        # shows 'itunes match', then treat the sale as a stream.
        # See Case 10.
        #
        return RPS::File::Sale::FORMAT_STREAM;
    }

    # .. otherwise get the format from the productFormat map
    #
    return $gProductFormatMediaMap{ lc $type }{format_type};
}

sub mediaType {
    my $self = shift;
    my $type = $self->_getByFieldName('productType');
    return $gProductFormatMediaMap{ lc $type }{media_type};
}

sub countryCode {
    my $self = shift;
    my $country = $self->_getByFieldName('countryCode');
    my $o = Common::Country->Get( $country );
    if( $o )
    {
        return $o->alpha2();
    }
    else
    {
        $self->errstr("Unknown country '$country'");
    }
}

sub saleDates {
    my $self = shift;

    my $startDate = $self->_getByFieldName('dateBegin');
    if( $startDate =~ /\d{5}/ )
    {
        $startDate = Spreadsheet::ParseExcel::Utility::ExcelFmt( "yyyy-mm-dd", $startDate );
    }
    return $self->_getDates( date_begin => $startDate );
}

sub _processSheet {
    my $self  = shift;
    my $sheet = shift;

    my $sheetnum = $self->{sheetnum};

    if ( $self->{sheetname} !~ /^summary$/i )
    {
        my $foundCurrency; # set if we find a currency header on current sheet

        foreach my $line(@$sheet)
        {
            $self->{line} = $line;

            my $cc = $self->_getByFieldName('currencyCode');

            if( $self->_getByFieldName('currencyCode') =~ /value \((\w+)\)/i )
            {
                # We should be setting _currencyCode from each sheet 
                #
                $self->{_currencyCode} = $1;

                $foundCurrency = 1;
                last;
            }
        }

        if( !$foundCurrency )
        {
           $self->fail("Unable to find currency information on sheet $sheetnum");
        }
    }

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

}

sub serviceID {
    my $self = shift;
    my $service = $self->_getByFieldName('serviceID');

    $self->fail( "Service name not defined" ) unless( $service );

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

    $self->fail( "Unable to determine service id from '$service'" ) unless( $serviceID );

    return $serviceID;
}

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