#!/usr/bin/perl

use strict;
use Getopt::Std;
use IO::File;
use Date::Calc;
use Data::Dumper;

use lib '/app/tools/common/lib';
use Common::Util qw(decodeDateMysql trimspaces clean normalize_upc normalize_isrc);
use Common::RSDB;
use Common::RSApp;
use Common::Assert;

use lib '/app/tools/rps/lib';
use RPS::XMLObject;
use RPS::DB::Item::Track;
use RPS::DB::Item::Album;
use RPS::DB::Item::Product;
use RPS::DB::Item::Master;
use RPS::DB::Item::Publisher;
use RPS::DB::Item::TrackLicense;


# reporting flags and variable
#
use constant kQuiet => 0;
use constant kNormal => 1;
use constant kDebug => 3;
my $gReportLevel = kNormal;

use constant kProgressQuanta => 200;

# if two tracks on the same album have the same title,
# duration is the only distinguishing property. In this
# case the import data might be slightly different from the
# database data so we'll allow a +/- tolerance in matching.
use constant kDurationTolerance => 5;

# we're skipping some publishers (DIGITAL ONLY)
#   - ABKCO MUSIC INC (P11300)
#   - ABKCO MUSIC INC PETE TOWNSHEND CATALOG (P20061)
my @skipPublishers = qw();


# Parse the command-line.
#
my ($clientID, $inputFile) =  parseCommandLine();

$| = 1;

# Instantiate the application singleton object.
#
my $appSingleton = Common::RSApp->new(clientID => $clientID);


# Scan the input file, and build the data structure of updates.
#
my %updates;
scanInputFileForUpdates($inputFile, \%updates);



# Commit any necessary updates.
#
processUpdates(\%updates);


#
# --- Subroutines
#


sub parseCommandLine
{
    my %opt;
    getopts('c:f:p', \%opt);

    my $inputFile = $opt{f};
    my $clientID = $opt{c};

    unless ($clientID =~ /^\d+$/ && $clientID > 0)
    {
	    die usage("You must specify a valid client ID");
    }

    unless ($inputFile)
    {
	    die usage("You must specify a catalog file to import");
    }

    unless (-e $inputFile)
    {
	    die usage("The specified catalog file does not exist");
    }

    return ($clientID, $inputFile);
}


sub usage
{
	my $errstr = shift;
	my $text = ($errstr) ? "ERROR: $errstr\n" : '';
	$text .= "Usage: $0 -c <clientID> -f <inputFile>\n";
	return $text;
}


sub scanInputFileForUpdates
{
    my ($inputFilePath, $updates) = @_;
    assert($inputFilePath);
    assert($updates);


    # Open the input file for reading.
    #
    my $inputFile = IO::File->new($inputFile) || die "Can't open input file '$inputFile': $!\n";

	readTabInputFile($inputFile, $updates);

    # Done with the input file, close it.
    #
    $inputFile->close();
}


