#!/usr/local/bin/perl
###########################################################
# Plik: rankingfactors.pl                                 #
# Opis: Skrypt wykonuje analizę kilku czynników           #
#       wpływających na pozycję strony w rankingu,        #
#       w tym analizuje:                                  #
# 1) Słowa kluczowe w tytułach stron                      #
# 2) Słowa kluczowe w nazwach domen                       #
# 3) Słowa kluczowe w treści strony                       #
# 4) Słowa kluczowe w nagłówkach                          #
# 5) Słowa kluczowe w opisach meta                        #
# 6) Bliskość słów kluczowych                             #
# 7) Słowa kluczowe w linkach zewnętrznych                #
# 8) Rozmiar strony                                       #
# 9) Liczbę słów na stronę                                #
# 10) Rozmiar witryny                                     #
# i wiele innych czynników...                             #
#                                                         #
# Format: perl rankingfactors.pl 10|100 słowo(a) kluczowe #
###########################################################

use LWP::Simple;
use LWP::UserAgent;
use HTML::TokeParser;
use HTML::TreeBuilder;
use File::Path;
use Math::Round qw(:all);

my $keyphrase = "";

my @googleLinks = ( );
my @googleTitles = ( );
my @yahooLinks = ( );
my @yahooTitles = ( );
my @bingLinks = ( );
my @bingTitles = ( );

#w razie potrzeby stwórz frazę/słowo kluczowe
foreach $argnum (1 .. $#ARGV) {
    $keyphrase = $keyphrase . "$ARGV[$argnum] ";
}
my $numres = $ARGV[0];
$keyphrase =~ s/^\s+//;
$keyphrase =~ s/\s+$//;
$keyphrase =~ s/'//g;
$keyphrase =~ s/"//g;

print "\nUruchamianie..";
#czyszczenie plików tymczasowych
rmtree( './serptemp', {keep_root => 1} );
print "\n.. czyszczenie zakończone ";
#incicjalizacja zmiennych
initializeKeyVariables($keyphrase, \@googleLinks,
                    \@googleTitles, \@yahooLinks,
                    \@yahooTitles, \@bingLinks,
                    \@bingTitles);
