package RPS::Import::WMG::Util;

use strict;


use lib '/app/tools/common/lib';
use Common::RSDB;

use lib '/app/tools/data_classes/lib';
use Client::Service;

use lib '/app/tools/rps/lib';
use RPS::File::Sale;

use constant WMG => 21;
use constant ERROR => 'Mapping Error';
use constant TABLE_FORMAT_WIRELESS => 'wireless_format_map';
use constant TABLE_BILLTO_SELLTO => 'wireless_billto_sellto';

my %WIRELESS_RS_FORMAT_MAP = ();
my %WIRELESS_WMG_FORMAT_MAP = ();
my %WIRELESS_FORMAT_MAP = ();
my %WIRED_FORMAT_MAP = ();
my %WIRED_PRICE_TYPE = ();

my $DB = Common::RSDB->new(client_id => WMG);

sub errstr
{
    return ERROR;
}

# pass the rs-format_id get their format_name back
# perl -MRPS::Import::WMG::Util -le "print RPS::Import::WMG::Util::getWirelessFormatName(FORMAT_ID)"
sub getWirelessFormatName
{
    my $formatID = shift;
    _getWirelessFormatMap() unless %WIRELESS_FORMAT_MAP;

    return $WIRELESS_RS_FORMAT_MAP{$formatID} || undef;
}

# pass the wmg-format_name get an rs-format_id back
# perl -MRPS::Import::WMG::Util -le "print RPS::Import::WMG::Util::getWirelessFormatNameFromWMG(WMG_FORMAT_NAME)"
sub getWirelessFormatNameFromWMG
{
    my $formatName = lc shift;
    _getWirelessFormatMap() unless %WIRELESS_FORMAT_MAP;

    return $WIRELESS_WMG_FORMAT_MAP{$formatName} || undef;
}

# pass the potentially ugly format name from a sales file and get an rs-format_id back
# perl -MRPS::Import::WMG::Util -le "print RPS::Import::WMG::Util::getWirelessFormatTypeID('FORMAT_NAME')"
sub getWirelessFormatTypeID
{
    my $format = _clean_format($_[0]);
    _getWirelessFormatMap() unless %WIRELESS_FORMAT_MAP;

    return $WIRELESS_FORMAT_MAP{$format} ? $WIRELESS_FORMAT_MAP{$format}{type} : undef;
}

# pass the potentially ugly format name from a sales file and get their "price type" back
# perl -MRPS::Import::WMG::Util -le "print RPS::Import::WMG::Util::getWirelessPriceType('FORMAT_NAME')"
sub getWirelessPriceType
{
    my $format = _clean_format($_[0]);
    _getWirelessFormatMap() unless %WIRELESS_FORMAT_MAP;

    return $WIRELESS_FORMAT_MAP{$format} ? $WIRELESS_FORMAT_MAP{$format}{price} : undef;
}

# pass the #rs-format_id and get their price-type
# perl -MRPS::Import::WMG::Util -le "print RPS::Import::WMG::Util::getWiredPriceType('FORMAT_ID')"
sub getWiredPriceType
{
    my $fmtID = $_[0];
    _getWiredPriceType() unless %WIRED_PRICE_TYPE;
    $fmtID = 'FREE' if $_[1];

    return defined $WIRED_PRICE_TYPE{$fmtID} ? $WIRED_PRICE_TYPE{$fmtID} : undef;
}

# pass an rs-service_id and get their associated 'DSP' info (code, name)
# perl -MRPS::Import::WMG::Util -le "print join(',', RPS::Import::WMG::Util::getWirelessBillto(SERVICE_ID))"
sub getWirelessBillto
{
    my $serviceId = shift;
    my $sth = $DB->DoCmd('SELECT billto_code, service_name FROM '.TABLE_BILLTO_SELLTO." WHERE service_id=$serviceId AND account_type_code='DSP'");
    return undef unless ($sth && $sth->rows());
    my $row = $sth->fetchrow_arrayref();

    return ($row->[0], $row->[1]);
}

# pass an rs-service_id and their 'billTo' code returned from getWirelessBillto and get their
# associated 'RET' info (code, name)
# perl -MRPS::Import::WMG::Util -le "print join(',',RPS::Import::WMG::Util::getWirelessSellto(SERVICE_ID, BILLTO))"
sub getWirelessSellto
{
    my ($serviceId, $billTo) = @_;
    return undef unless ($serviceId && $billTo);

    my $sth = $DB->DoCmd('SELECT sellto_code, service_name FROM '.TABLE_BILLTO_SELLTO." WHERE service_id=$serviceId AND billto_code=$billTo AND account_type_code='RET'");
    return undef unless ($sth && $sth->rows());
    my $row = $sth->fetchrow_arrayref();

    return ($row->[0], $row->[1]);
}

# this is meant to handle the 3 previous method calls all in one and is only suited for "normal"
# wireless importers that have only 1 billto/sellto and format
sub getWirelessInfo
{
    my $serviceId = shift;
    my $format = shift || ''; # optional param

    my ($billtoOK, $selltoOK);

    my @billto = getWirelessBillto($serviceId);
    if ($billto[0])
    {
        $billtoOK = 1;
        $selltoOK = getWirelessSellto($serviceId, $billto[0]) ? 1 : 0;
    }
    else
    {
        $billtoOK = $selltoOK = 0;
    }

    return
        $format ? ($billtoOK, $selltoOK, getWirelessPriceType($format)) :
        ($billtoOK, $selltoOK);
}