sub readTabInputFile
{
    my ($file, $updates) = @_;
    assert($file);
    assert($updates);

    report("\nReading input file...");

    my $recordCount = 0;
	my $skipCount = 0;

    # Process the file line by line
    #
    while (my $record = <$file>) 
    {
	    my @fields;
	    my $licenseType;
	    my $artistName;
	    my $albumTitle;
	    my $catalogNumber;
	    my $upc;
	    my $isrc;
	    my $productConfig;
	    my $songCode;
	    my $duration;
	    my $songTitle;
	    my $dateSent;
	    my $licenseDate;
	    my $dateSigned;
	    my $topPublisherNumber;
	    my $topPublisherName;
	    my $publisherNumber;
	    my $publisherName;
	    my $publisherShare;
	    my $licenseNumber;
	    my $rate;
	    my $balanceFwd;
    
        $recordCount++;

        if (0 == $recordCount % kProgressQuanta)
        {
            report("  record $recordCount ... ");
        }

        # Split the line up into fields.
        #
    	chomp $record;
    	@fields = split("\t", $record);
    	@fields = trimquotes(@fields);
    	@fields = escapequotes(@fields);


		# Note - clientAlbumProductID is coming from the 'albumID' field,
		# and clientTrackProductID is coming from the 'trackID' field.
		# I'm not positive that this mapping is correct, or even
		# meaningful, but I do believe that the original values _are_ just
		# client-specified meta-data... so, it may make sense.
		# In any event, we need _something_ to put in the
		# 'product_code' column in the RPS product table, so this is
		# as good as anything...
		#
		(undef,$licenseType,undef,undef,$artistName,$albumTitle,$catalogNumber,$upc,$isrc,$productConfig,undef,$duration,$songTitle,undef,$songCode,$dateSent,$licenseDate,$dateSigned,$topPublisherNumber,$topPublisherName,$publisherNumber,$publisherName,$publisherShare,undef,$licenseNumber,undef,$rate,undef,undef, $balanceFwd,undef,undef) = undefspaces(@fields);

		$isrc = normalize_isrc($isrc);

		# trim leading zeros
		$upc = _myNormalizeUPC($upc);
		my $altUPC = _myNormalizeUPC($catalogNumber);
		$publisherShare =~ s/%//;

		# we aren't saving licenses with share of 0.00%.
		#
		if(abs($publisherShare) && ($catalogNumber || $altUPC || $upc || $isrc) && $songCode && $publisherNumber)
		{
				my $newLicense = {};
				$newLicense->{trackLicenseID}		= undef;
				$newLicense->{lineNum}				= $recordCount+1; # the original excel file started on row 2, adjust here
				$newLicense->{songCode}				= $songCode;
				$newLicense->{licenseType}			= $licenseType;
				$newLicense->{artistName}			= $artistName;
				$newLicense->{albumTitle}			= $albumTitle;
				$newLicense->{catalogNumber}		= $catalogNumber;
				$newLicense->{altUPC}				= $altUPC;
				$newLicense->{upc}					= $upc;
				$newLicense->{isrc}					= $isrc;
				$newLicense->{productConfig}		= $productConfig;
				$newLicense->{duration}				= $duration;
				$newLicense->{songTitle}			= $songTitle;
				$newLicense->{dateSent}				= _convertDate($dateSent);
				$newLicense->{licenseDate}			= _convertDate($licenseDate);
				$newLicense->{dateSigned}			= _convertDate($dateSigned);
				$newLicense->{topPublisherNumber}	= $topPublisherNumber;
                $newLicense->{publisherNumber}		= $publisherNumber;
                $newLicense->{publisherShare}		= $publisherShare;
                $newLicense->{licenseNumber}		= $licenseNumber;
                $newLicense->{rate}					= $rate;
                $balanceFwd =~ s/,//g;
                $newLicense->{advance_amount}		= $balanceFwd;

				push @{$updates->{licenses}}, $newLicense;

				# -jff- I forget why this line is here
				#
				# report(join('\t', sort keys %$newLicense)) if($recordCount == 2);
		}
		else
		{
			report("!Warning (line ".$recordCount."): Incomplete data for song=$songTitle, code=$songCode, publisher#=$publisherNumber");
			$skipCount++;
		}

		# regular publisher
		#
		if($publisherNumber && $publisherName)
		{
			if(!exists($updates->{publishers}->{$publisherNumber}))
			{
				# $updates->{publishers}->{$publisherNumber}->{publisherID} = "";
				# $updates->{publishers}->{$publisherNumber}->{isAdmin} = "";
				# $updates->{publishers}->{$publisherNumber}->{adminNumber} = "";
				$updates->{publishers}->{$publisherNumber}->{publisher_name} = $publisherName;
			}
		}
		else
		{
			report("!Warning (line ".$recordCount."): Incomplete publisher", kDebug);
		}

		# top (admin) publisher
		#
		if($topPublisherNumber && $topPublisherName)
		{
			if(!exists($updates->{publishers}->{$topPublisherNumber}))
			{
				$updates->{publishers}->{$topPublisherNumber}->{publisher_name} = $topPublisherName;
			}

			if($publisherName && ($publisherName ne $topPublisherName))
			{
				# mark this publisher as an admin
				#
				$updates->{publishers}->{$topPublisherNumber}->{isAdmin} = 1;

				# set the regular publisher's admin as this publisher
				#
				$updates->{publishers}->{$publisherNumber}->{adminNumber} = $topPublisherNumber;
			}
		}
		else
		{
			report("!Warning (line ".$recordCount."): Incomplete top publisher", kDebug);
		}

	}
    report("  Records processed : $recordCount");
    report("  Records skipped   : $skipCount");
}


