#!/usr/bin/perl -Imodules

#use Cluster::Clustering;
use Time::HiRes;

my @R				= ();
my @SW				= ();
my @CON				= ();
my @DOUBLE			= ();
my @CLUSTERRESULTS	= ();
my $CLUSTERDESC		= {};
my $CLUSTERTITLE	= {};
my $RESULTCLUSTER	= {};	
my $HashRefDoubleItems = {};

my $temp;
my $count	= 0;
my $clustercount	= 0;
my $wordcount = 0;
my $ResultCountTitle = 0;
my $ResultCountDesc	 = 0;
my $ClusterCountItems = {};

# kommt später aus der config:

my $MaxCountClusterTitle		= 5;
my $MaxCountClusterDesc			= 5;
my $IgnoreResultsShorterThan	= 4;
my $IgnoreWordsShorterThan		= 2;


open(RH, "<CLUSTER.txt");
	@CON = <RH>;
close RH;

open(SW, "<stopwords.txt");
	@SW = <SW>;
close SW;

my $s1 = Time::HiRes::time();

foreach my $line ( @CON ) {
	my ( $url, $title, $desc, $engine ) = split('#\t#', $line);
	$ResultHashRefUrl{$count}		= $url;
	$ResultHashRefTitle{$count}		= $title;
	$ResultHashRefDesc{$count}		= $desc;
	$ResultHashRefEngine{$count}	= $engine;
	$ResultHashRefBoost{$count}		= "1.0";
	$count++;
};


# für alle descriptions, splitte die einzelnen wörter auf und speichere sie in einer Hashreferenz, die zeiger auf die entsprechende
# arrayreferenz mit den einzelnen wörtern der description enthält

for ( my $i=0; $i<=$count; $i++ ) {
	
	my @R = split(' ', $ResultHashRefDesc{$i}); 
	my @Q = split(' ', $ResultHashRefTitle{$i}); 

	# hier folgt der algoritmus zum entfernene der stopwörter aus der description des jeweiligen eintrages
	foreach my $sw ( @SW ) {
		chomp($sw);
		foreach my $r ( @R ) {
			next if ( $r eq ' ' );	# ignoriere leerzeichen 
			if ( lc($sw) eq lc($r) ) {
				undef $r;
			};
		};
	};

	foreach my $sw ( @SW ) {
		chomp($sw);
		foreach my $q ( @Q ) {
			next if ( $q eq ' ' );
			if ( lc($sw) eq lc($q) ) {
				undef $q;
			};
		};
	};

	$CLUSTERDESC{$i}  = \@R;
	$CLUSTERTITLE{$i} = \@Q;

};


# fische die doppelten Einträge herraus
# Wichtig; bei $i=1 anfangen zu zählen und bei $j=0 !!!!!!!

for ( my $i=1 ; $i<=$count ; $i++ ) {
	for ( my $j=0 ; $j<=$count ; $j++ ) {
		next if ( $i == $j );
		if ( $ResultHashRefUrl{$i} eq $ResultHashRefUrl{$j} ) {
			push(@DOUBLE, "$i $j");
		};
	};
};


# für jeden doppelten eintrag lösche diesen, merke dir aber in welcher suchmaschine der eintrag doppelt vorkam