#zapisywanie wszytskich docelowych linków znalezionych na stronach z wynikami wyszukiwania
print "\n..pobieranie stron z wynikami wyszukiwania";
getSERPResults($#googleLinks, \@googleLinks, "google");
getSERPResults($#yahooLinks,\@yahooLinks, "yahoo");
getSERPResults($#bingLinks,\@bingLinks, "bing");
print "\n..pobrano strony z wynikami wyszukiwania";


#-------------------Analiza tytułów-----------------------
#pobieranie rzeczywistych tytułów
my @googleRealTitles = ( );
my @yahooRealTitles = ( );
my @bingRealTitles = ( );
getRealTitles($#googleLinks, \@googleRealTitles, "google");
getRealTitles($#yahooLinks,\@yahooRealTitles, "yahoo");
getRealTitles($#bingLinks,\@bingRealTitles, "bing");
print "\n..pobrano rzeczywiste tytuły";

#pobranie rzeczywistych tytułów z tytułami na stronach z wynikami wyszukiwania
my @googleTitleComp = ( );
my @yahooTitleComp = ( );
my @bingTitleComp = ( );
my $percentMatchTitlesGoogle = compareArrays($#googleTitles,\@googleRealTitles,
\@googleTitles,

\@googleTitleComp);
my $percentMatchTitlesYahoo = compareArrays($#yahooTitles,\@yahooRealTitles,
\@yahooTitles, \@yahooTitleComp);
my $percentMatchTitlesBing = compareArrays($#bingTitles,\@bingRealTitles,
\@bingTitles, \@bingTitleComp);
print "\n..zakończono częściowe porównanie tytułów";

#szukanie dopasowań słów kluczowych
my @googleKeywordTitleMatch = ( );
my @yahooKeywordTitleMatch = ( );
my @bingKeywordTitleMatch = ( );
getKeywordsTitleMatch($keyphrase, \@googleRealTitles,$#googleRealTitles,
\@googleKeywordTitleMatch );

getKeywordsTitleMatch($keyphrase, \@yahooRealTitles, $#yahooRealTitles,
\@yahooKeywordTitleMatch);
getKeywordsTitleMatch($keyphrase, \@bingRealTitles, $#bingRealTitles,
\@bingKeywordTitleMatch);
print "\n..zakończono porównywanie słów kluczowych tytułów";

#sprawdzanie czy słowa kluczowe znalezione w tytule znajdują się w treści strony
my @googleKeywordTitlePageCopy = ( );
my @yahooKeywordTitlePageCopy = ( );
my @bingKeywordTitlePageCopy = ( );
compareTitlePageCopy($#googleRealTitles,\@googleRealTitles,
\@googleKeywordTitlePageCopy, "google");
compareTitlePageCopy($#yahooRealTitles,\@yahooRealTitles,
\@yahooKeywordTitlePageCopy, "yahoo");
compareTitlePageCopy($#bingRealTitles,\@bingRealTitles,
\@bingKeywordTitlePageCopy, "bing");
print "\n..zakończono porównywanie tytułu i treści strony";


#-------------------Analiza nazwy domeny-----------------------

#dopasowanie dokładne
my @googleDomainKeywordExactMatch = ( );
my @yahooDomainKeywordExactMatch = ( );
my @bingDomainKeywordExactMatch = ( );
my $percentDomainKeywordExactMatchGoogle = keywordDomainExactMatch($keyphrase,
\@googleLinks, $#googleLinks,
\@googleDomainKeywordExactMatch);
my $percentDomainKeywordExactMatchYahoo = keywordDomainExactMatch($keyphrase,
\@yahooLinks, $#yahooLinks,
\@yahooDomainKeywordExactMatch);
my $percentDomainKeywordExactMatchBing = keywordDomainExactMatch($keyphrase,
\@bingLinks, $#bingLinks,
\@bingDomainKeywordExactMatch);
print "\n..zakończono analizę dokładnych dopasowań słów kluczowych w nazwie domeny";

#dopasowanie częściowe
my @googleDomainKeywordPartialMatch = ( );
my @yahooDomainKeywordPartialMatch = ( );
my @bingDomainKeywordPartialMatch = ( );
$percentDomainKeywordPartialMatchGoogle = keywordDomainPartialMatch($keyphrase,
\@googleLinks, $#googleLinks,
\@googleDomainKeywordPartialMatch);
$percentDomainKeywordPartialMatchYahoo = keywordDomainPartialMatch($keyphrase,
\@yahooLinks, $#yahooLinks,
\@yahooDomainKeywordPartialMatch);
$percentDomainKeywordPartialMatchBing = keywordDomainPartialMatch($keyphrase,
\@bingLinks, $#bingLinks,
\@bingDomainKeywordPartialMatch);
print "\n..zakończono analizę częściowych dopasowań słów kluczowych w nazwie domeny";


#-------------------Analiza treści strony----------------------------
my @googleKeywordDensity = ( );
my @yahooKeywordDensity = ( );
my @bingKeywordDensity = ( );
my $googleAvgDensity = keywordDensity($#googleLinks, $keyphrase,
\@googleKeywordDensity, "google");
my $yahooAvgDensity = keywordDensity($#yahooLinks, $keyphrase,
\@yahooKeywordDensity, "yahoo");
my $bingAvgDensity = keywordDensity($#bingLinks, $keyphrase,
\@bingKeywordDensity, "bing");

#-------------------Analiza znaczników opisowych META------------------
my @googleDescriptionMetaExact = ( );
my @yahooDescriptionMetaExact = ( );
my @bingDescriptionMetaExact = ( );

checkExactDescriptionMeta($#googleLinks, \@googleDescriptionMetaExact,
$keyphrase, "google");
checkExactDescriptionMeta($#yahooLinks, \@yahooDescriptionMetaExact,
$keyphrase, "yahoo");
checkExactDescriptionMeta($#bingLinks, \@bingDescriptionMetaExact,
$keyphrase, "bing");

my @googleDescriptionMetaPartial = ( );
my @yahooDescriptionMetaPartial = ( );
my @bingDescriptionMetaPartial = ( );

checkPartialDescriptionMeta($#googleLinks, \@googleDescriptionMetaPartial,
$keyphrase, "google");
checkPartialDescriptionMeta($#yahooLinks, \@yahooDescriptionMetaPartial,
$keyphrase, "yahoo");
checkPartialDescriptionMeta($#bingLinks, \@bingDescriptionMetaPartial,
$keyphrase, "bing");
print "\n..zakończono analizę opisów META";

#-------------------Analiza znaczników nagłówków----------------------------
my @googleNumberOfHeaderTags = ( );
my @yahooNumberOfHeaderTags = ( );
my @bingNumberOfHeaderTags = ( );
my @googleHeaderTagsKeywords = ( );
my @yahooHeaderTagsKeywords = ( );
my @bingHeaderTagsKeywords = ( );

checkHeaderTags($#googleLinks, \@googleNumberOfHeaderTags,
\@googleHeaderTagsKeywords, "google", $keyphrase);
checkHeaderTags($#yahooLinks, \@yahooNumberOfHeaderTags,
\@yahooHeaderTagsKeywords, "yahoo", $keyphrase);
checkHeaderTags($#bingLinks, \@bingNumberOfHeaderTags,
\@bingHeaderTagsKeywords, "bing", $keyphrase);
print "\n..zakończono analizę znaczników nagłówków";

#-------------------Analiza zagęszczenia słów kluczowych---------------------
my @googleKeywordPositions = ( );
my @yahooKeywordPositions = ( );
my @bingKeywordPositions = ( );
my @googleKeywordPositionsList = ( );
my @yahooKeywordPositionsList = ( );
my @bingKeywordPositionsList = ( );
analyzeKeywordPositions($#googleLinks, \@googleKeywordPositions,
\@googleKeywordPositionsList, "google",
$keyphrase);
analyzeKeywordPositions($#yahooLinks, \@yahooKeywordPositions,
\@yahooKeywordPositionsList, "yahoo", $keyphrase);
analyzeKeywordPositions($#bingLinks, \@bingKeywordPositions,
\@bingKeywordPositionsList, "bing", $keyphrase);
print "\n..zakończono analizę zagęszczenia słów kluczowych";

#-------------------Analiza linków zewnętrznych--------------------------
my @googleOutboundLinkKeywords = ( );
my @yahooKOutboundLinkKeywords = ( );
my @bingOutboundLinkKeywords = ( );
outboundLinkKeywordAnalysis($#googleLinks, \@googleLinks,
\@googleOutboundLinkKeywords, "google", $keyphrase);
outboundLinkKeywordAnalysis($#yahooLinks, \@yahooLinks,
\@yahooKOutboundLinkKeywords, "yahoo", $keyphrase);
outboundLinkKeywordAnalysis($#bingLinks, \@bingLinks,
\@bingOutboundLinkKeywords, "bing", $keyphrase);
print "\n..zakończono analizę linków zewnętrznych";

#-------------------Analiza PR linków zewnętrznych--------------------------
my @googleOutboundLinksPR = ( );
my @yahooKOutboundLinksPR = ( );
my @bingOutboundLinksPR = ( );
outboundLinkPRAnalysis($#googleLinks, \@googleLinks,
\@googleOutboundLinksPR, "google", $keyphrase);
outboundLinkPRAnalysis($#yahooLinks, \@yahooLinks,
\@yahooKOutboundLinksPR, "yahoo", $keyphrase);
outboundLinkPRAnalysis($#bingLinks, \@bingLinks,
\@bingOutboundLinksPR, "bing", $keyphrase);
print "\n..zakończono analizę PR linków zewnętrznych";

#-------------------Analiza średniego rozmiaru strony--------------------------
my @googlePageSize = ( );
my @yahooPageSize = ( );
my @bingPageSize = ( );
my $googleAvgPageSize = averagePageSize($#googleLinks, \@googlePageSize, "google");
my $yahooAvgPageSize = averagePageSize($#yahooLinks, \@yahooPageSize, "yahoo");
my $bingAvgPageSize = averagePageSize($#bingLinks, \@bingPageSize, "bing");
print "\n..zakończono analizę średniego rozmiaru strony";

#-------------------Analiza optymalnej liczby słów kluczowych--------------------
my @googleWords = ( );
my @yahooWords = ( );
my @bingWords = ( );
my $googleWordsPerPage = optimumWordsPerPage($#googleLinks, \@googleWords, "google");
my $yahooWordsPerPage = optimumWordsPerPage($#yahooLinks, \@yahooWords, "yahoo");
my $bingWordsPerPage = optimumWordsPerPage($#bingLinks, \@bingWords, "bing");
print "\n..zakończono analizę optymalnej liczby słów kluczowych na stronę";

#-------------------Analiza rozmiaru strony -------------------------------
my @googleResultsWebsiteSizes = ( );
my @yahooResultsWebsiteSizes = ( );
my @bingResultsWebsiteSizes = ( );
my $googleAverageWebSize = analyzeWebsiteSize($#googleLinks, \@googleLinks,
\@googleResultsWebsiteSizes);
my $yahooAverageWebSize = analyzeWebsiteSize($#yahooLinks, \@yahooLinks,
\@yahooResultsWebsiteSizes);
my $bingAverageWebSize = analyzeWebsiteSize($#bingLinks, \@bingLinks,
\@bingResultsWebsiteSizes);
print "\n..zakończono analizę rozmiaru strony internetowej";

#-------------------Analiza wieku strony-----------------------------------
my @googlePageAge = ( );
my @yahooPageAge = ( );
my @bingPageAge = ( );
pageAgeAnalysis($#googleLinks, \@googleLinks, \@googlePageAge);
pageAgeAnalysis($#yahooLinks, \@yahooLinks, \@yahooPageAge);
pageAgeAnalysis($#bingLinks, \@bingLinks, \@bingPageAge);


#-------------------Tworzenie raportu HTML---------------------------------
#tworzenie pliku index
createIndexHTML($keyphrase);

my $numberOfLinesGoogle = $#googleLinks;
my $numberOfLinesYahoo = $#yahooLinks;
my $numberOfLinesBing = $#bingLinks;

createGoogleHTMLReport();
createYahooHTMLReport();
createBingHTMLReport();

#---------------------------PODPROGRAMY---------------------------
# Podprogram:
#   createGoogleHTMLReport
# Opis:
#   Ten podprogram tworzy plik google.html 
#   z podsumowaniem wyników dla wyszukiwarki Google
# Zmienne wejściowe:
#   Brak
# Zmienne wyjściowe:
#   Tworzy plik google.html
# Zwraca:
#   Nic
sub createGoogleHTMLReport {
    #tworzenie tabeli podsumowania
    my $googleFile = "<html><head><title>Raport podsumowujący dla wyszukiwarki Google</title>";
    $googleFile .= "<style>";
    $googleFile .=
"body, td, tr{font-family: \"Trebuchet ms\", verdana, sans-serif; font-size:9px;}";
    $googleFile .=
"b{font-family: \"Trebuchet ms\", verdana, sans-serif;font-size:10px;}";
    $googleFile .= "</style>";
    $googleFile .= "</head>";
    $googleFile .= "<body><h1>Raport podsumowujący</h1>";
    $googleFile .= "<br>";
    $googleFile .=
"<table border=\"1\" width=\"500\" cellspacing=\"2\" cellpadding=\"2\">";
    $googleFile .= "<tr><td colspan=2><b>Wartości średnie</b></td>";
    $googleFile .= "</tr>";
    $googleFile .= "<tr>";
    $googleFile .= "<td><b>% dopasowania tytułu</b></td>";
    my $tmp = sprintf "%.1f", $percentMatchTitlesGoogle;
    $googleFile .= "<td>$tmp</td>";
    $googleFile .= "</tr>";
    $googleFile .= "<tr>";
    $googleFile .= "<td><b>% dokładnego dopasowania słów kluczowych w nazwie domeny</b></td>";
    $tmp = sprintf "%.1f", $percentDomainKeywordExactMatchGoogle;
    $googleFile .= "<td>$tmp</td>";
    $googleFile .= "</tr>";
    $googleFile .= "<tr>";
    $googleFile .= "<td><b>% częściowego dopasowania słów kluczowych w nazwie domeny</b></td>";
    $tmp = sprintf "%.1f", $percentDomainKeywordPartialMatchGoogle;
    $googleFile .= "<td>$tmp</td>";
    $googleFile .= "</tr>";
    $googleFile .= "<tr>";
    $googleFile .= "<td><b>% zagęszczenie słów kluczowych</b></td>";
    $tmp = sprintf "%.1f", $googleAvgDensity;
    $googleFile .= "<td>$tmp</td>";
    $googleFile .= "</tr>";
    $googleFile .= "<tr>";
    $googleFile .= "<td><b>Rozmiar strony [bajty]</b></td>";
    $tmp = sprintf "%.0f", $googleAvgPageSize;
    $googleFile .= "<td>$tmp</td>";
    $googleFile .= "</tr>";
    $googleFile .= "<tr>";
    $googleFile .= "<td><b>Liczba słów na stronę</b></td>";
    $tmp = sprintf "%.0f", $googleWordsPerPage;
    $googleFile .= "<td>$tmp</td>";
    $googleFile .= "</tr>";
    $googleFile .= "<tr>";
    $googleFile .= "<td><b>Rozmiar witryny [bazowych adresów URL]</b></td>";
    $tmp = round($googleAverageWebSize);
    $googleFile .= "<td>$tmp</td>";
    $googleFile .= "</tr>";
    $googleFile .= "</table><br><br>";
    $googleFile .= "<b>Tabela szczegółowa</b> <br>";
    $googleFile .= "<table border=1 cellpadding=2 cellspacing=2>";
    $googleFile .= "<tr>";
    $googleFile .= "<td nowrap>#</td>";
    $googleFile .= "<td width='100'><b>URL</b></td>";
    $googleFile .= "<td nowrap width='150'><b>Tytuł Google</b></td>";
    $googleFile .= "<td nowrap width='150'><b>Tytuł strony</b></td>";
    $googleFile .= "<td nowrap><b>Słowa kluczowe<br> znalezione w tytule? [Y|N]</b></td>";
    $googleFile .= "<td nowrap><b>Słowa kluczowe <br>w treści strony[%]</b></td>";
    $googleFile .= "<td nowrap><b>Dokładne dopasowania <br>w nazwie domeny</b></td>";
    $googleFile .= "<td nowrap><b>Częściowe dopasowania <br>w nazwie domeny</b></td>";
    $googleFile .= "<td nowrap><b>Zagęszczenie słów<br> kluczowych</b></td>";
    $googleFile .= "<td nowrap><b>Dokładne dopasowania <br>w opisach META</b></td>";
    $googleFile .= "<td nowrap><b>Częściowe dopasowania <br>w opisach META</b></td>";
    $googleFile .= "<td nowrap><b>Znaczniki nagłówków</b></td>";
    $googleFile .= "<td nowrap><b>Słowa kluczowe<br>w znacznikach nagłówków</b></td>";
    $googleFile .= "<td nowrap width='350'><b>Pozycje słów kluczowych <br> na stronie</b></td>";
    $googleFile .= "<td nowrap><b>Mapa zagęszczenia <br>słów kluczowych</b></td>";
    $googleFile .= "<td nowrap><b>Linki zewnętrzne <br> ze słowami kluczowymi</b></td>";
    $googleFile .= "<td nowrap width='150'><b>Wskaźnik PR<br> linków zewnętrznych</b></td>";
    $googleFile .= "<td nowrap><b>Rozmiar strony<br>[bajty]</b></td>";
    $googleFile .= "<td nowrap><b>Liczba słów<br> na stronie</b></td>";
    $googleFile .= "<td nowrap><b>Rozmiar witryny <br> internetowej</b></td>";
    $googleFile .= "<td nowrap><b>Wiek strony</b></td>";
    $googleFile .= "</tr>";

    for (my $i=0; $i < $numberOfLinesGoogle; $i++) {
        $googleFile .= "<tr>";
        $googleFile .= "<td align=left>$i&nbsp;</td>";
        $googleFile .= "<td align=left>$googleLinks[$i]&nbsp;</td>";
        $googleFile .= "<td align=left>$googleTitles[$i]&nbsp;</td>";
        $googleFile .= "<td align=left>$googleRealTitles[$i]&nbsp;</td>";
        $googleFile .= "<td align=left>$googleKeywordTitleMatch[$i]&nbsp;</td>";
        $tmp = sprintf "%.1f", $googleKeywordTitlePageCopy[$i];

        $googleFile .= "<td align=left>$tmp&nbsp;</td>";
        $googleFile .= "<td align=left>$googleDomainKeywordExactMatch[$i]&nbsp;</td>";
        $googleFile .=
"<td align=left>$googleDomainKeywordPartialMatch[$i]&nbsp;</td>";
        $tmp = sprintf "%.3f", $googleKeywordDensity[$i];
        $googleFile .= "<td align=left>$tmp&nbsp;</td>";
        $googleFile .= "<td align=left>$googleDescriptionMetaExact[$i]&nbsp;</td>";
        $googleFile .= "<td align=left>$googleDescriptionMetaPartial[$i]&nbsp;</td>";
        $googleFile .= "<td align=left>$googleNumberOfHeaderTags[$i]&nbsp;</td>";
        $googleFile .= "<td align=left>$googleHeaderTagsKeywords[$i]&nbsp;</td>";
        $tmp = $googleKeywordPositionsList[$i];
        $tmp =~ s/\|/\, /g;
        $googleFile .= "<td align=left>$tmp&nbsp;</td>";
        $googleFile .=
"<td align=left><a href='./maps/google".$i.".html'>Map</a></td>";
        printIndividualKeywordProminenceMap($i, \@googleKeywordPositions, "google");
        $googleFile .= "<td align=left>$googleOutboundLinkKeywords[$i]&nbsp;</td>";
        $googleFile .= "<td align=left>$googleOutboundLinksPR[$i]&nbsp;</td>";
        $googleFile .= "<td align=left>$googlePageSize[$i]&nbsp;</td>";
        $googleFile .= "<td align=left>$googleWords[$i]&nbsp;</td>";
        $googleFile .= "<td align=left>$googleResultsWebsiteSizes[$i]&nbsp;</td>";
        $googleFile .= "<td align=left>$googlePageAge[$i]&nbsp;</td>";
        $googleFile .= "</tr>";
    }
    my $filename = "./report/google.html";
    open FILE, ">", "$filename" or die $!;
    print FILE $googleFile;
    close FILE;
}

# Podprogram:
#   createYahooHTMLReport
# Opis:
#   Ten podprogram tworzy plik yahoo.html
#   z podsumowaniem wyników dla wyszukiwarki Yahoo
# Zmienne wejściowe:
#   Brak
# Zmienne wyjściowe:
#   Tworzy plik yahoo.html
# Zwraca:
#   Nic
sub createYahooHTMLReport {
    #Tworzenie tabeli podsumowania
    my $yahooFile = "<html><head><title>Raport podsumowujący dla wyszukiwarki Yahoo</title>";
    $yahooFile .= "<style>";
    $yahooFile .=
"body, td, tr{font-family: \"Trebuchet ms\", verdana, sans-serif; font-size:9px;}";
    $yahooFile .=
"b{font-family: \"Trebuchet ms\", verdana, sans-serif;font-size:10px;}";
    $yahooFile .= "</style>";
    $yahooFile .= "</head>";
    $yahooFile .= "<body><h1>Raport podsumowujący</h1>";
    $yahooFile .= "<br>";
    $yahooFile .=
"<table border=\"1\" width=\"500\" cellspacing=\"2\" cellpadding=\"2\">";
    $yahooFile .= "<tr><td colspan=2><b>Wartości średnie</b></td>";
    $yahooFile .= "</tr>";
    $yahooFile .= "<tr>";
    $yahooFile .= "<td><b>% dopasowania tytułu</b></td>";
    my $tmp = sprintf "%.1f", $percentMatchTitlesYahoo;
    $yahooFile .= "<td>$tmp</td>";
    $yahooFile .= "</tr>";
    $yahooFile .= "<tr>";
    $yahooFile .= "<td><b>% dokładnego dopasowania słów kluczowych w nazwie domeny </b></td>";
    $tmp = sprintf "%.1f", $percentDomainKeywordExactMatchYahoo;
    $yahooFile .= "<td>$tmp</td>";
    $yahooFile .= "</tr>";
    $yahooFile .= "<tr>";
    $yahooFile .= "<td><b>% częściowego dopasowania słów kluczowych w nazwie domeny </b></td>";
    $tmp = sprintf "%.1f", $percentDomainKeywordPartialMatchYahoo;
    $yahooFile .= "<td>$tmp</td>";
    $yahooFile .= "</tr>";
    $yahooFile .= "<tr>";
    $yahooFile .= "<td><b>% zagęszczenie słów kluczowych </b></td>";
    $tmp = sprintf "%.1f", $yahooAvgDensity;
    $yahooFile .= "<td>$tmp</td>";
    $yahooFile .= "</tr>";
    $yahooFile .= "<tr>";
    $yahooFile .= "<td><b>Rozmiar strony [bajty]</b></td>";
    $tmp = sprintf "%.0f", $yahooAvgPageSize;
    $yahooFile .= "<td>$tmp</td>";
    $yahooFile .= "</tr>";
    $yahooFile .= "<tr>";
    $yahooFile .= "<td><b> Liczba słów na stronę</b></td>";
    $tmp = sprintf "%.0f", $yahooWordsPerPage;
    $yahooFile .= "<td>$tmp</td>";
    $yahooFile .= "</tr>";
    $yahooFile .= "<tr>";
    $yahooFile .= "<td><b> Rozmiar witryny [bazowych adresów URL]</b></td>";
    $tmp = round($yahooAverageWebSize);
    $yahooFile .= "<td>$tmp</td>";
    $yahooFile .= "</tr>";
    $yahooFile .= "</table><br><br>";
    $yahooFile .= "<b>Tabela szczegółowa</b> <br>";
    $yahooFile .= "<table border=1 cellpadding=2 cellspacing=2>";
    $yahooFile .= "<tr>";
    $yahooFile .= "<td nowrap>#</td>";
    $yahooFile .= "<td width='100'><b>URL</b></td>";
    $yahooFile .= "<td nowrap width='150'><b>Tytuł Yahoo</b></td>";
    $yahooFile .= "<td nowrap width='150'><b>Tytuł strony</b></td>";
    $yahooFile .= "<td nowrap><b>Słowa kluczowe<br> znalezione w tytule? [Y|N]</b></td>";
    $yahooFile .= "<td nowrap><b>Słowa kluczowe <br>w treści strony[%]</b></td>";
    $yahooFile .= "<td nowrap><b>Dokładne dopasowania <br>w nazwie domeny</b></td>";
    $yahooFile .= "<td nowrap><b>Częściowe dopasowania <br>w nazwie domeny</b></td>";
    $yahooFile .= "<td nowrap><b>Zagęszczenie słów<br> kluczowych</b></td>";
    $yahooFile .= "<td nowrap><b>Dokładne dopasowania <br>w opisach META</b></td>";
    $yahooFile .= "<td nowrap><b>Częściowe dopasowania <br>w opisach META</b></td>";
    $yahooFile .= "<td nowrap><b>Znaczniki nagłówków</b></td>";
    $yahooFile .= "<td nowrap><b>Słowa kluczowe<br>w znacznikach nagłówków</b></td>";
    $yahooFile .= "<td nowrap width='350'><b>Pozycje słów kluczowych <br> na stronie</b></td>";
    $yahooFile .= "<td nowrap><b>Mapa zagęszczenia <br>słów kluczowych</b></td>";
    $yahooFile .= "<td nowrap><b>Linki zewnętrzne <br> ze słowami kluczowymi</b></td>";
    $yahooFile .= "<td nowrap width='150'><b>Wskaźnik PR<br> linków zewnętrznych</b></td>";
    $yahooFile .= "<td nowrap><b>Rozmiar strony<br>[bajty]</b></td>";
    $yahooFile .= "<td nowrap><b>Liczba słów<br> na stronie</b></td>";
    $yahooFile .= "<td nowrap><b>Rozmiar witryny <br> internetowej</b></td>";
    $yahooFile .= "<td nowrap><b>Wiek strony</b></td>";
    $yahooFile .= "</tr>";

    for (my $i=0; $i < $numberOfLinesYahoo; $i++) {
        $yahooFile .= "<tr>";
        $yahooFile .= "<td align=left>$i&nbsp;</td>";
        $yahooFile .= "<td align=left>$yahooLinks[$i]&nbsp;</td>";
        $yahooFile .= "<td align=left>$yahooTitles[$i]&nbsp;</td>";
        $yahooFile .= "<td align=left>$yahooRealTitles[$i]&nbsp;</td>";
        $yahooFile .= "<td align=left>$yahooKeywordTitleMatch[$i]&nbsp;</td>";
        $tmp = sprintf "%.1f", $yahooKeywordTitlePageCopy[$i];

        $yahooFile .= "<td align=left>$tmp&nbsp;</td>";
        $yahooFile .= "<td align=left>$yahooDomainKeywordExactMatch[$i]&nbsp;</td>";
        $yahooFile .=
"<td align=left>$yahooDomainKeywordPartialMatch[$i]&nbsp;</td>";
        $tmp = sprintf "%.3f", $yahooKeywordDensity[$i];
        $yahooFile .= "<td align=left>$tmp&nbsp;</td>";
        $yahooFile .= "<td align=left>$yahooDescriptionMetaExact[$i]&nbsp;</td>";
        $yahooFile .= "<td align=left>$yahooDescriptionMetaPartial[$i]&nbsp;</td>";
        $yahooFile .= "<td align=left>$yahooNumberOfHeaderTags[$i]&nbsp;</td>";
        $yahooFile .= "<td align=left>$yahooHeaderTagsKeywords[$i]&nbsp;</td>";
        $tmp = $yahooKeywordPositionsList[$i];
        $tmp =~ s/\|/\, /g;
        $yahooFile .= "<td align=left>$tmp&nbsp;</td>";
        $yahooFile .=
"<td align=left><a href='./maps/yahoo".$i.".html'>Map</a></td>";
        printIndividualKeywordProminenceMap($i, \@yahooKeywordPositions, "yahoo");
        $yahooFile .= "<td align=left>$yahooOutboundLinkKeywords[$i]&nbsp;</td>";
        $yahooFile .= "<td align=left>$yahooOutboundLinksPR[$i]&nbsp;</td>";
        $yahooFile .= "<td align=left>$yahooPageSize[$i]&nbsp;</td>";
        $yahooFile .= "<td align=left>$yahooWords[$i]&nbsp;</td>";
        $yahooFile .= "<td align=left>$yahooResultsWebsiteSizes[$i]&nbsp;</td>";
        $yahooFile .= "<td align=left>$yahooPageAge[$i]&nbsp;</td>";
        $yahooFile .= "</tr>";
    }
    my $filename = "./report/yahoo.html";
    open FILE, ">", "$filename" or die $!;
    print FILE $yahooFile;
    close FILE;
}

# Podprogram:
#   createBingHTMLReport
# Opis:
#   Ten podprogram tworzy plik bing.html
#   z podsumowaniem wyników dla wyszukiwarki Bing
# Zmienne wejściowe:
#   Brak
# Zmienne wyjściowe:
#   Tworzy plik bing.html
# Zwraca:
#   Nic
sub createBingHTMLReport {
    #tworzenie tabeli podsumowania
          my $bingFile = "<html><head><title>Raport podsumowujący dla wyszukiwarki Bing</title>";
    $bingFile .= "<style>";
    $bingFile .=
"body, td, tr{font-family: \"Trebuchet ms\", verdana, sans-serif; font-size:9px;}";
    $bingFile .=
"b{font-family: \"Trebuchet ms\", verdana, sans-serif;font-size:10px;}";
    $bingFile .= "</style>";
    $bingFile .= "</head>";
    $bingFile .= "<body><h1>Raport podsumowujący</h1>";
    $bingFile .= "<br>";
    $bingFile .=
"<table border=\"1\" width=\"500\" cellspacing=\"2\" cellpadding=\"2\">";
    $bingFile .= "<tr><td colspan=2><b>Wartości średnie</b></td>";
    $bingFile .= "</tr>";
    $bingFile .= "<tr>";
    $bingFile .= "<td><b>% dopasowania tytułu</b></td>";
    my $tmp = sprintf "%.1f", $percentMatchTitlesBing;
    $bingFile .= "<td>$tmp</td>";
    $bingFile .= "</tr>";
    $bingFile .= "<tr>";
    $bingFile .= "<td><b>% dokładnego dopasowania słów kluczowych w nazwie domeny</b></td>";
    $tmp = sprintf "%.1f", $percentDomainKeywordExactMatchBing;
    $bingFile .= "<td>$tmp</td>";
    $bingFile .= "</tr>";
    $bingFile .= "<tr>";
    $bingFile .= "<td><b>% częściowego dopasowania słów kluczowych w nazwie domeny</b></td>";
    $tmp = sprintf "%.1f", $percentDomainKeywordPartialMatchBing;
    $bingFile .= "<td>$tmp</td>";
    $bingFile .= "</tr>";
    $bingFile .= "<tr>";
    $bingFile .= "<td><b>% zagęszczenie słów kluczowych</b></td>";
    $tmp = sprintf "%.1f", $bingAvgDensity;
    $bingFile .= "<td>$tmp</td>";
    $bingFile .= "</tr>";
    $bingFile .= "<tr>";
    $bingFile .= "<td><b>Rozmiar strony [bajty]</b></td>";
    $tmp = sprintf "%.0f", $bingAvgPageSize;
    $bingFile .= "<td>$tmp</td>";
    $bingFile .= "</tr>";
    $bingFile .= "<tr>";
    $bingFile .= "<td><b>Liczba słów na stronę</b></td>";
    $tmp = sprintf "%.0f", $bingWordsPerPage;
    $bingFile .= "<td>$tmp</td>";
    $bingFile .= "</tr>";
    $bingFile .= "<tr>";
    $bingFile .= "<td><b>Rozmiar witryny [bazowych adresów URL]</b></td>";
    $tmp = round($bingAverageWebSize);
    $bingFile .= "<td>$tmp</td>";
    $bingFile .= "</tr>";
    $bingFile .= "</table><br><br>";
    $bingFile .= "<b>Tabela szczegółowa</b> <br>";
    $bingFile .= "<table border=1 cellpadding=2 cellspacing=2>";
    $bingFile .= "<tr>";
    $bingFile .= "<td nowrap>#</td>";
    $bingFile .= "<td width='100'><b>URL</b></td>";
    $bingFile .= "<td nowrap width='150'><b>Tytuł Bing</b></td>";
    $bingFile .= "<td nowrap width='150'><b>Tytuł strony</b></td>";
    $bingFile .= "<td nowrap><b>Słowa kluczowe<br> znalezione w tytule? [Y|N]</b></td>";
    $bingFile .= "<td nowrap><b>Słowa kluczowe <br>w treści strony[%]</b></td>";
    $bingFile .= "<td nowrap><b>Dokładne dopasowania <br>w nazwie domeny</b></td>";
    $bingFile .= "<td nowrap><b>Częściowe dopasowania <br>w nazwie domeny</b></td>";
    $bingFile .= "<td nowrap><b>Zagęszczenie słów<br> kluczowych</b></td>";
    $bingFile .= "<td nowrap><b>Dokładne dopasowania <br>w opisach META</b></td>";
    $bingFile .= "<td nowrap><b>Częściowe dopasowania <br>w opisach META</b></td>";
    $bingFile .= "<td nowrap><b>Znaczniki nagłówków</b></td>";
    $bingFile .= "<td nowrap><b>Słowa kluczowe<br>w znacznikach nagłówków</b></td>";
    $bingFile .= "<td nowrap width='350'><b>Pozycje słów kluczowych <br> na stronie</b></td>";
    $bingFile .= "<td nowrap><b>Mapa zagęszczenia <br>słów kluczowych</b></td>";
    $bingFile .= "<td nowrap><b>Linki zewnętrzne <br> ze słowami kluczowymi</b></td>";
    $bingFile .= "<td nowrap width='150'><b>Wskaźnik PR<br> linków zewnętrznych</b></td>";
    $bingFile .= "<td nowrap><b>Rozmiar strony<br>[bajty]</b></td>";
    $bingFile .= "<td nowrap><b>Liczba słów<br> na stronie</b></td>";
    $bingFile .= "<td nowrap><b>Rozmiar witryny <br> internetowej</b></td>";
    $bingFile .= "<td nowrap><b>Wiek strony</b></td>";
    $bingFile .= "</tr>";
    
    for (my $i=0; $i < $numberOfLinesBing; $i++) {
        $bingFile .= "<tr>";
        $bingFile .= "<td align=left>$i&nbsp;</td>";
        $bingFile .= "<td align=left>$bingLinks[$i]&nbsp;</td>";
        $bingFile .= "<td align=left>$bingTitles[$i]&nbsp;</td>";
        $bingFile .= "<td align=left>$bingRealTitles[$i]&nbsp;</td>";
        $bingFile .= "<td align=left>$bingKeywordTitleMatch[$i]&nbsp;</td>";
        $tmp = sprintf "%.1f", $bingKeywordTitlePageCopy[$i];

        $bingFile .= "<td align=left>$tmp&nbsp;</td>";
        $bingFile .= "<td align=left>$bingDomainKeywordExactMatch[$i]&nbsp;</td>";
        $bingFile .= "<td align=left>$bingDomainKeywordPartialMatch[$i]&nbsp;</td>";
        $tmp = sprintf "%.3f", $bingKeywordDensity[$i];
        $bingFile .= "<td align=left>$tmp&nbsp;</td>";
        $bingFile .= "<td align=left>$bingDescriptionMetaExact[$i]&nbsp;</td>";
        $bingFile .= "<td align=left>$bingDescriptionMetaPartial[$i]&nbsp;</td>";
        $bingFile .= "<td align=left>$bingNumberOfHeaderTags[$i]&nbsp;</td>";
        $bingFile .= "<td align=left>$bingHeaderTagsKeywords[$i]&nbsp;</td>";
        $tmp = $bingKeywordPositionsList[$i];
        $tmp =~ s/\|/\, /g;
        $bingFile .= "<td align=left>$tmp&nbsp;</td>";
        $bingFile .= "<td align=left><a href='./maps/bing".$i.".html'>Map</a></td>";
        printIndividualKeywordProminenceMap($i, \@bingKeywordPositions, "bing");
        $bingFile .= "<td align=left>$bingOutboundLinkKeywords[$i]&nbsp;</td>";
        $bingFile .= "<td align=left>$bingOutboundLinksPR[$i]&nbsp;</td>";
        $bingFile .= "<td align=left>$bingPageSize[$i]&nbsp;</td>";
        $bingFile .= "<td align=left>$bingWords[$i]&nbsp;</td>";
        $bingFile .= "<td align=left>$bingResultsWebsiteSizes[$i]&nbsp;</td>";
        $bingFile .= "<td align=left>$bingPageAge[$i]&nbsp;</td>";
        $bingFile .= "</tr>";
    }
    my $filename = "./report/bing.html";
    open FILE, ">", "$filename" or die $!;
    print FILE $bingFile;
    close FILE;
}

# Podprogram:
#   createIndexHTML
# Opis:
#   Ten podprogram tworzy fragment kodu HTML dla pliku index 
#   szukając ostatnio zmodyfikowanego łańcucha znaków
# Zmienne wejściowe:
#   $keyword => słowo kluczowe
# Zmienne wyjściowe:
#   Tworzy plik index.html
# Zwraca:
#   Nic
sub createIndexHTML {
    my $keyword = shift;

    my $indexFile = "<html><head><title>Raport podsumowujący</title></head>";
    $indexFile .= "<body><center><strong>Raport podsumowujący";
    $indexFile .= " (for \"$keyword\") <br><br>";
    $indexFile .=
"<a href=\"#\" onclick=\"document.all.myiframe.src='google.html\'\">";
    $indexFile .= "Google</a> |";
    $indexFile .=
"<a href=\"#\" onclick=\"document.all.myiframe.src='yahoo.html'\">";
    $indexFile .= "Yahoo!</a> |";
    $indexFile .=
"<a href=\"#\" onclick=\"document.all.myiframe.src='bing.html'\">";
    $indexFile .= "Bing</a><br><br>";
    $indexFile .= "Kliknij na link, aby wyświetlić raport...<br><br>";
    $indexFile .=
"<iframe name=\"myiframe\" width=5000 height=6000 border=\"0\" frameborder=\"0\">";
    $indexFile .= "</iframe></center></body></html>";
    
my $filename = "./report/index.html";
    open FILE, ">", "$filename" or die $!;
    print FILE $indexFile;
    close FILE;
}

# Podprogram:
#   pageAgeAnalysis
# Opis:
#   Ten podprogram przegląda wszystkie adresy URL znalezione
#   na stronie z wynikami wyszukiwania szukając ostatnio modyfikowanego łańcucha
# Zmienne wejściowe:
#   $numberOfElements => liczba plików do przetworzenia
#   $destArr => macierz (odwołanie) do macierzy linków
#   $srcArr => macierz (odwołanie) do macierzy linków
# Zmienne wyjściowe:
#   Brak
# Zwraca:
#   Nic
sub pageAgeAnalysis {
    my ($numberOfElements, $srcArr, $destArr) = @_;

    for(my $i=0; $i<$numberOfElements; $i++) {
        #print "\nprzetwarzanie: $srcArr->[$i]";
        my $ua = new LWP::UserAgent;
        $ua->agent("Mozilla/3.0 (compatible)");
        my $request = new HTTP::Request("GET", "$srcArr->[$i]");
        my $response = $ua->request($request);
        my $code=$response->code;
        $destArr->[$i]= scalar(localtime($response->last_modified)),
        #print "\n$destArr->[$i]";
    }
}

# Podprogram:
#   analyzeWebsiteSize
# Opis:
#   Ten podprogram przegląda strony z wynikami wyszukiwania Google, 
#   aby sprawdzić rozmiar różnych witryn
# Zmienne wejściowe:
#   $numberOfElements => liczba plików do przetworzenia
#   $destArr => macierz (odwołanie) do macierzy linków
#   $srcArr => macierz (odwołanie) do macierzy linków
# Zmienne wyjściowe:
#   Brak
# Zwraca:
#   Zwraca średni rozmiar witryny
sub analyzeWebsiteSize {
    my ($numberOfElements, $srcArr, $destArr) = @_;
    # tworzy linki za pomocą polecenia "site:" 
    my $ua = new LWP::UserAgent;
    my $res;
    $ua->timeout(25);
    $ua->agent("Mozilla/3.0 (compatible)");
    my $total = 0;
    
    for($i=0; $i<$numberOfElements; $i++){

        my $filename = "./serptemp/temp.txt";
        my $url = $srcArr->[$i];
        #Najpierw pobieramy bazowe adresy URL
        
        if($url =~ /^http/) {
            my @tmparr1 = split (/\/\//,$url);
            my @tmparr2 = split (/\//,$tmparr1[1]);
            my $baseurl = "";
            if($#tmparr2>0) {
                $baseurl = $tmparr2[0];
            }else {
                $baseurl = $tmparr1[1];
            }
            $baseurl =~ s/\/$//;
            $url = $baseurl;
        }

        my $tmpurl =
'http://www.google.com/search?hl=en&q=site%3A' . $url . '&btnG=Wyszukaj';
        my $randNum = int(rand(5));
        #print "\nOczekiwanie przez $randNum sekund.\n";
        sleep($randNum);
        $res = $ua->get("$tmpurl",':content_file' => "$filename");
        #Pobieranie treści strony z wynikami wyszukiwania Google
        my $pageCopy = "";
        if (-e "$filename"){
            my $p = HTML::TokeParser->new($filename);
            #Pobieranie treści strony dla tego pliku
            while (my $token = $p->get_tag("body")) {
                $pageCopy = $p->get_text("/body");
            }
        }else {
            print "\nplik nie istnieje";
        }
        #Dzielenie pliku za pomocą tekstu "z około <b>"
        my $separator1 = 'z około ';

        my @tempArr1 = split(/$separator1/, $pageCopy);
        my $separator2 = 'b';
        my @tempArr2 = split(/$separator2/, $tempArr1[1]);
        my $separator3 = ' for';
        my @tempArr3 = split(/$separator3/, $tempArr2[0]);

        my $size = $tempArr3[0];
        
        #Usunięcie przecinku z liczby
        $size =~ s/,//g;
        
        #Zapisywanie dla tego adresu URL
        $destArr->[$i] = $size;
        $total = $total + $size;
    }
    #Obliczanie i zwracanie wartości średniej
    if ($total>0) {
        return ($total/$numberOfElements);
    } else {
        return 0;
    }
}

# Podprogram:
#   optimumWordsPerPage
# Opis:
#   Ten podprogram wykonuje pętlę po wszystkich plikach, aby 
#   w macierzy wynikowej zapisać rozmiary stron.
# Zmienne wejściowe:
#   $numberOfElements => liczba plików do przetworzenia
#   $destArr => macierz (odwołanie) do macierzy linków
#   $prefix => Prefiks pliku wyszukiwarki
# Zmienne wyjściowe:
#   Brak
# Zwraca:
#   Zwraca średnią liczbę słów na stronę
sub optimumWordsPerPage {
    my ($numberOfElements, $destArr, $prefix) = @_;
    my $total = 0;
    for(my $i=0; $i< $numberOfElements; $i++) {
        my $filename = './serptemp/' . $prefix . "$i.txt";
        my $tree = HTML::TreeBuilder->new;
        $tree->parse_file("$filename");
        my $non_html = $tree->as_text();
        $non_html =~ s/^s+/ /g;
        my @tempsizearr = split(/ /,$non_html);
        $destArr->[$i]= $#tempsizearr;
        $total = $total + $#tempsizearr;
    }
    return ($total/$numberOfElements);
}

# Podprogram:
#   averagePageSize
# Opis:
#   Ten podprogram wykonuje pętlę po wszystkich plikach, aby
#   w macierzy wynikowej zapisać rozmiary stron.
# Zmienne wejściowe:
#   $numberOfElements => liczba plików do przetworzenia
#   $destArr => macierz (odwołanie) do macierzy linków
#   $prefix => Prefiks pliku wyszukiwarki
# Zmienne wyjściowe:
#   Brak
# Zwraca:
#   Zwraca średni rozmiar strony
sub averagePageSize {
    my ($numberOfElements, $destArr, $prefix) = @_;
    my $total = 0;
    for(my $i=0; $i< $numberOfElements; $i++) {
        my $filename = './serptemp/' . $prefix . "$i.txt";
        my $filesize = -s "$filename";
        $destArr->[$i] = $filesize;
        $total = $total + $destArr->[$i];
    }
    return ($total/$numberOfElements);
}

# Podprogram:
#   outboundLinkPRAnalysis
# Opis:
#   Ten podprogram przeprowadza analizę składniową wartości PR 
#   z głównych domen wszystkich zewnętrznych linków
# Zmienne wejściowe:
#   $numberOfElements => liczba plików do przetworzenia
#   $srcLinksArr => macierz (odwołanie) do macierzy linków
#   $prefix => Prefiks pliku wyszukiwarki
# Zmienne wyjściowe:
#   Drukuje mapę słów kluczowych
# Zwraca:
#   Nic
sub outboundLinkPRAnalysis {
    my ($numberOfElements, $srcLinksArr, $destArr, $prefix) = @_;
    my $PRURL = 'http://www.seowarrior.net/scripts/pr.php?pr=';
    my $range = 2;
    #Pętla przez wszystkie pliki
    for(my $i=0; $i< $numberOfElements; $i++) {
        my $filename = './serptemp/' . $prefix . "$i.txt";
        my %linkHash = ();
        my $PRs = "";
        #Sprawdzanie, czy plik istnieje
        if (-e "$filename") {
            my $p = HTML::TokeParser->new($filename);
            while (my $token = $p->get_tag("a")) {
                #Pobieranie linka i tekstu kotwiczki
                my $url = $token->[1]{href} || "-";
                my $text = $p->get_trimmed_text("/a");
                #Sprawdzanie, czy link jest zewnętrzny, czy wewnętrzny
                if($url =~ /^http/) {
                    my @tmparr1 = split (/\/\//,$url);
                    my @tmparr2 = split (/\./,$tmparr1[1]);
                    my $tmpbaseURLChild = $tmparr2[0] . $tmparr2[1];

                    my @tmparr3 = split (/\/\//,$srcLinksArr->[$i]);
                    my @tmparr4 = split (/\./,$tmparr3[1]);
                    my $tmpbaseURLParent = $tmparr4[0] . $tmparr4[1];

                    my @tmparr5 = split (/\//,$tmparr1[1]);
                    my $baseurl = "";
                    if($#tmparr5>0) {
                        $baseurl = $tmparr5[0];
                    }else {
                        $baseurl = $tmparr1[1];
                    }
                    $baseurl =~ s/\/$//;

                    if($tmpbaseURLChild ne $tmpbaseURLParent) {
                        #Praca na linku zewnętrznym
                        if( !(exists $linkHash{$baseurl}) ){
                            #Pobieranie wartości PR / losowy czas uśpienia
                            my $randNum = int(rand($range));
                            #print "\nOczekiwanie przez $randNum sekund.\n";
            
                            sleep($randNum);
                            my $tmpurl = $PRURL . $baseurl;
                            my $PR = get $tmpurl;
                            #print "$PR:";
                            $PR =~ s/\n//g;
                            $PRs = $PRs . $PR . "|";
                            $linkHash{$baseurl} = 1;
                        }
                    }
                }
            }
        }
        else {
            #print "\nPlik: $filename nie został znaleziony!";
        }
        $destArr->[$i] = $PRs;
        #print "\n$PRs";
    }
}

# Podprogram:
#   outboundLinkKeywordAnalysis
# Opis:
#   Ten podprogram analizuje słowa kluczowe w linkach zewnętrznych
# Zmienne wejściowe:
#   $numberOfElements => liczba plików do przetworzenia
#   $srcLinksArr => macierz (odwołanie) do macierzy linków
#   $prefix => Prefiks pliku wyszukiwarki
#   $keyword => słowo kluczowe
# Zmienne wyjściowe:
#   Drukuje mapę słów kluczowych
# Zwraca:
#   Nic
sub outboundLinkKeywordAnalysis {
    my ($numberOfElements, $srcLinksArr, $destArr, $prefix, $keyword) = @_;
    my @keywordFragments = split(/ /,$keyword);
    #Pętla przez każdy z plików
    for(my $i=0; $i< $numberOfElements; $i++) {
        my $filename = './serptemp/' . $prefix . "$i.txt";
        my $keywordMatchPercent = "";
        my $foundCount = 0;
        my $total = 0;
        #Sprawdzanie, czy plik istnieje
        if (-e "$filename") {
            my $p = HTML::TokeParser->new($filename);
            while (my $token = $p->get_tag("a")) {
                #Pobieranie linka i tekstu kotwiczki
                my $url = $token->[1]{href} || "-";
                my $text = $p->get_trimmed_text("/a");
                $text =~ s/"//;
                $text =~ s/'//;

                #Sprawdzenie, czy link jest wewnętrzny, czy zewnętrzny
                if($url =~ /^http/) {
                    @tmparr1 = split (/\/\//,$url);
                    @tmparr2 = split (/\./,$tmparr1[1]);
                    $tmpbaseURLChild = $tmparr2[0] . $tmparr2[1];
    
                    @tmparr3 = split (/\/\//,$srcLinksArr->[$i]);
                    @tmparr4 = split (/\./,$tmparr3[1]);
                    $tmpbaseURLParent = $tmparr4[0] . $tmparr4[1];
                    if($tmpbaseURLChild ne $tmpbaseURLParent) {
                        #Link zewnętrzny...przetwarzanie
                        if($#keywordFragments >0){
                            #Obsługa wielu słów kluczowych
                            for(my $j=0; $j <= $#keywordFragments; $j++){
                                #Sprawdzenie dopasowania
                                if($text =~ /$keywordFragments[$j]/i) {
                                #Dopasowanie znalezione
                                $foundCount++;
                                last;
                            }
                        }
                    } else {
        
                            if($text =~ /$keyword/i) {
                                #Dopasowanie znalezione
                                $foundCount++;
                            }
                        }
                    }
                }
                $total++;
            }
        }
        else {
        #print "\nPlik: $filename nie został znaleziony!";
        }
        if($total>0) {
            $destArr->[$i] = ( $foundCount);
        } else {
            $destArr->[$i] = 0;
        }
        #print "\n$destArr->[$i]";
    }
}

# Podprogram:
#   printKeywordProminenceMap
# Opis:
#   Ten podprogram drukuje mapę każdego adresu URL
# Zmienne wejściowe:
#   $numberOfElements => liczba plików do przetworzenia
#   $srcArr => macierz (odwołanie) do macierzy linków
# Zmienne wyjściowe:
#   Drukuje mapę słów kluczowych
# Zwraca:
#   Nic
sub printKeywordProminenceMap {
    my ($srcArr, $numberOfElements) = @_;
    for(my $i; $i<$numberOfElements; $i++){
        print "$srcArr->[$index]\n";
    }
}

# Podprogram:
#   printIndividualKeywordProminenceMap
# Opis:
#   Ten podprogram drukuje mapę każdego adresu URL
# Zmienne wejściowe:
#   $numberOfElements => liczba plików do przetworzenia
#   $srcArr => macierz (odwołanie) do macierzy wyników
# Zmienne wyjściowe:
#   Drukuje mapę słów kluczowych
# Zwraca:
#   Nic
sub printIndividualKeywordProminenceMap {
    my ($index, $srcArr, $prefix) = @_;
    my $filename = "./report/maps/$prefix".$index.".html";
    open FILE, ">", "$filename" or die $!;
    print FILE "<html><head><title>\n";
    print FILE "Mapa wag słów kluczowych\n";
    print FILE "</title></head>\n";
    print FILE "<body><table width=400 cellpading=2 cellspacing=0><tr><td width=400>";
    print FILE $srcArr->[$index];
    print FILE "</td></tr></table></body></html>";
    close FILE;
}

# Podprogram:
#   analyzeKeywordPositions
# Opis:
#   Ten podprogram analizuje relatywne pozycje słów kluczowych w treści witryny
# Zmienne wejściowe:
#   $numberOfElements => liczba plików do przetworzenia
#   $destArr => macierz (odwołanie) do macierzy wyników
#   $keyword => słowo kluczowe do analizy
#   $prefix => prefiks pliku
# Zmienne wyjściowe:
#   Brak
# Zwraca:
#   Nic, cała praca wykonywana na przekazywanych macierzach

sub analyzeKeywordPositions {
    my ($numberOfElements, $destArr, $destArr2, $prefix, $keyword) = @_;
    my @keywordFragments = split(/ /,$keyword);
    #Pętla przez wszystkie pliki do pobrania
    for(my $i=0; $i< $numberOfElements; $i++) {
        my $pageCopy = "";
        my $tmpMap = ":";
        my $filename = './serptemp/' . $prefix . "$i.txt";
        #Sprawdzanie, czy plik istnieje
        if (-e "$filename"){
            my $p = HTML::TokeParser->new($filename);
            #Pobranie treści strony dla tego pliku
            while (my $token = $p->get_tag("body")) {
                $pageCopy = $p->get_trimmed_text("/body");
                $pageCopy = cleanText($pageCopy);
            }
            $pageCopy =~ s/s+/ /g;
            my @tempArr = split(/ /, $pageCopy);
            $totalWords = $#tempArr;
            #print "\nSuma wyrazów na tej stronie: $totalWords";
            #Pętla przez wszystkie wyrazy
            for(my $j=0; $j < $totalWords; $j++){
                my $flag = "N";
                if($#keywordFragments >0){
                    #Obsługa wielu słów kluczowych
                    for(my $k=0; $k <= $#keywordFragments; $k++){
                    #Sprawdzanie dopasowania
                    if($tempArr[$j] =~ /$keywordFragments[$k]/i) {
                        #Aktualizacja zmiennej docelowej indeksem macierzy słów kluczowych
                        $destArr->[$i] .= "$k ";
                        #Aktualizacja zmiennej docelowej pozycją względną
                        $destArr2->[$i] = $destArr2->[$i] ."$j" . "|";
                        $flag = "T";
                        last;
                    } else {
                        if( ($k == $#keywordFragments) && ($flag ne "T") ) {
                                $destArr->[$i] .= "* ";
                            }
                        }
                    }
                } else {
                    #Obsługa pojedynczego słowa kluczowego
                    $tempArr[$j] =~ s/"//;
                    $tempArr[$j] =~ s/'//;

                    if($tempArr[$j] =~ /$keyword/i){
                        $destArr->[$i] .= "0 ";
                        $destArr2->[$i] = $destArr2->[$i] . "$j" . "|";
                        $flag = "T";
                    } else {
                        $destArr->[$i] .= "* ";
                    }
                }
                if($flag ne "N") {
                    $destArr->[$i] .= "* ";
                }
            }
            #print "\n\n$destArr->[$i]";
        } else {
            print "\nPlik nie istnieje";
        }
    }
}

# Podprogram:
#   checkHeaderTags
# Opis:
#   Ten podprogram sprawdza, czy używane są znaczniki nagłówków, a jeśli są, to czy 
#   w nagłówkach używane są słowa kluczowe.
# Zmienne wejściowe:
#   $numberOfElements => liczba plików do przetworzenia
#   $destArr1 => macierz (odwołanie) do macierzy wyników
#   $destArr2 => macierz (odwołanie) do macierzy wyników
#   $keyword => słowo kluczowe do analizy
#   $prefix => prefiks pliku
# Zmienne wyjściowe:
#   Brak
# Zwraca:
#   Nic, cała praca wykonywana na przekazywanych macierzach
sub checkHeaderTags {
    my ($numberOfElements, $destArr1, $destArr2, $prefix, $keyword) = @_;
    my @keywordFragments = split(/ /,$keyword);
    
    for(my $i=0; $i < $numberOfElements; $i++) {
        my $filename = './serptemp/' . $prefix . "$i.txt";
        if (-e "$filename"){
            my $p = HTML::TokeParser->new($filename);
            my $h1Text = "";
            my $h2Text = "";
            my $h3Text = "";
            my $h4Text = "";
            my $h5Text = "";
            my $h6Text = "";
            my $separator = '|s|e|p|a|r|a|t|o|r';
            while(my $token = $p->get_token) {
                if($token->[0] eq 'S' and $token->[1] eq 'h1') {
                    $h1Text = $h1Text . $separator . $p->get_text("/h1");
                }
                if($token->[0] eq 'S' and $token->[1] eq 'h2') {
                    $h2Text = $h2Text . $separatpr . $p->get_text("/h2");
                }
                if($token->[0] eq 'S' and $token->[1] eq 'h3') {
                    $h3Text = $h3Text . $separator . $p->get_text("/h3");
                }
                if($token->[0] eq 'S' and $token->[1] eq 'h4') {
                    $h4Text = $h4Text . $separator . $p->get_text("/h4");
                }
                if($token->[0] eq 'S' and $token->[1] eq 'h5') {
                    $h5Text = $h5Text . $separator . $p->get_text("/h5");
                }
                if($token->[0] eq 'S' and $token->[1] eq 'h6') {
                    $h6Text = $h6Text . $separator . $p->get_text("/h6");
                }
            }
            $h1Text = cleanText($h1Text);
            $h2Text = cleanText($h2Text);
            $h3Text = cleanText($h3Text);
            $h4Text = cleanText($h4Text);
            $h5Text = cleanText($h5Text);
            $h6Text = cleanText($h6Text);

            my @h1Arr = split($separator, $h1Text);
            my @h2Arr = split($separator, $h2Text);
            my @h3Arr = split($separator, $h3Text);
            my @h4Arr = split($separator, $h4Text);
            my @h5Arr = split($separator, $h5Text);
            my @h6Arr = split($separator, $h6Text);
        
            my $h1Cnt = ($#h1Arr == -1) ? 0 : $#h1Arr;
            my $h2Cnt = ($#h2Arr == -1) ? 0 : $#h2Arr;
            my $h3Cnt = ($#h3Arr == -1) ? 0 : $#h3Arr;
            my $h4Cnt = ($#h4Arr == -1) ? 0 : $#h4Arr;
            my $h5Cnt = ($#h5Arr == -1) ? 0 : $#h5Arr;
            my $h6Cnt = ($#h6Arr == -1) ? 0 : $#h6Arr;

            my $h1Flag = "N";
            my $h2Flag = "N";
            my $h3Flag = "N";
            my $h4Flag = "N";
            my $h5Flag = "N";
            my $h6Flag = "N";
            
            $destArr1->[$i] =
"".$h1Cnt."|".$h2Cnt."|".$h3Cnt."|".$h4Cnt."|".$h5Cnt."|".$h6Cnt;
            if($#keywordFragments > 0) {
                #Obsługa wielu słów kluczowych
                for(my $j=0; $j<=$#keywordFragments; $j++) {

                    if( $keywordFragments[$j] =~ /$h1Text/i ) {
                        $h1Flag = "T";
                    }
                    if( $keywordFragments[$j] =~ /$h2Text/i ) {
                        $h2Flag = "T";
                    }
                    if( $keywordFragments[$j] =~ /$h3Text/i ) {
                        $h3Flag = "T";
                    }
                    if( $keywordFragments[$j] =~ /$h4Text/i ) {
                        $h4Flag = "T";
                    }
                    if( $keywordFragments[$j] =~ /$h5Text/i ) {
                        $h5Flag = "T";
                    }
                    if( $keywordFragments[$j] =~ /$h6Text/i ) {
                        $h6Flag = "T";
                    }
                }
            } else {
                #Obsługa słowa kluczowego
                if($keyword =~ /$h1Text/i) {
                    $h1Flag = "T";
                }
                if($keyword =~ /$h2Text/i) {
                    $h2Flag = "T";
                }
                if($keyword =~ /$h3Text/i) {
                    $h3Flag = "T";
                }
                if($keyword =~ /$h4Text/i) {
                    $h4Flag = "T";
                }
                if($keyword =~ /$h5Text/i) {
                    $h5Flag = "T";
                }
                if($keyword =~ /$h6Text/i) {
                    $h6Flag = "Y";
                }
            }
            $destArr2->[$i] =
"".$h1Flag."|".$h2Flag."|".$h3Flag."|".$h4Flag."|".$h5Flag."|".$h6Flag;
        } else {
            # Brak pliku => wstaw wartości domyślne;
            $destArr1->[$i] = "0|0|0|0|0|0|";
            $destArr2->[$i] = "N|N|N|N|N|N|";
        }
        #print "\n".$destArr1->[$i]."\n".$destArr2->[$i];
    }
}

# Podprogram:
#   checkExactDescriptionMeta
# Opis:
#   Ten podprogram sprawdza, czy występują dokładne dopasowania w opisie słów 
#   kluczowych.
# Zmienne wejściowe:
#   $numberOfElements => liczba plików do przetworzenia
#   $destArr => macierz (odwołanie) do macierzy wyników
#   $keyword => słowo kluczowe do analizy
#   $prefix => prefiks pliku
# Zmienne wyjściowe:
#   Brak
# Zwraca:
#   Nic, cała praca wykonywana na przekazywanych macierzach
sub checkExactDescriptionMeta {
    my ($numberOfElements, $destArr, $keyword, $prefix) = @_;
    for(my $i=0; $i<$numberOfElements; $i++){
        $filename = './serptemp/' . $prefix . "$i.txt";
        if (-e "$filename"){
            my $p = HTML::TokeParser->new($filename);
            while (my $token=$p->get_tag("meta")) {
                if ($token->[1]{name}=~/description/i) {
                    my $metaDescription = $token->[1]{content};
                    $metaDescription =~ s/"//;
                    $metaDescription =~ s/'//;

                    if($metaDescription =~ /$keyword/i) {
                        $destArr->[$i] = "T";
                    } else {
                        $destArr->[$i] = "N";
                    }
                }
            }
        }
        if ( !(exists $destArr->[$i])) {
            $destArr->[$i] = "N";
        }
    }
}

# Podprogram:
#   checkExactDescriptionMeta
# Opis:
#   Ten podprogram sprawdza, czy występują dokładne dopasowania w opisie słów 
#   kluczowych.
# Zmienne wejściowe:
#   $numberOfElements => liczba plików do przetworzenia
#   $destArr => macierz (odwołanie) do macierzy wyników
#   $keyword => słowo kluczowe do analizy
#   $prefix => prefiks pliku
# Zmienne wyjściowe:
#   Brak
# Zwraca:
#   Nic, cała praca wykonywana na przekazywanych macierzach
sub checkPartialDescriptionMeta {
    my ($numberOfElements, $destArr, $keyword, $prefix) = @_;
    my @keywordFragments = split(/ /, $keyword);
    
    for(my $i=0; $i<$numberOfElements; $i++){
        $filename = './serptemp/' . $prefix . "$i.txt";
        if (-e "$filename"){
            my $p = HTML::TokeParser->new($filename);
            while (my $token=$p->get_tag("meta")) {
                if ($token->[1]{name}=~/description/i) {
                    my $metaDescription = $token->[1]{content};

                    if($#keywordFragments >0) {
                        for (my $j=0; $j<=$#keywordFragments; $j++){
                            if($metaDescription =~ /$keywordFragments[$j]/i) {
                                $destArr->[$i] = "T";
                                last;
                            } else {
                                $destArr->[$i] = "N";
                            }
                        }
                    } else {
                        if($metaDescription =~ /$keyword/i) {
                            $destArr->[$i] = "T";
                            last;
                        } else {
                            $destArr->[$i] = "N";
                        }
                    }
                }
            }
        }
        if ( !(exists $destArr->[$i])) {
            $destArr->[$i] = "N";
        }
    }
}

# Podprogram:
#   keywordDensity
# Opis:
#   Ten podprogram oblicza gęstość występowania danego słowa kluczowego.
# Zmienne wejściowe:
#   $numberOfElements => liczba plików do przetworzenia
#   $destArr => macierz (odwołanie) do macierzy wyników
#   $keyword => słowo kluczowe do analizy
#   $prefix => prefiks pliku
# Zmienne wyjściowe:
#   Brak
# Zwraca:
#   Nic, cała praca wykonywana na przekazywanych macierzach

sub keywordDensity {
    my ($numberOfElements, $keyword, $destArr, $prefix) = @_;
    my $total = 0;
    #Pętla przez wszystkie pliki
    
    for(my $i=0; $i<$numberOfElements; $i++) {
        my $pageCopy = "";
        my $filename = './serptemp/' . $prefix . "$i.txt";
        if (-e "$filename"){
            my $p = HTML::TokeParser->new($filename);
            while (my $token = $p->get_tag("body")) {
                $pageCopy = $p->get_trimmed_text("/body");
            }
        } else {
            print "\nW czasie obliczania gęstości występowania słowa kluczowego nie odnaleziono pliku.";
        }    
        #Porównanie treści i macierzy (funkcja sep)
        $pageCopy =~ s/"//g;
        $pageCopy =~ s/'//g;

        $total = $total + calculateKD($i, $pageCopy, $destArr, $keyword);
    }
    return ($total/$numberOfElements);
}

# Podprogram:
#   calcualteKD
# Opis:
#   Pomocniczy podprogram do obliczania gęstości występowania słów kluczowych
# Zmienne wejściowe:
#   $numberOfElements => liczba plików do przetworzenia
#   $destArr => macierz (odwołanie) do macierzy wyników
#   $keyword => słowo kluczowe do analizy
#   $prefix => prefiks pliku
# Zmienne wyjściowe:
#   Brak
# Zwraca:
#   Nic, cała praca wykonywana na przekazywanych macierzach
sub calculateKD {
    my ($index, $pageCopy, $destArr, $keyword) = @_;

    my @keywordFragments = split (/ /,$keyword);
    if ($#keywordFragments>0) {
        for (my $i=0; $i<= $#keywordFragments; $i++){
            my @tempArr = split(/$keywordFragments[$i]/,$pageCopy);
            my @tempArr2 = split(/ /, $pageCopy);
            if( ($#tempArr == -1) || ($#tempArr2 == -1)) {
                $destArr->[$index] = 0;
            }else {
                $destArr->[$index] = $destArr->[$index] + ($#tempArr/$#tempArr2)*100;
            }
        }
        return $destArr->[$index];

    } else {
        my @tempArr = split(/$keyword/,$pageCopy);
        my @tempArr2 = split(/ /, $pageCopy);
        $destArr->[$index] = ($#tempArr/$#tempArr2)*100;
        return $destArr->[$index];
    }
}

# Podprogram:
#   keywordDomainExactMatch
# Opis:
#   Ten podprogram analizuje słowa kluczowe w nazwach domen. Sprawdza, 
#   czy słowo kluczowe jest częścią nazwy domeny.
#   Potencjalne udoskonalenie wiąże się z wyszukiwaniem odmian słowa kluczowego.
# Zmienne wejściowe:
#   $numberOfElements => liczba plików do przetworzenia
#   $linksArr => macierz (odwołanie) do macierzy linków
#   $destArr => macierz (odwołanie) do macierzy wyników
#   $keyword => prefiks pliku dla trzech wyszukiwarek
# Zmienne wyjściowe:
#   Brak
# Zwraca:
#   Nic, cała praca wykonywana na przekazywanych macierzach
sub keywordDomainExactMatch {
    my ($keyword, $linksArr, $numberOfElements, $destArr) = @_;
    my $matchCnt=0;
    my @keywordFragments = split(/ /, $keyword);
    my $numberOfKeywordFragments = $#keywordFragments;
    my $total = 0;
    for (my $i=0; $i<=$numberOfElements; $i++) {
        $matchCnt=0;
        my $tmp = $linksArr->[$i];
        $tmp =~ s/^http:\/\///g;
        $tmp =~ s/^https:\/\///g;
        my @linkFragments = split(/\//,$tmp);
        my $link = $linkFragments[0];

        if($numberOfKeywordFragments>0) {
            for(my $j=0; $j<=$numberOfKeywordFragments; $j++) {
            if ($link =~ /$keywordFragments[$j]/i) {
                $matchCnt++;
            }
        }
    } else {
        if($link =~ /$keyword/i) {
            $matchCnt++;
        }
    }
    if($matchCnt>0) {
        if($numberOfKeywordFragments>0) {
            if($matchCnt == ($numberOfKeywordFragments+1)) {
                $destArr->[$i] = "T";
                } else {
                    $destArr->[$i] = "N";
                }
            } else {
                # Pojedyncze słowo kluczowe
                $destArr->[$i] = "T";
            }
        } else {
            $destArr->[$i] = "N";
        }
        if($destArr->[$i] eq "T") {
            $total++;
        }
    }
    return ( ($total/$numberOfElements)* 100);
}

# Podprogram:
#   keywordDomainPartialMatch
# Opis:
#   Ten podprogram analizuje słowa kluczowe w nazwach domen. Szuka 
#   częściowych dopasowań między słowami kluczowymi, a nazwą domeny.
# Zmienne wejściowe:
#   $numberOfElements => liczba plików do przetworzenia
#   $linksArr => macierz (odwołanie) do macierzy linków
#   $destArr => macierz (odwołanie) do macierzy wyników
#   $keyword => słowo kluczowe do analizy
# Zmienne wyjściowe:
#   Brak
# Zwraca:
#   Nic, cała praca wykonywana na przekazywanych macierzach
sub keywordDomainPartialMatch {
    my ($keyword, $linksArr, $numberOfElements, $destArr) = @_;
    my $totalNumber = $numberOfElements;
    my $matchCnt=0;
    my @keywordFragments = split (/ /, $keyword);
    my $numOfKeywordFragments = $#keywordFragments;

    my $keywordHyphen = $keyword;
    my $keywordUnderscore = $keyword;
    my $keywordNoSpace = $keyword;
    $keywordHyphen =~ s/ /-/g;
    $keywordNoSpace =~ s/ //g;

    #Pętla przez wszystkie linki
    if($numOfKeywordFragments >0) {
        for(my $i=0; $i<$numberOfElements; $i++) {
            my $tmp = $linksArr->[$i];
            $tmp =~ s/^http:\/\///gi;
            $tmp =~ s/^https:\/\///gi;
            my @linkFragments = split(/\//,$tmp);
            my $link = $linkFragments[0];
            for(my $j=0; $j<=$numOfKeywordFragments; $j++) {
                if($link =~ /$keywordFragments[$j]/i) {
                    $destArr->[$i] = "T";
                    $j = $numOfKeywordFragments;
                    $matchCnt++;
                } else {
                    $destArr->[$i] = "N";
                }
            }
        }
    } else {

        for(my $i=0; $i<$numberOfElements; $i++) {
            my $tmp = $linksArr->[$i];
            $tmp =~ s/^http:\/\///g;
            $tmp =~ s/^https:\/\///g;
            my @linkFragments = split(/\//,$tmp);
            my $link = $linkFragments[0];

            if( ($link =~ /$keyword/) ||
                ($link =~ /$keywordHyphen/) ||
                ($link =~ /$keywordNoSpace/) ) {
                $destArr->[$i] = "T";
                $matchCnt++;
            } else {
                $destArr->[$i] = "N";
            }
        }

    }
    return ( ($matchCnt/$totalNumber)* 100);
}

# Podprogram:
#   compareTitlePageCopy
# Opis:
#   Ten program porównuje tytuł strony z jej treścią
# Zmienne wejściowe:
#   $numberOfElements => liczba plików do przetworzenia
#   $titlesArr => macierz (odwołanie) do macierzy tytułów
#   $destArr => macierz (odwołanie) do macierzy wyników
#   $prefix => prefiks pliku dla trzech wyszukiwarek
# Zmienne wyjściowe:
#   Brak
# Zwraca:
#   Nic, cała praca wykonywana na przekazywanych macierzach
sub compareTitlePageCopy {
    my ($numberOfElements, $titlesArr, $destArr, $prefix) = @_;
    #Pętla przez wszystkie pliki
    for(my $i=0; $i<=$numberOfElements; $i++) {
        #split up current title into token words
        my $title = $titlesArr->[$i];

        $title = cleanText($title);
        $title =~ s/\'//g;
        $title =~ s/\"//g;
        
        my @titleFragments = split(/ /,$title);
        #Pobieranie treści dla każdego pliku
        my $pageCopy = "";
        my $filename = './serptemp/' . $prefix . "$i.txt";
        if (-e "$filename"){
            my $p = HTML::TokeParser->new($filename);
            while (my $token = $p->get_tag("body")) {
                $pageCopy = $p->get_trimmed_text("/body");
                $pageCopy =~ s/\'//g;
                $pageCopy =~ s/\"//g;

                last;
            }
        }
        #Porównanie treści i macierzy (funkcja sep)
        compareTitlePageCopyHelper($i, $#titleFragments,
\@titleFragments, $pageCopy, $destArr);
    }
}

# Podprogram:
#   compareTitlePageCopyHelper
# Opis:
#   Ten podprogram używany jest przez podprogram compareTitlePageCopy 
#   do porównywania tytułu strony i jej treści
# Zmienne wejściowe:
#   $index => reprezentuje indeks numeryczny macierzy
#   $numberOfElements => liczba plików do przetworzenia
#   $titleFragments => macierz (odwołanie) do macierzy fragmentów tytułów
#   $pageCopy => treść strony
#   $pageCopyTitleArr => macierz (odwołanie) do macierzy wyników
# Zmienne wyjściowe:
#   Brak
# Zwraca:
#   Nic, cała praca wykonywana na przekazywanych macierzach
sub compareTitlePageCopyHelper {
    my ($index, $numberOfElements, $titleFragments, $pageCopy, $pageCopyTitleArr) = @_;
    my $foundCnt = 0;
    my $totalTitleFragments = $numberOfElements;

    for(my $j=0; $j<=$numberOfElements; $j++) {
        my $tmpfragment = $titleFragments->[$j];
        
        if( $pageCopy =~ /$tmpfragment/i ){
            $foundCnt++;
        }
    }
    if($foundCnt == 0){
        $pageCopyTitleArr->[$index] = 0;
    } else {
        $pageCopyTitleArr->[$index] = ( ($foundCnt/($totalTitleFragments+1)) * 100);
    }
}

# Podprogram:
#   compareArrays
# Opis:
#   Ten podprogram porównuje ze sobą elementy dwóch macierzy, aby sprawdzić
#   czy się w sobie nawzajem znajdują.
# Zmienne wejściowe:
#   $numberOfElements => liczba plików do przetworzenia
#   $realArr => macierz (odwołanie) do pierwszej macierzy źródłowej
#   $foundArr => macierz (odwołanie) do drugiej macierzy źródłowej
#   $destArr => macierz (odwołanie) do macierzy wyników
# Zmienne wyjściowe:
#   Brak
# Zwraca:
#   Nic, cała praca wykonywana na przekazywanych macierzach
sub compareArrays {
    my ($numOfElements, $realArr, $foundArr, $destArr) = @_;
    my $found = 0;
    my $percentMatch = 0;

    for(my $i=0; $i<$numOfElements; $i++){
        $tmpVar = $foundArr->[$i];
        $tmpVar =~ s/\(/\\\(/g;
        $tmpVar =~ s/\)/\\\)/g;
        $tmpVar =~ s/\-/\\\-/g;
        $tmpVar =~ s/\+/\\\+/g;
        $tmpVar =~ s/\$/\\\$/g;
        $tmpVar =~ s/\^/\\\^/g;
        $tmpVar =~ s/\[/\\\[/g;
        $tmpVar =~ s/\]/\\\]/g;
        $tmpVar =~ s/\}/\\\}/g;
        $tmpVar =~ s/\{/\\\{/g;

        if ($realArr->[$i] =~ /$tmpVar/i) {
            $destArr[$i] = "T";
            $found++;
        }else {
            $destArr[$i] = "N";
        }
    }
    return ( ($found/$numOfElements)*100);
}

# Podprogram:
#   getRealTitles
# Opis:
#   Ten podprogram pobiera rzeczywiste tytuły
# Zmienne wejściowe:
#   $numberOfElements => liczba plików do przetworzenia
#   $titlesArr => macierz (odwołanie) do macierzy, która będzie zawierać
#   rzeczywiste tytuły
#   $prefix => prefik pliku, który ma być użyty
# Zmienne wyjściowe:
#   Brak
# Zwraca:
#   Podprogram operuje na macierzy zdefiniowanej już wcześniej poza funkcją.
#   Podprogram nic nie zwraca.
sub getRealTitles {
    my ($numberOfElements, $titlesArr, $prefix) = @_;
    for(my $i=0; $i<$numberOfElements; $i++){
        $filename = './serptemp/' . $prefix . "$i.txt";
        if (-e "$filename"){
            my $p = HTML::TokeParser->new($filename);
            while (my $token = $p->get_token) {
                if ($token->[0] eq "S" and lc $token->[1] eq 'title') {
                    my $title = $p->get_text() || "not found";
                    $title =~ s/^\s+//;
                    $title =~ s/\s+$//;
                    $titlesArr->[$i]=$title;
                    last;
                }
            }
        }else {
            $titlesArr->[$i]="not found";
        }
    }
}

# Podprogram:
#   getKeywordsTitleMatch
# Opis:
#   Ten podprogram porównuje dane słowo kluczowe z wpisami macierzy
#   budując jednocześnie trzecią macierz z wynikami tego porównania.
# Zmienne wejściowe:
#   $keyword => słowo lub fraza kluczowa, na której przeprowadzona będzie analiza
#   $sourceArr => macierz (odwołanie), która ma zostać użyta do porównania
#   $numOfElements => rozmiar macierzy odwołania
#   $destArr => macierz (odwołanie)zawierająca wyniki porównania
# Zmienne wyjściowe:
#   Brak
# Zwraca:
#   Podprogram operuje na macierzy zdefiniowanej już wcześniej poza funkcją.
#   Podprogram nic nie zwraca.
sub getKeywordsTitleMatch {
    my ($keyword, $sourceArr, $numOfElements, $destArr) = @_;
    $keyword = cleanText($keyword);
    $keyword =~ s/\'//g;
    $keyword =~ s/\"//g;
    @keywordFragments = split(/ /, $keyword);
    my $numberOfKeywordTokens = $#keywordFragments;
    
    for(my $i=0; $i<= $numOfElements; $i++) {
    my $tmp = $sourceArr->[$i];
    $tmp = cleanText($tmp);
    $tmp =~ s/'//;
    $tmp =~ s/"//;
    my $foundCnt = 0;
    if ($numberOfKeywordTokens >0) {
        for(my $j=0; $j<=$#keywordFragments; $j++){
            if ($tmp =~ /$keywordFragments[$j]/i) {
                $foundCnt++;
                
                last;
            }
        }
        } else {
            if ($tmp =~ /$keyword/i) {
                $foundCnt++;
        
            }
        }
        if($foundCnt > 0) {
            $destArr->[$i] = "T";
        } else {
            $destArr->[$i] = "N";
        }
    }
}

# Podprogram:
#   initializeKeyVariables
# Opis:
#   Głównym celem jest zdefiniowanie macierzy linków i tytułów, które będą 
#   używane w różnych częściach skryptu.
# Zmienne wejściowe:
#   $keyword => słowo lub fraza kluczowa, na której przeprowadzona będzie analiza
#   $googleLinksArr => macierz (odwołanie)z linkami Google
#   $googleTitlesArr => macierz (odwołanie)z tytułami Google
#   $yahooLinksArr => macierz (odwołanie)z linkami Yahoo!
#   $yahooTitlesArr => macierz (odwołanie)z tytułami Yahoo!
#   $bingLinksArr => macierz (odwołanie)z linkami Bing
#   $bingTitlesArr => macierz (odwołanie)z tytułami Bing
# Zmienne wyjściowe:
#   Brak
# Zwraca:
#   Podprogram operuje na przekazywanych macierzach zdefiniowanych już wcześniej poza funkcją.
#   Podprogram nic nie zwraca.
sub initializeKeyVariables {
    my ($keyword, $googleLinksArr,$googleTitlesArr,
        $yahooLinksArr, $yahooTitlesArr, $bingLinksArr,
        $bingTitlesArr) = @_;
    #Tworzenie agentów
    my $uaGoogle = new LWP::UserAgent;
    my $uaYahoo = new LWP::UserAgent;
    my $uaBing = new LWP::UserAgent;

    #Ustawienie maksymalnego czasu wykonania polecenia na 25 sekund
    $uaGoogle->timeout(25);
    $uaYahoo->timeout(25);
    $uaBing->timeout(25);

    #Konfiguracja agenta
    my $useragent = "Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.0)";
    $uaGoogle->agent("$useragent");
    $uaYahoo->agent("$useragent");
    $uaBing->agent("$useragent");

    #Konfigurowanie i pobieranie 100 wyników wyszukiwania z każdej wyszukiwarki
    my $gurl=
"http://www.google.com/search?num=$numres&hl=en&safe=off&q=$keyword&sa=N";
    my $yurl=
"http://search.yahoo.com/search?p=$keyword&ei=UTF-8&fr=sfp&n=$numres&b=1";
    my $lurl=
"http://search.bing.com/results.aspx?q=$keyword&first=1&count=$numres&";
    
    my $reqGoogle = new HTTP::Request GET => "$gurl";
    my $reqYahoo = new HTTP::Request GET => "$yurl";
    my $reqBing = new HTTP::Request GET => "$lurl";
    
    my $resGoogle = $uaGoogle->request($reqGoogle);
    my $resYahoo = $uaYahoo->request($reqYahoo);
    my $resBing = $uaBing->request($reqBing);

    #Przypisanie stron z wynikami wyszukiwania do specjalnych zmiennych
    my $ghtml = $resGoogle->content;
    my $yhtml = $resYahoo->content;
    my $lhtml = $resBing->content;

    #Pobranie linków dla każdej strony z wynikami wyszukiwania
    my $streamGoogle = HTML::TokeParser->new(\$ghtml);
    my $streamYahoo = HTML::TokeParser->new(\$yhtml);
    my $streamBing = HTML::TokeParser->new(\$lhtml);

    # Przetwarzanie linków Google
    my $cnt=0;
    my $threeDots = '...';
    while (my $token = $streamGoogle->get_token) {
        if ($token->[0] eq 'S' && $token->[1] eq 'a') {
            if( ($token->[2]{'href'} !~ /cache/i) &&
            !($token->[2]{'href'} !~ /^http/i) &&
             ($token->[2]{'href'} !~ /^https/i) &&
             ($token->[2]{'href'} !~ /google/i) &&
             ($token->[2]{'href'} !~ /aclk/i) &&
             ($token->[2]{'href'} !~ /youtube/i)&&
             ($token->[2]{'href'} !~ /wikipedia/i) ) {
             $googleLinksArr->[$cnt] = $token->[2]{'href'};
             $googleTitlesArr->[$cnt] = $streamGoogle->get_trimmed_text("/a");
             $googleTitlesArr->[$cnt] =~ s/$threeDots$//;
             $cnt++;
            }
        }
    }
    # Przetwarzanie linków Yahoo
    my $cnt2=0;
    while (my $token = $streamYahoo->get_token) {
        if ($token->[0] eq 'S' && $token->[1] eq 'a') {
            @tmpurl= split (/\*\*/, $token->[2]{'href'});
            $tmpurl[1] =~ s/%3f/?/g;
            $tmpurl[1] =~ s/%26/&/g;
            
            if( ($tmpurl[1] !~ /cache/i) &&
                 ($tmpurl[1] !~ /^https/i) &&
                 ($tmpurl[1] !~ /yahoo/i) &&
                 ($tmpurl[1] !~ /wikipedia/i) &&
                 ($tmpurl[1] !~ /overture/i) ){
                $tmpurl[1] =~ s/%3a/:/g;
                $tmpurl[1] =~ s/^s+//g;
                if( $tmpurl[1] ne "") {
                    $yahooLinksArr->[$cnt2] = $tmpurl[1];
                $yahooTitlesArr->[$cnt2] = $streamYahoo->get_trimmed_text("/a");
                    $yahooTitlesArr->[$cnt2] =~ s/$threeDots$//;
                    $cnt2++;
                }
            }
        }
    }
    # Przetwarzanie linków Bing
    my $cnt3=0;
    while (my $token = $streamBing->get_token) {
        if ($token->[0] eq 'S' && $token->[1] eq 'a') {
            if( !($token->[2]{'href'} !~ /^http/i) &&
                 ($token->[2]{'href'} !~ /^https/i) &&
                 ($token->[2]{'href'} !~ /cache/i) &&
                 ($token->[2]{'href'} !~ /wikipedia/i) &&
                 ($token->[2]{'href'} !~ /msn/i) &&
                 ($token->[2]{'href'} !~ /hotmail/i) &&
                 ($token->[2]{'href'} !~ /microsoft/i) &&
                 ($token->[2]{'href'} !~ /bing\.com/i) ) {
                  $token->[2]{'href'} =~ s/^s+//g;
                  if($token->[2]{'href'} ne "") {
                    $bingLinksArr->[$cnt3] = $token->[2]{'href'};
                $bingTitlesArr->[$cnt3] = $streamBing->get_trimmed_text("/a");
                    $bingTitlesArr->[$cnt3] =~ s/$threeDots$//;
                    $cnt3++;
                }
            }
        }
    }
}

# Podprogram:
#   getSERPResults
# Opis:
#   Ten podprogram pobiera wszystkie pliki htmls wszystkich zdefiniowanych adresów urls 
#   zdefiniowanych w macierzy, do której odwołuje się zmienna $urlArr
# Zmienne wejściowe:
#   $numberOfElements => rozmiar macierzy odwołania
#   $urlArr => macierz (odwołanie)z adresami URL do przetworzenia
#   $name => prefiks pliku, który ma być użyty
# Zmienne wyjściowe:
#   pliki tekstowe z kodem html z pobranych linków
# Zwraca:
#   Podprogram operuje na macierzy zdefiniowanej już wcześniej poza funkcją.
#   Podprogram nic nie zwraca.
sub getSERPResults {
    my ($numberOfElements, $urlArr, $name) = @_;
    my $ua = new LWP::UserAgent;
    my $res;

    $ua->timeout(25);
    $ua->agent("My Crawler");
    
    for($i=0;$i<$numberOfElements;$i++){
        $filename = "./serptemp/". $name . $i . ".txt";
        $res = $ua->get("$urlArr->[$i]",':content_file' => "$filename");
    }
}

# Podprogram:
#   cleanText
# Opis:
#   Ten podprogram używany jest to wyczyszczenia fragemntów kodu HTML.
# Zmienne wejściowe:
#   $text => treść pliku do wyczyszczenia
# Zmienne wyjściowe:
#   Brak
# Zwraca:
#   Nic, cała praca wykonywana na przekazanej macierzy
sub cleanText {
    my $text = shift;
       $text =~ s/\(/ /g;
       $text =~ s/\)/ /g;
       $text =~ s/\[/ /g;
       $text =~ s/\]/ /g;
       $text =~ s/\./ /g;
       $text =~ s/\-/ /g;
       $text =~ s/\=/ /g;
       $text =~ s/\|/ /g;
       $text =~ s/\!/ /g;
       $text =~ s/\,/ /g;
       $text =~ s/\?/ /g;
       $text =~ s/\^/ /g;
       $text =~ s/\:/ /g;
       $text =~ s/\;/ /g;
       $text =~ s/\&/ /g;
       $text =~ s/\*/ /g;
       $text =~ s/\$/ /g;
       $text =~ s/\s+/ /g;
    return $text;
}