sub processUpdates
{
    my ($updates) = @_;

	my $publishers = $updates->{publishers};
	# Create publisher entries
	#
	report("\nCreating Publishers...");
	my $count = 0;

	# we need to create an entry for Harry Fox first
	#
	# my $hfa = RPS::DB::Item::Publisher->Create(publisher_name => "HARRY FOX AGENCY",
											   # is_agency => 1,
											   # is_admin => 0);
	# $hfa->save();
	# my $hfaID = $hfa->publisher_id;

	# HFA has publisher_id=1, we don't need to create it again. -jff-
	#
	my $hfaID = 1;

	my $pubCreateCount = 0;
	my $pubMatchCount = 0;
	foreach my $publisherNumber (sort { $publishers->{$b}->{isAdmin} <=> $publishers->{$a}->{isAdmin} } keys %$publishers)
	{
		$count++;
		if (0 == $count % kProgressQuanta)
		{
			report("  publisher $count ...");
		}

		my $publisher = $publishers->{$publisherNumber};

		# have we already created/matched this publisher?
		#
		if(! $publisher->{publisherID})
		{
			# Does this publisher already exist?
			#
			my $coll = RPS::DB::Item::Publisher->Match($publisher->{publisher_name});
			if(defined $coll && $coll->hasNext())
			{
				my $dbItem = $coll->next();
				$publisher->{publisherID} = $dbItem->publisher_id();
				$pubMatchCount++;

				# is this a new admin?
				#
				if($publisher->{isAdmin} == 1 && !$dbItem->is_admin())
				{
					$dbItem->is_admin(1);
					$dbItem->save();
					report("!Update (Pub# $publisherNumber): publisher set to Admin, publisher = ".$publisher->{publisher_name});
				}

				next;
			}

			my %pubParams =
			(
				publisher_name => $publisher->{publisher_name},
				is_agency => 0,
				is_admin => 0,
				agent_id => $hfaID,
			);

			if($publisher->{adminNumber})
			{
				# does this publisher have an admin?
				#
				$pubParams{admin_id} = $publishers->{$publisher->{adminNumber}}->{publisherID};
			}
			elsif($publisher->{isAdmin} == 1)
			{
				# is this an admin?
				#
				$pubParams{is_admin} = 1;
			}

			# report("Creating publisher: ".Dumper(\%pubParams), kDebug);

			my $dbItem = RPS::DB::Item::Publisher->Create(%pubParams);
			$dbItem->save();
			$publisher->{publisherID} = $dbItem->publisher_id;
			$pubCreateCount++;
		}

	} # END - publishers loop

	report("  Publishers created : $pubCreateCount");
	report("  Publishers matched : $pubMatchCount");

    # Create license entries
    #
	my $tracks = {};
    my $licenses = $updates->{licenses};
	my %seenLicense = ();

	report("\nCreating Licenses...");

	my $matchCount = 0;
    $count = 0;
    foreach my $license (@$licenses)
    {
        $count++;
        if (0 == $count % kProgressQuanta)
        {
            report("  license $count ...");
        }

		# SKIP these publishers:
		#
		my $publisherNumber = $license->{publisherNumber};
		my $topPublisherNumber = $license->{topPublisherNumber};
		if(grep(/^$publisherNumber$/, @skipPublishers) || grep(/^$topPublisherNumber$/, @skipPublishers))
		{
			report("!Warning (line ".$license->{lineNum}."): Skipping publisher=$publisherNumber (admin: $topPublisherNumber)");
			next;
		}

		# did we already create this license?
		#
		if(!$license->{trackLicenseID})
		{
			#
			# We need to identify this track before we can assign
			# a license to it.
			#
			my $trackID;
			my $trackKey = join('|', $license->{albumTitle},
								$license->{catalogNumber},
								$license->{upc},
								$license->{songCode},
								$license->{songTitle},
								$license->{isrc},
								$license->{duration},
								);

			if(!exists($tracks->{$trackKey}))
			{
				$trackID = _deriveTrackIDFromLicense($license);
			}
			else
			{
				$trackID = $tracks->{$trackKey};
				report("TrackID already found for trackKey = $trackKey", kDebug);
			}
			
			if($trackID)
			{
				report("Song matched!", kDebug);

				# store this for future reference
				#
				$tracks->{$trackKey} = $trackID;

				my %licenseParams = 
				(
					track_id => $trackID,
					date_sent => $license->{dateSent},
					date_received => $license->{licenseDate},
					date_issued => $license->{dateSigned},
					issuer_license_id => $license->{licenseNumber},
					type => 1,
					rate_basis => 1,
					free_goods => 15, # Sanctuary physical license specific
					# percentage_of_sales => 100,
				);

				# all the balances are negative
				#
				if($license->{advance_amount} < 0)
				{
					$licenseParams{advance_amount} = $license->{advance_amount} * -1;
				}

				my $rateType = _deriveRateType($license->{rate});
				if($rateType)
				{
					$licenseParams{rate_type} = $rateType;
				}
				else
				{
					report("!Warning (line ".$license->{lineNum}."): unknown rate basis (".$license->{rate}.") for song = ".$license->{songTitle});
					next;
				}
				
				if($rateType == RPS::DB::Item::TrackLicense::kRateTypePenny())
				{
					# just assign the penny rate
					#
					# $licenseParams{penny_rate} = $license->{rate};
					$licenseParams{penny_rate} = sprintf("%.4f", $license->{rate});
					$licenseParams{rate_basis} = undef;
					$licenseParams{percentage_of_sales} = 100;
				}
				else
				{
					# otherwise, figure out the percent rate
					#
					my $percentRate;
					$percentRate = _deriveRate($license->{rate});
					if($percentRate)
					{
						$licenseParams{percentage_of_sales} = $percentRate;
					}
					else
					{
						report("!Warning (line ".$license->{lineNum}."): unknown percent of rate (".$license->{rate}.") for song = ".$license->{songTitle});
						next;
					}
				}


				my $productTypeID = _deriveProductType($license->{productConfig});
				if($productTypeID)
				{
					$licenseParams{product_type_id} = $productTypeID;
				}
				else
				{
					report("!Warning (line ".$license->{lineNum}."): unknown license type (".$license->{productConfig}.") for song = ".$license->{songTitle});
					next;
				}

				my $share;
				if($license->{publisherShare})
				{
					$licenseParams{share} = $license->{publisherShare};
				}
				else
				{
					report("!Warning (line ".$license->{lineNum}."): missing share for song = ".$license->{songTitle});
					next;
				}

				my $publisherID;
				my $pubNum = $license->{publisherNumber};
				if($pubNum && $publishers->{$pubNum} && $publishers->{$pubNum}->{publisherID})
				{
					$licenseParams{publisher_id} = $publishers->{$pubNum}->{publisherID};
				}
				else
				{
					report("!Warning (line ".$license->{lineNum}."): missing publisher for song = ".$license->{songTitle});
					next;
				}

				# let's make sure we didn't already import this license
				#
				# my $licenseKey = join('-', $trackID, $licenseParams{publisher_id}, $licenseParams{share}, $licenseParams{issuer_license_id});
				my $licenseKey = join('-', $trackID, $licenseParams{publisher_id}, $licenseParams{product_type_id});
				if(!$seenLicense{$licenseKey})
				{
					$seenLicense{$licenseKey} = 1;

					# check for duplicate in the system
					#
					my $coll = RPS::DB::Item::TrackLicense->GetByTrackPublisherProductType($trackID, $licenseParams{publisher_id}, $licenseParams{product_type_id});
					if(defined $coll && $coll->size > 0)
					{
						report("!Warning (line ".$license->{lineNum}."): License already exists: track_id=$trackID, song = ".$license->{songTitle});
						next;
					}
	
					# report("Creating track_license with: ".Dumper(\%licenseParams), kDebug);

					my $newLicense = RPS::DB::Item::TrackLicense->Create(%licenseParams);
					$newLicense->save();
					$license->{trackLicenseID} = $newLicense->track_license_id;
					$matchCount++;
				}
				else
				{
					report("!Warning (line ".$license->{lineNum}."): License already created: song = ".$license->{songTitle});
				}
			}
			else
			{
				report("!Warning (line ".$license->{lineNum}."): Song not found: song = ".$license->{songTitle});
			}
		}
		else
		{
			report("!Warning (line ".$license->{lineNum}."): I guess we already processed this license?");
		}

	} # END - licenses loop

    report("  Total licenses processed : $count");
    report("  Licenses created         : $matchCount");
}


