package RPS::Sale::Match::EMI;

use strict;
use warnings;

use lib '/app/tools/common/lib';
use lib '/app/tools/rps/lib';
use lib '/app/tools/data_classes/lib';
use Client::Service;
use Common::Log;
use RPS::DB::Item::Product;

use base 'RPS::Sale::Match';


sub _cleanClientProductID
{
    my ($self, $data) = @_;

    my $dti= $data->{client_product_id};

    # Default is a noop
    return $dti;
}


sub _get_track_matches
{
    my ($self, $data, $skipRec) = @_;

    # First, let's create clean or 'normalized' versions of the parameters
    # we might use to construct the query.
    #
    my $trackClean = $self->_cleanTrack($data);
    my $clientProductID = $self->_cleanClientProductID($data);

#    Common::Log::Print("clientProductID: $clientProductID   trackClean: $trackClean", $data);

    if ($clientProductID && $trackClean)
    {
        my $dbo = Common::RSApp::GetClientDB();


        my $sql = "SELECT product.product_id AS track_product_id"
         . ",track.title AS track_title"
         . ",track.title_clean AS track_title_clean"
         . ",track.custom_1 AS track_custom_1"
         . " FROM product LEFT JOIN track ON (product.asset_id = track.track_id)"
         . " WHERE product.product_type_id=" . RPS::DB::Item::Product::kProductTypeDigitalTrack
         . " AND track.custom_1=".$dbo->DBQuote($clientProductID);


        my $sth = $dbo->DoCmd($sql);


        # !!!
        # The biggest problem I see with this approach is for recommended searches.
        # This method will end up possibly skipping items where the track title is way off,
        # but the DTI does match.
        #
        # I think in that case, I will need to add this product to what the inherited method returns.

        # !!! There should ONLY BE ONE of these.
        #
        if (1 == $sth->rows())
        {
            my $hr = $sth->fetchrow_hashref();

            
            # We don't need to test the DTI, since it was specified in the WHERE clause of the query.
            # Just see if the title is close enough.
            #
            my $titleMatchFlag = $self->_testTrackTitle(row => $hr, data => $data, clean => $trackClean, threshold => 0.70);

            # JPK - For the trial, we now want to just go ahead and match when the DTI matches, even if the title is off.
            # At some point it would be nice to note this someplace.  Right now, we don't have anyplace to put it...
            #
            if (1)
#            if (RPS::Sale::Match::ISMATCH == $titleMatchFlag)
            {
                my %matches;
                $matches{$hr->{track_product_id}} = 
                {
                    data => $hr,  
                    status => RPS::Sale::Match::MATCH,
                    weight => 5,
                };

                return \%matches;
            }
            elsif (! $skipRec)
            {
                # Since the DTI does match, this should probably be a suggested match.
                #
                my $matchesRef = $self->SUPER::_get_track_matches($data, $skipRec);
                if (! defined $matchesRef->{$hr->{track_product_id}})
                {
                    $matchesRef->{$hr->{track_product_id}} = 
                    {
                        data => $hr,  
                        status => RPS::Sale::Match::SUGGEST,
                        weight => 1,
                    };
                }

                return $matchesRef;
            }

        }
    }

    return $self->SUPER::_get_track_matches($data, $skipRec);
}


sub _testUPC
{
    my ($self, %args) = @_;

    my $row = $args{row};
    my $data = $args{data};


    # JPK - We've not been doing a great job with EAN ids where the service has removed the _two_ leading zeroes.
    # The inherited logic probably needs to be rewritten, but in the meanwhile I'll override this method
    # to do a simplistic test:   If the value has fewer than 13 characters, I'll pad with zeroes up to 13 and
    # then try to match it to the two upc/ean fields.  If that fails I'll call the inherited method to do it's stuff.
    #

    my $upc = $data->{upc};
    if ($upc)
    {
        my $pad = 13 - (length $upc);
        if ($pad)
        {
            my $padString = '0' x $pad;
            $upc = $padString . $upc;
        }

        my $metaUPC = $row->{upc};
        my $metaUPCAlt = $row->{upc_alt};

        if ((defined $metaUPC && $upc eq $metaUPC) || (defined $metaUPCAlt && $upc eq $metaUPCAlt))
        {
            return (RPS::Sale::Match::ISMATCH, 1);
        }
    }

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


# Overriding this to call any match with an exact UPC a 'real' match...
# Not that I think this is a good idea, but that's what EMI seems to want.
#
sub _scoreAlbumRow
{
    my ($self, %args) = @_;
    my $hr = $args{row};
    my $data = $args{data};

    my ($upcFlag, $upcExactFlag) = $self->_testUPC(row => $hr, data => $data);

    if (RPS::Sale::Match::ISMATCH == $upcFlag && $upcExactFlag)
    {
        # !!! This is quite the hack...
        # !!! A weight of '5' should easily win over any other matches.
        #
        return (RPS::Sale::Match::MATCH, 5);
    }
    return $self->SUPER::_scoreAlbumRow(%args);
}


    
1;