# used by wireless report
sub getDistributionMedium
{
    my ($format, $serviceID) = @_;
    return
        $serviceID == Client::Service::DSP_SPRINT ? 'INWR' :
        $serviceID == Client::Service::DSP_INTEGRA ? 'KI' :
        $format eq RPS::File::Sale::FORMAT_DUALDOWNLOAD ? 'INWR' :
        'WR';
}

# pass the rs-format_id and get the output format name
# perl -MRPS::Import::WMG::Util -le "print RPS::Import::WMG::Util::getWirelessFormatName(FORMAT_ID)"
sub getWiredFormatName
{
    my $formatID = shift;
    _getWiredFormatMap() unless %WIRED_FORMAT_MAP;

    return $WIRED_FORMAT_MAP{$formatID} || undef;
}

# XML mappings

sub xml_product_type
{
    my $format = shift;
    return
        $format eq RPS::File::Sale::FORMAT_DOWNLOAD ? '' :
        $format eq RPS::File::Sale::FORMAT_TETHERED ? '' :
        $format eq RPS::File::Sale::FORMAT_STREAM ? '' :
        $format eq RPS::File::Sale::FORMAT_VIDEO ? '' :
        $format eq RPS::File::Sale::FORMAT_VIDEOSTREAM ? '' :
        $format eq RPS::File::Sale::FORMAT_RADIO ? '' :
        $format eq RPS::File::Sale::FORMAT_TELEVISION ? '' :
        '';
}

sub getWiredFileContentType
{
    my $file_id = shift || return undef;

    #my $sql = "SELECT format_type, SUM(units), SUM(price * units * conversion_rate), COUNT(*) FROM ".DB_TABLE." WHERE file_id=$file_id GROUP BY 1";
    my $sql = "SELECT format_type, COUNT(*) FROM sale WHERE file_id=$file_id GROUP BY 1";
    my $sth = $DB->DoCmd($sql);

    return undef unless ($sth && $sth->rows > 0);

    my %types = ();
    foreach my $format(@{ $sth->fetchall_arrayref() })
    {
        $types{ getReleaseContentType($format->[0]) } = 1;
    }

    #my ($contentType) = scalar keys %types == 1 ? keys %types : undef;
    my ($contentType) = keys %types;

    return $contentType;
}

sub getUsageTypeCode
{
    my $format = shift;

    # currently only video (16) or audio streams (17)
    my $video = join('|', RPS::File::Sale::FORMAT_VIDEOSTREAM, RPS::File::Sale::FORMAT_VIDEO, 'video');

    return $format =~ m/^($video)/i ? 16 : 17;
}

sub getReleaseContentType
{
    my $format = shift;
    my $ct = 'Single';

    my $video = join('|', RPS::File::Sale::FORMAT_VIDEOSTREAM, RPS::File::Sale::FORMAT_VIDEO);
    substr($ct,0,0) = 'Video' if ($format =~ m/^($video)$/i);

    return $ct;
}


# private helper methods

sub _getWirelessFormatMap
{
    my $sth = $DB->DoCmd('select * from '.TABLE_FORMAT_WIRELESS);
    while (my $row = $sth->fetchrow_hashref())
    {
        $WIRELESS_FORMAT_MAP{$row->{format_name}} = {
            type => $row->{rs_format_id},
            name => $row->{client_format_name},
            price => $row->{price_type},
        };

        $WIRELESS_RS_FORMAT_MAP{$row->{rs_format_id}} = $row->{client_format_name};
        $WIRELESS_WMG_FORMAT_MAP{lc($row->{client_format_name})} = $row->{rs_format_id};
    }
}

sub _getWiredFormatMap
{
    # hard coded here for now - eventually move to db where it can be edited by cs via ui?
    %WIRED_FORMAT_MAP = (
        RPS::File::Sale::FORMAT_DOWNLOAD        =>  'PERMDWNL',
        RPS::File::Sale::FORMAT_TETHERED        =>  'SUBASON',
        RPS::File::Sale::FORMAT_STREAM          =>  'SUBASON',
        RPS::File::Sale::FORMAT_VIDEO           =>  'SUBVSON',
        RPS::File::Sale::FORMAT_VIDEOSTREAM     =>  'SUBVSON',
        RPS::File::Sale::FORMAT_RADIO           =>  'SUBASPP',
        RPS::File::Sale::FORMAT_TELEVISION      =>  'SUBVSPP',
    );
}

sub _getWiredPriceType
{
    # hard coded here for now - eventually move to db where it can be edited by cs via ui?
    %WIRED_PRICE_TYPE = (
        FREE                                =>  'Standard/FreeTrial',
        RPS::File::Sale::FORMAT_DOWNLOAD         =>  'Standard/Pre-Programmed',
        RPS::File::Sale::FORMAT_TETHERED         =>  'Standard/OnDemand',
        RPS::File::Sale::FORMAT_STREAM           =>  'Standard/OnDemand',
        RPS::File::Sale::FORMAT_VIDEO            =>  'Standard/OnDemand',
        RPS::File::Sale::FORMAT_VIDEOSTREAM      =>  'Standard/OnDemand',
        RPS::File::Sale::FORMAT_RADIO            =>  'Standard/Pre-Programmed',
        RPS::File::Sale::FORMAT_TELEVISION       =>  'Standard/Pre-Programmed',
    );
}

sub _clean_format
{
    my $format = lc($_[0]);
    $format =~ s/^\s+//;
    $format =~ s/\s+$//;
    $format =~ s/(er|ne)s\b/$1/;
    $format =~ s/[\W_]*?(tone|ringe)/$1/;       # master-tone, video ringer
    $format =~ s/exclusive(\S+)/exclusive_$1/;  # fix for regex above
    $format =~ s/non[\W_]+/non/;
    $format =~ s/\W+/_/g;

    return $format;
}

1;