sub _deriveRateType
{
	my $rate = shift;

	# full  = 1
	# min   = 2
	# penny = 3
	#
	my $rateType;
	if($rate =~ /(MIN(IMUM)?|WITHOUT REGARD TO PLAYING TIME)/i)
	{
		$rateType = RPS::DB::Item::TrackLicense::kRateTypeMinimum;
	}
	elsif($rate =~ /\d\.\d+/)
	{
		$rateType = RPS::DB::Item::TrackLicense::kRateTypePenny;
	}
	else
	{
		$rateType = RPS::DB::Item::TrackLicense::kRateTypeFull;
	}

	return $rateType;
}


sub _deriveRate
{
	my $rateType = shift;

	my $rate;

	if($rateType =~ /(\d\d)%/)
	{
		$rate = $1;
	}
	else
	{
		$rate = 100;
	}

	return $rate;
}


sub _deriveProductType
{
	my $config = shift;

	my $id;

	if($config =~ /(DIGITAL|DOWNLOAD)/i)
	{
		# digital
		#
		$id = 3;
	}
	elsif($config =~ /COMPACT DISC/i)
	{
		# physical - CD
		#
		$id = 2;
	}

	return $id;
}


sub _deriveTrackIDFromLicense
{
	my $license = shift;

	my $trackID;

	# The Sanctuary matching rule is this:
	# 1. We must be able to match the catalog number or UPC to a release in our catalog.
	#
	if($license->{catalogNumber} || $license->{upc})
	{
		$trackID = _getTrackIDFromCatalogNumber($license);
	}

	return $trackID;
}