foreach my $double ( @DOUBLE ) {
	my ( $i, $j ) = split(' ', $double );
	
	chomp($ResultHashRefEngine{$i});
	chomp($ResultHashRefEngine{$j});

	if ( $ResultHashRefEngine{$i} eq '' ) {
		next if ( $ResultHashRefEngine{$j} eq '' );
		$temp = "$ResultHashRefEngine{$j}";
	} elsif ( $ResultHashRefEngine{$j} eq '' ) {
		next if ( $ResultHashRefEngine{$i} eq '' );
		$temp = "$ResultHashRefEngine{$i}";
	} elsif ( $ResultHashRefEngine{$i} ne '' && $ResultHashRefEngine{$j} ne ''  ) {
		$temp = "$ResultHashRefEngine{$i}" . " " . "$ResultHashRefEngine{$j}";
	};

	delete $ResultHashRefEngine{$i};
	delete $ResultHashRefUrl{$j};
	delete $ResultHashRefTitle{$j};
	delete $ResultHashRefDesc{$j};
	delete $ResultHashRefEngine{$j};
	delete $ResultHashRefBoost{$j};
	
	$ResultHashRefEngine{$i} = $temp;
	$ResultHashRefBoost{$i} = "1.0";

	# Algorithmus zur Bestimmung des Neuen Boost Faktors
	my @COUNTENGINES = split(' ', $ResultHashRefEngine{$i});
	$ResultHashRefBoost{$i} = ( $ResultHashRefBoost{$i} ) + (( $#COUNTENGINES + 1 ) / 10 );
	
};


# Alle leerzeichen entfernen
for ( my $i=1 ; $i<=$count ; $i++ ) {
	chomp($ResultHashRefUrl{$i});
	chomp($ResultHashRefTitle{$i});
	chomp($ResultHashRefDesc{$i});
	chomp($ResultHashRefEngine{$i});
	chomp($ResultHashRefBoost{$i});
};


#	Vergleich von 2 Wörtern von Description mit allen anderen 2er paaren der restlichen descriptions
for ( my $i=0; $i<=$count; $i++ ) {
	
	next if ( $ResultCountDesc >= $MaxCountClusterDesc );	#	 zähle nur die ersten X Ergebnisse als Cluster 
	next if ( $ResultHashRefUrl{$i} eq '' );				#	 überspringe leere elemente
	
	#	für alle einzelnen wörter aus dem array $i 
	for ( $m=0; $m<=$#{$CLUSTERDESC{$i}} ; $m++ ) {
		
		#	baue eine for schleife über alle $count einträge,
		#	diese scheife wird dann benutzt, um das element @{$CLUSTERDESC{$i}}[$m] mit @{$CLUSTERDESC{$j}}[0] bist @{$CLUSTERDESC{$j}}[$n] zu vergleichen
		for ($j=0; $j<=$count ; $j++ ) {

			next if ( $ResultCountDesc >= $MaxCountClusterDesc );
			next if ( $ResultHashRefUrl{$j} eq '' );	#	überspringe leere elemente
			next if ( $i == $j );						#	überspringe den vergleich des Arrays $i mit sich selbst

			#	vergleiche alle elemente von @{$CLUSTERDESC{$j}}[] mit @{$CLUSTERDESC{$i}}[$m]
			for ( $n=0; $n<=$#{$CLUSTERDESC{$j}} ; $n++ ) {
				
				next if ( $ResultCountDesc >= $MaxCountClusterDesc );
				$wordcount++;

				#	speed hacks - ignoriere alles was kürzer/gleich $IgnoreResultsShorterThan buchstaben ist
				next if ( length(@{$CLUSTERDESC{$i}}[$m]) <= $IgnoreResultsShorterThan );
				next if ( length(@{$CLUSTERDESC{$i}}[$m+1]) <= $IgnoreResultsShorterThan );
				next if ( length(@{$CLUSTERDESC{$j}}[$n]) <= $IgnoreResultsShorterThan );
				next if ( length(@{$CLUSTERDESC{$j}}[$n+1]) <= $IgnoreResultsShorterThan );
	
				my $StrOne	= @{$CLUSTERDESC{$i}}[$m] . " " . @{$CLUSTERDESC{$i}}[$m+1];
				my $StrTwo	= @{$CLUSTERDESC{$j}}[$n] . " " . @{$CLUSTERDESC{$j}}[$n+1];
				
				if ( lc($StrOne) eq lc($StrTwo) ) {	# 2 wörter aus der description sind mit den 2 anderen identisch
					
					$HashRefDoubleItems{$StrOne}++;

					if ( $HashRefDoubleItems{$StrOne} >= 2) {
					};

					my $CompleteOne = "$ResultHashRefUrl{$i} $ResultHashRefTitle{$i} $ResultHashRefDesc{$i} $ResultHashRefBoost{$i} $ResultHashRefEngine{$i}";
					my $CompleteTwo = "$ResultHashRefUrl{$j} $ResultHashRefTitle{$j} $ResultHashRefDesc{$j} $ResultHashRefBoost{$j} $ResultHashRefEngine{$j}";
					print "$HashRefDoubleItems{$StrOne} - $StrOne\n ";
					# speichere $ResultHashRefTitle{$i} und $ResultHashRefTitle{$j} als Cluster
				
				};
			};
		};
	};
};


$HashRefDoubleItems = {};	
$ClusterCountItems  = {};

my $s2 = Time::HiRes::time();
my $sec = $s2 - $s1;

print "vergleich von $wordcount wörtern dauerte $sec Sekunden\n";
print "$clustercount\n";


# print <<END;
# <b>Cluster $$match </b><br>
#
#
#END

#		if ( $HashRefDoubleItems{$StrOne} >= 2) {	#	ignoriere das vorkommen von doppelten clustern
#			
#			next if ( $ResultHashRefUrl{$i} eq '' );
#			next if ( $ResultHashRefTitle{$i} eq '' );
#			next if ( $ResultHashRefDesc{$i} eq '' );
#			next if ( $ResultHashRefEngine{$i} eq '' );
##			next if ( $ResultHashRefBoost{$i} eq '' );
#
#		#	print "$HashRefDoubleItems{$StrOne} DESC: '$StrOne'\n";
#
#		} else {
#
#			# es gibt nur 2 ergebnisse 
#			next if ( $ResultHashRefUrl{$i} eq '' );
#			next if ( $ResultHashRefTitle{$i} eq '' );
#			next if ( $ResultHashRefDesc{$i} eq '' );
#			next if ( $ResultHashRefEngine{$i} eq '' );
#			next if ( $ResultHashRefBoost{$i} eq '' );
#		
#	#		print "DESC: '$StrOne'\n";
#			
#	#		$ResultCountDesc++;
#			$clustercount++;
#		};


#	$RESULTCLUSTER{$clustercount}														= "desc";
#	$RESULTCLUSTER{$clustercount}{'MATCH'}												= $StrOne;
#	$RESULTCLUSTER{$clustercount}{'MATCH'}{'URL'}										= $ResultHashRefUrl{$i};
#	$RESULTCLUSTER{$clustercount}{'MATCH'}{'URL'}{'TITLE'}								= $ResultHashRefTitle{$i};
#	$RESULTCLUSTER{$clustercount}{'MATCH'}{'URL'}{'TITLE'}{'DESC'}						= $ResultHashRefDesc{$i};
#	$RESULTCLUSTER{$clustercount}{'MATCH'}{'URL'}{'TITLE'}{'DESC'}{'ENGINE'}			= $ResultHashRefEngine{$i};
#	$RESULTCLUSTER{$clustercount}{'MATCH'}{'URL'}{'TITLE'}{'DESC'}{'ENGINE'}{'BOOST'}	= $ResultHashRefBoost{$i};
#
#	delete $ResultHashRefUrl{$i};
#	delete $ResultHashRefTitle{$i};
###	delete $ResultHashRefDesc{$i};
#	delete $ResultHashRefEngine{$i};
#	delete $ResultHashRefBoost{$i};