sub lookupPublisher
{
	my ($name) = @_;

	my $publisherID;

	# Does this publisher already exist?
	#
	my $coll = RPS::DB::Item::Publisher->Match($name);
	if(defined $coll && $coll->size == 1)
	{
		my $dbItem = $coll->next();
		$publisherID = $dbItem->publisher_id;
	}

	return $publisherID;
}

sub _normalizeCatalogNumber
{
	my $catalogNumber = shift;

	$catalogNumber =~ s/\D//g;
	if(length($catalogNumber) >= 10)
	{
		if(length($catalogNumber) == 10)
		{
			if($catalogNumber !~ /2$/)
			{
				$catalogNumber = $catalogNumber."2";
			}
			elsif($catalogNumber !~ /^0/)
			{
				$catalogNumber = "0".$catalogNumber;
			}
		}

		$catalogNumber = substr($catalogNumber, 5, 10);
		if(length($catalogNumber) == 5)
		{
			$catalogNumber .= "-2";
		}
		else
		{
			$catalogNumber =~ s/2$/-2/;
		}
	}
	elsif(length($catalogNumber) == 5)
	{
		$catalogNumber .= "-2";
	}

	return $catalogNumber;
}

sub _getTrackIDFromCatalogNumber
{
	my ($license) = @_;

	my $trackID;
	my $matchedTracks;

	# the order here is important, we always want to use the catalogNumber if we can.
	#
	my $catalogNumber = _normalizeCatalogNumber($license->{catalogNumber}) || _normalizeCatalogNumber($license->{upc});
	report("Looking up CatalogNumber = $catalogNumber", kDebug);
	if($catalogNumber)
	{
		my $coll = RPS::DB::Item::Album->GetByCatalogNumber($catalogNumber);

		if($coll->hasNext())
		{
			my $albumItem = $coll->next();

			$matchedTracks = MatchTracksFromAlbumID($albumItem->album_id, $license);
			$trackID = FindTrackFromMatchedTracks($matchedTracks, $license);
		}
		else
		{
			report("!Warning: CatalogNumber not found", kDebug);
		}
	}

	return $trackID;
}


sub _getTrackIDFromUPC
{
	my ($license) = @_;

	my $trackID;
	my $upc = $license->{upc} || $license->{altUPC};

	if($upc)
	{
		report("Looking up UPC = $upc", kDebug);
		my $productColl = RPS::DB::Item::Product->GetByUPC($upc);
		if($productColl->hasNext())
		{
			my $prodItem = $productColl->next();
			my $matchedTracks = MatchTracksFromAlbumID($prodItem->album_id, $license);
			$trackID = FindTrackFromMatchedTracks($matchedTracks, $license);
		}
		else
		{
			report("!Warning: UPC not found", kDebug);
		}
	}

	return $trackID;
}

sub FindTrackFromMatchedTracks
{
	my ($matchedTracks, $license) = @_;

	my $trackID;

	if(@$matchedTracks == 1)
	{
		$trackID = $matchedTracks->[0]->track_id;
		report("!Notice (line ".$license->{lineNum}."): MATCH found! trackID = ".$trackID, kDebug);
	}
	elsif(@$matchedTracks > 1 && $license->{duration} =~ /\d?\d?:\d\d/)
	{
		report("Checking duration...", kDebug);
		foreach my $track (@$matchedTracks)
		{
			# let's compare duration
			#
			my $licDuration = RPS::XMLObject::_MMSSToSeconds($license->{duration});
			my $masterItem = RPS::DB::Item::Master->Lookup(master_id => $track->master_id);

			if($licDuration == $masterItem->duration || abs($licDuration - $masterItem->duration) <= kDurationTolerance)
			{
				$trackID = $track->track_id;
			}
		}

		if(!$trackID)
		{
			report("!Warning (line ".$license->{lineNum}."): duplicate song, no match on duration = ".$license->{songTitle}, kDebug);
		}
	}
	else
	{
		report("!Warning (line ".$license->{lineNum}."): duplicate song, no match on duration = ".$license->{songTitle}, kDebug);
	}
	
	return $trackID;
}


sub MatchTracksFromAlbumID
{
	my ($albumID, $license) = @_;

	my @matchedTracks = ();

	# normalize the song title we are trying to match
	#
	my $licenseTrack = lc($license->{songTitle});
	$licenseTrack =~ s/\s+//g;
	my $licenseTrackClean = clean($licenseTrack);

	my $trackColl = RPS::DB::Item::Track->GetTracksByAlbumID($albumID);
	while($trackColl->hasNext())
	{
		my $trackItem = $trackColl->next();

		if ($trackItem->title)
		{
			# normalize the song title from the database
			#
			my $prodTrack = lc($trackItem->title);
			$prodTrack =~ s/\s+//g;
			my $prodTrackClean = clean($prodTrack);
			$prodTrackClean =~ s/_//g;

			report("!Notice (line ".$license->{lineNum}."): comparing ('".$prodTrack."' cmp '".$licenseTrack."')", kDebug);

			##########################
			########################## We are restricting matches to ONLY EXACT matches
			##########################

			# match a short title
#			if (length($prodTrack) < 3)
#			{
				if ($licenseTrack eq $prodTrack || $licenseTrackClean eq $prodTrackClean)
				{
					report("!Notice (line ".$license->{lineNum}."): MATCH ('".$prodTrack."' cmp '".$licenseTrack."')", kDebug);
					push @matchedTracks, $trackItem;
					# $trackID = $trackItem->track_id;
				}
#			}
#			# does the dbTrack contain the title? or the other way around?
#			# This works because we've already narrowed it down to the 
#			# correct album.
#			elsif ($licenseTrack eq $prodTrack ||
#				   index($licenseTrack, $prodTrack) > -1 ||
#				   index($prodTrack, $licenseTrack) > -1 ||
#				   $licenseTrackClean eq $prodTrackClean ||
#				   index($licenseTrackClean, $prodTrackClean) > -1 ||
#				   index($prodTrackClean, $licenseTrackClean) > -1
#				   )
#			{
#				report("!Notice (line ".$license->{lineNum}."): MATCH ('".$prodTrack."' cmp '".$licenseTrack."')", kDebug);
#				push @matchedTracks, $trackItem;
#				# $trackID = $trackItem->track_id;
#			}
		}
	}

	return \@matchedTracks;
}


sub escapequotes
{
	my @string = @_;

	for (@string)
	{
		s/\"\"/"/g;
	}

	return wantarray ? @string : $string[0];
}

sub trimquotes
{
	my @string = trimspaces(@_);

	for (@string)
	{
		if (m/^\".*\"$/)
		{
			s/^\"//;
			s/\"$//;
		}
	}

	return wantarray ? @string : $string[0];
}

sub undefspaces
{
	my @string = trimspaces(@_);

	for (@string)
	{
		if ($_ eq '')
		{
			$_ = undef;
		}
	}

	return wantarray ? @string : $string[0];
}

sub report
{
    my ($text, $level) = @_;

    $level = kNormal unless $level;

    if ($level <= $gReportLevel)
    {
        print $text . "\n";
    }
}

sub _convertDate
{
	my $date = shift;
	my $newValue;

	my ($year, $month, $day);
	if ((($year, $month, $day) = Date::Calc::Decode_Date_US($date))
	 || (($year, $month, $day) = Date::Calc::Decode_Date_EU($date))
	 || (($year, $month, $day) = decodeDateMysql($date)))
	{
		$newValue = sprintf("%4d-%02d-%02d", $year, $month, $day);
	}

	return $newValue;
}

sub _myNormalizeUPC
{
	my $upc = shift;

	if(length($upc) > 10)
	{
		$upc =~ s/^0+//;
	}

	if(length($upc) == 10)
	{
		# assume it needs the "format" digit on the end (2)
		$upc = $upc."2";
	}

	return normalize_upc($upc);
}