use strict;
use warnings;

#Bioperl moduler
use Bio::Tools::Run::StandAloneBlast;
use Bio::SeqIO;
use Bio::SearchIO;
use Bio::SearchIO::Writer::HTMLResultWriter;


#initialisering
my @query_hit_list = ();
my @subject_hit_list = ();
my @query_ID_list = ();
my @subject_ID_list = ();


#Hovedprogram


#importere blast input filer og sætter deres parametre
my @params = (program => 'blastp', database => 'Q0045', Filterquerysequence => 'F', X => 50);	#parametre til StandAloneBlast
my $blast_obj =  Bio::Tools::Run::StandAloneBlast->new(@params);	#danner blast objekt

my $query_seqio_obj_input = Bio::SeqIO->new(-file => "Q0045", -format => "fasta");	#input objekt (query) laves og parametre til den 														#gives
my $subject_seqio_obj_input = Bio::SeqIO->new(-file => "Q0045", -format => "fasta");	#input objekt (subject) laves og parametre til 														#den gives

#trækker alle subject IDs ud af subject input fil og sætter dem i liste
while (my $subject_seq = $subject_seqio_obj_input->next_seq) {push(@subject_ID_list, $subject_seq->display_id())};

#foretager blast
while (my $seq_obj = $query_seqio_obj_input->next_seq) {	#én sekvens (query) trækkes ud af input filen af gangen vha. next_seq metoden

	my $report_obj = $blast_obj->blastall($seq_obj);	#denne sekvens (query) blastes med præferencerne sat ovenover, og et rapport objekt laves

	my $result_obj = $report_obj->next_result;	#ét resultat trækkes ud af rapporten af gangen vha. next_result metoden, og danner 									#resultat objektet. Objektet indeholder alle hits som igen indeholder alle hsp.

	#trækker alle query IDs ud af query input fil og sætter dem i liste
	push(@query_ID_list, $seq_obj->display_id());

	my $count_result_obj++;
print "main prog OK\n";

	parse_blast_result(\$result_obj);				#resultatet sendes til parse_blast_result subrutinen. Dvs. ét resultat 
									#for hvert blastet input (query) sekvens parses af gangen.

	write_blast_report_html(\$result_obj, 'testigen'.$count_result_obj);	#blast resultatet for hvert query protein visualiseres vha. denne 												#subrutine
}


print "i main prog igen\n";

#kalder subrutine der parser "hittet_S_list.out" filen til en liste indeholdende hittet Subject IDs og en liste med Query IDs der har hittet i Subject #DB'en
my ($hittet_subject_list, $hittet_query_list) = parse_hittet_S_list();

print "i main ", @$hittet_subject_list[0],"\n";
print "i main ", @$hittet_query_list[0], "\n";


#sammenligner input liste med subject IDs og subject IDs der er hittet med en query sekvens (fra filen "hittet_S_list.out"). returnere subject IDs der #ikke er hittet af query input sekvenserne. Dvs. finder suject gener der ikke har et nært beslægtet query gen.
my $no_subject_hit_list = compare_lists(\@subject_ID_list, $hittet_subject_list);

#printer subject IDs der ikke er hittet af query input sekvenserne til filen "no_subject_hit_list.out"
open(FH_NO_SUBJECT_HIT_LIST, ">>no_subject_hit_list.out");

foreach (@$no_subject_hit_list) {

	print FH_NO_SUBJECT_HIT_LIST $_,"\n";; 

}

close FH_NO_SUBJECT_HIT_LIST;

if (defined($$no_subject_hit_list[0])) {print "subjecter ikke hittet er: ",$$no_subject_hit_list[0],"\n";}


#sammenligner input liste med query IDs og query IDs der har hittet med en subject sekvens (fra filen "hittet_S_list.out"). returnere query IDs der ikke #har hittet en subject input sekvens. Dvs. finder query gener der ikke har et nært beslægtet subject gen.
my $no_query_hit_list = compare_lists(\@query_ID_list, $hittet_query_list);

#printer query IDs der ikke har hittet en subject input sekvens til filen "no_query_hit_list.out"
open(FH_NO_QUERY_HIT_LIST, ">>no_query_hit_list.out");

foreach (@$no_query_hit_list) {

	print FH_NO_QUERY_HIT_LIST $_,"\n";; 

}

close FH_NO_QUERY_HIT_LIST;

if (defined($$no_query_hit_list[0])) {print "query ikke hittet er: ",$$no_query_hit_list[0],"\n";}


exit;



################################################################

#Subrutiner

#################################################################

sub parse_blast_result {	#hovedsubrutine der parser blast resultatet primær ved at kalde andre subrutiner

	my ($result_obj) = @_;	#resultat input objekt fra hovedprogrammet. 

	#initialisering
	my $subject_chromosome_nr = '';
	my $subject_strain = '';
	my $percent_identity = 100;
	my @aligned_query_region = ();
	my @aligned_subject_region = ();
	my $count_hit = 0;
	my %result_hash = ();
	my $number_of_hits = $$result_obj->num_hits;

print	"antal hits er: ",$number_of_hits, "\n";

	my $total_query_protein_length = $$result_obj->query_length;	#længden af hele query protein input sekvensen

	#headeren for query sekvensen parses
print	my ($query_protein_acc_ID, $query_chromosome_nr, $query_chromosome_position, $query_gene_orientation, 
	$number_of_query_introns) = parse_query_protein_header(\$$result_obj);	
print "Q kromo nr er: ", $query_chromosome_nr,"\n";
print "\n";

	#sender protein ID til "no_hit.out" filen hvis proteinet ikke har et hit i DB'en
	if ($number_of_hits == 0) {
print "ingen hits\n";
		open(FH_NO_HITS, ">>no_hit.out");

		print FH_NO_HITS $query_protein_acc_ID,"\n";

		close FH_NO_HITS;

	}


	while (my $hit = $$result_obj->next_hit) {	#ét hit resultat trækkes ud af resultat objektet af gangen vha. next_hit metoden.
							#Hit resultatet indeholder den eller de alignet sekvens(er) der er mellem query sekvensen og 
							#denne ene hit (subject) sekvens.
print "HIT OK\n";
		#initialisering
		my $count_hsp = 0;
		my $query_alignment_length_result = '';
		my $subject_alignment_length_result = '';
		my @aligned_query_region = ();
		my @aligned_subject_region = ();
		my %query_nomatch_hash = ();
		my %subject_nomatch_hash = ();
		my %query_conserved_hash = ();
		my %subject_conserved_hash = ();
		
		#angiver nummeret af hittet for query sekvensen
		$count_hit++;	
print "antal hits er: ", $number_of_hits, "\n";			
print "antal hit count er: ", $count_hit, "\n";
	
		#bestemmer antal HSP'ere for hittet
		my $number_of_hsps_in_hit = $hit->num_hsps;
print "antal hsps er: ", $number_of_hsps_in_hit, "\n";
			
		#headeren for hit (subjekt) sekvensen parses
print		my ($subject_protein_acc_ID, $subject_chromosome_nr, $subject_chromosome_position, $subject_gene_orientation, 
		$number_of_subject_introns) = parse_subject_protein_header(\$hit);
print "\n";
		my $subject_input_length = $hit->length;
print "S længden er: ",$subject_input_length,"\n";

		#Tjekker om query og hit sekvensen findes på samme kromosom
		my $check_on_same_chromosome = check_on_same_chromosome(\$query_chromosome_nr, \$subject_chromosome_nr);
print "samme kromo? ", $check_on_same_chromosome,"\n";

		while (my $hsp = $hit->next_hsp) {	#ét hsp resultat trækkes ud af hit objektet af gangen vha. next_hsp metoden.

			#initialisering
			my $unique_hash_key = '';
			
			#angiver nummeret af hsp'en for query sekvensens givne hit
			$count_hsp++;

print "antal hsp count er: ", $count_hsp, "\n";

			$percent_identity = $hsp->percent_identity;
print "% er: ", $percent_identity, "\n";

			#loop hvori et lavere mål for identitetsprocenten af query-hsp evt. kan sættes. Dvs. man kan sortere dårlige alignments fra. 
			if ($hsp->percent_identity < 90) {
print "dårlig hsp\n";
				next;

			} 		

			#sender Subject ID med OK alignment til "hittet_S_list.out" filen som første element på line og Query ID som hitter Subjectet som 				#andet element på line, separeret af et TAB
			if ($hsp->percent_identity => 90) {
print "god hsp alignment\n";
				push(@query_hit_list, $query_protein_acc_ID);
				push(@subject_hit_list, $subject_protein_acc_ID);

				open(FH_S_LIST, ">>hittet_S_list.out");

				print FH_S_LIST $subject_protein_acc_ID,"\t",$query_protein_acc_ID,"\n";

				close FH_S_LIST;
	
			} 	 	
		
print "HSP OK, % er $percent_identity\n";	

			#tjekker om hele query input protein sekvensen er med i alignmenten					
			$query_alignment_length_result = check_if_full_length_query_aligned(\$hsp, \$$result_obj);
print $query_alignment_length_result, "\n";

			#tjekker om hele subjekt input protein sekvensen er med i alignmenten	
			$subject_alignment_length_result = check_if_full_length_subject_aligned(\$hsp, \$hit);
print $subject_alignment_length_result, "\n";

			#angiver intervallet af query regionen der er alignet
			@aligned_query_region = retrieve_aligned_query_region(\$hsp);
print "query range er: ", $aligned_query_region[0], "-", $aligned_query_region[1],"\n";

			#angiver intervallet af subjekt regionen der er alignet
			@aligned_subject_region = retrieve_aligned_subject_region(\$hsp);
print "subject range er: ", $aligned_subject_region[0], "-", $aligned_subject_region[1],"\n";

			#linker query positionen til Aminosyren for de anminosyrer der ikke matcher en Aa i subjekt sekvensen. Dvs. en key i hashen er  			#en position og dens value er den Aa i query sekvensen der ikke er et match til i subjekt sekvensen.
			%query_nomatch_hash = query_seq_alignment_nomatch_residues(\$hsp);
print "query nomatch pos er: ", keys %query_nomatch_hash, "\n";
print "query nomatch Aa er: ", values %query_nomatch_hash, "\n";	

			#linker subjekt positionen til Aminosyren for de anminosyrer der ikke matcher en Aa i query sekvensen. Dvs. en key i hashen er 				#en position og dens value er den Aa i subject sekvensen der ikke er et match til i query sekvensen.
			%subject_nomatch_hash = subject_seq_alignment_nomatch_residues(\$hsp);
	
print "subject nomatch pos er: ", keys %subject_nomatch_hash, "\n";
print "subject nomatch Aa er: ", values %subject_nomatch_hash, "\n";

			#linker query positionen til Aminosyren for de anminosyrer der er konserverede men ikke identiske til en Aa i subjekt sekvensen. 				#Dvs. en key i hashen er en position og dens value er den Aa i query sekvensen der er konserveret men ikke identisk til en Aa i 			#subjekt sekvensen.
			%query_conserved_hash = query_seq_alignment_conserved_residues(\$hsp);
print "query conserved pos er: ", keys %query_conserved_hash, "\n";
print "query conserved Aa er: ", values %query_conserved_hash, "\n";	

			#linker subjekt positionen til Aminosyren for de anminosyrer der er konserverede men ikke identiske til en Aa i query sekvensen. 				#Dvs. en key i hashen er en position og dens value er den Aa i subjekt sekvensen der er konserveret men ikke identisk til en Aa i 				#query sekvensen.
			%subject_conserved_hash = subject_seq_alignment_conserved_residues(\$hsp);
	
print "subject conserved pos er: ", keys %subject_conserved_hash, "\n";
print "subject conserved Aa er: ", values %subject_conserved_hash, "\n";

			#laver et unikt ID for hver hsp. Medtager query ID, hit nummer og hsp nummer 
			$unique_hash_key = $query_protein_acc_ID."hit".$count_hit."hsp".$count_hsp;
print "unik hash key er: ",$unique_hash_key, "\n";

			#hasher alle de ovenover fundne værdier til den unikke hash key i result hashen
			$result_hash{$unique_hash_key} = [$query_protein_acc_ID,  			
				       $query_chromosome_nr, $query_chromosome_position, $query_gene_orientation,
				       $number_of_query_introns, $subject_protein_acc_ID, $subject_chromosome_nr, 
	 			       $subject_chromosome_position, $subject_gene_orientation, $number_of_subject_introns, 				               $query_alignment_length_result, $subject_alignment_length_result, $percent_identity, 					       \%query_nomatch_hash, \%subject_nomatch_hash, \%subject_conserved_hash,      
				       \%query_conserved_hash, $number_of_hsps_in_hit, $count_hsp, \@aligned_query_region, 
				       \@aligned_subject_region, $check_on_same_chromosome,$total_query_protein_length, 	
				       $subject_input_length];

			#sender resultater i %result_hash til analyse således at hits'ene kan fordeles på tabeller
			result_analysis(\%result_hash);

			#printer de parsede resultater ud for hver query blastet mod databasen
			open(FH, ">$unique_hash_key.out") or die "cannot save $unique_hash_key.out to textfile\n";

			print "ele 1 af hash: ", $result_hash{$unique_hash_key}[0],"\n";
	
			print FH ($unique_hash_key) = keys %result_hash, "\n";
			print FH $result_hash{$unique_hash_key}[0], "\n";	#query_protein_acc_ID,  			
			print FH $result_hash{$unique_hash_key}[1], "\n"; #query_chromosome_nr, 
			print FH $result_hash{$unique_hash_key}[2], "\n"; #query_chromosome_position, 
			print FH $result_hash{$unique_hash_key}[3], "\n"; #query_gene_orientation,
			print FH $result_hash{$unique_hash_key}[4], "\n"; #number_of_query_introns, 
			print FH $result_hash{$unique_hash_key}[5], "\n"; #subject_protein_acc_ID, 
			print FH $result_hash{$unique_hash_key}[6], "\n"; #subject_chromosome_nr,
			print FH $result_hash{$unique_hash_key}[7], "\n"; #subject_chromosome_position, 
			print FH $result_hash{$unique_hash_key}[8], "\n"; #subject_gene_orientation, 
			print FH $result_hash{$unique_hash_key}[9], "\n"; #number_of_subject_introns, 	               
			print FH $result_hash{$unique_hash_key}[10], "\n"; #query_alignment_length_result, 
			print FH $result_hash{$unique_hash_key}[11], "\n"; #subject_alignment_length_result, 
			print FH $result_hash{$unique_hash_key}[12], "%", "\n"; #percent_identity, 
			
			#query_nomatches 
			print FH "Query nomatches:\n";
			foreach my $key1 (sort keys %{$result_hash{$unique_hash_key}[13]}) {

			print FH $key1, "=>", ${$result_hash{$unique_hash_key}[13]}{$key1},"\n";

			} 	 

			#subject_nomatches
			print FH "Subject nomatches:\n";
			foreach my $key2 (sort keys %{$result_hash{$unique_hash_key}[14]}) {

				print FH $key2, "=>", ${$result_hash{$unique_hash_key}[14]}{$key2},"\n";

			} 	 

			#subject_conserved
			print FH "Subject conserved:\n";
			foreach my $key3 (sort keys %{$result_hash{$unique_hash_key}[15]}) {

				print FH $key3, "=>", ${$result_hash{$unique_hash_key}[15]}{$key3},"\n";

			} 	 

			#query_conserved 
			print FH "Query conserved:\n";
			foreach my $key4 (sort keys %{$result_hash{$unique_hash_key}[16]}) {

				print FH $key4, "=>", ${$result_hash{$unique_hash_key}[16]}{$key4},"\n";

			} 	 
			
			print FH $result_hash{$unique_hash_key}[17], "\n"; #number_of_hsps_in_hit, 
			print FH $result_hash{$unique_hash_key}[18], "\n"; #count_hsp, 
			print FH my $query_alignment_start_nr = ${$result_hash{$unique_hash_key}[19]}[0];	#start nr for query alignment 
			print FH "-";
			print FH my $query_alignment_end_nr = ${$result_hash{$unique_hash_key}[19]}[1], "\n"; #slut nr for query 																   #alignment 
			print FH my $subject_alignment_start_nr = ${$result_hash{$unique_hash_key}[20]}[0]; #start nr for subject 															          #alignment 
			print FH "-";
			print FH my $subject_alignment_end_nr = ${$result_hash{$unique_hash_key}[20]}[1], "\n"; #slut nr for subject 																      #alignment   
			print FH $result_hash{$unique_hash_key}[21], "\n"; #check_on_same_cromosom

			print FH $total_query_protein_length, "\n"; #længden af hele query protein input sekvensen		

			close FH;	

print "efter hash\n";
print keys %result_hash, "\n";	

print "ele 1 af hash: ", $result_hash{$unique_hash_key}[0],"\n";
print "ele 2 af hash: ", $result_hash{$unique_hash_key}[1],"\n";
print "ele 14 af hash: ",keys %{$result_hash{$unique_hash_key}[14]},"\n";

foreach (@{$result_hash{$unique_hash_key}[20]}) {

	print $_, "\n";
				
}

			

		}	

	}

}
				

#################################################################

sub check_if_full_length_query_aligned {	#tjekker om hele query input protein sekvensen er med i alignmenten

	my ($hsp, $result_obj) = @_;

print "Q længden er: ", my $total_query_protein_length = $$result_obj->query_length;		#længden af hele query protein input sekvensen
print "\n";
print "Q længden alignet er: ", my $alignment_query_protein_length = $$hsp->length('query');	#længden af hele query protein sekvensen alignet, 													#eksklusiv gaps
print "\n";
	if ($total_query_protein_length == $alignment_query_protein_length) {

		return 'QUERY_FULL_LENGTH';

	} else {

		return 'QUERY_NOT_FULL_LENGTH';

	}

}

########################################################################

sub check_on_same_chromosome {	#tjekker om query og subject matchet blev fundet på det samme kromosom

	my ($query_chromosome_nr, $subject_chromosome_nr) = @_;	

	if ($$query_chromosome_nr eq $$subject_chromosome_nr) {

		return 'wright_chromosome'; 
	
	} else {return 'wrong_chromosome'}
	
}


##########################################################################

sub parse_query_protein_header {	#parser query proteinets accession ID, kromosom lokalisation, position på kromosom,  
					#gen's orientation på kromosom og antallet af gen introns, og returnere dem
				
	my ($result_obj) = @_;

	my $query_protein_header = $$result_obj->query_description;		#query_description metoden returnere query headeren
print "query header er: ", $query_protein_header,"\n";
	my @query_protein_header_elements = split / /, $query_protein_header;	#splitter headeren

	my $query_protein_acc_ID = $$result_obj->query_accession;		#query_accession metoden returnere query accession ID'et
	my $query_chromosome_nr = $query_protein_header_elements[3];		#kromosome nr trækkes ud af query header
print "se her",	my $query_chromosome_position = $query_protein_header_elements[5];	#kromosome position trækkes ud af query header	
print "\n";
	my $query_gene_orientation = $query_protein_header_elements[6];	#query gen orientation trækkes ud af query header
	
	$query_protein_acc_ID =~ s/\.//g;						#ryder op i query accession ID'et

	if ($query_gene_orientation =~ /reverse/ig) { $query_gene_orientation = 'revcom';	#reverse oversættes til revcom
													#elers til normal
	} else { $query_gene_orientation = 'normal';}

	my $number_of_introns = ($query_chromosome_position =~ tr/,//) - 1;			#antal introns bestemmes ud fra headerens 														#udtrukne kromosom position

	return ($query_protein_acc_ID, $query_chromosome_nr, $query_chromosome_position, $query_gene_orientation, $number_of_introns);

}


##########################################################################

sub parse_subject_protein_header {	#parser subject proteinets accession ID, kromosom lokalisation, position på kromosom,  
					#gen's orientation på kromosom og antallet af gen introns, og returnere dem til sub parse_blast_result 
				
	my ($hit) = @_;

	my $subject_protein_header = $$hit->description;					#description metoden returnere subjekt headeren
print "subject header er: ", $subject_protein_header,"\n";
	my @subject_protein_header_elements = split / /, $subject_protein_header; 	#splitter headeren

	my $subject_protein_acc_ID = $$hit->accession;					#accession metoden returnere subjekt accession ID'et
	my $subject_chromosome_nr = $subject_protein_header_elements[3];		#kromosome nr trækkes ud af subjekt header
	my $subject_chromosome_position = $subject_protein_header_elements[5];	#kromosome position trækkes ud af subjekt header
	my $subject_gene_orientation = $subject_protein_header_elements[6];		#query gen orientation trækkes ud af subjekt header
	
	$subject_protein_acc_ID =~ s/\.//g;							#ryder op i subjekt accession ID'et

	if ($subject_gene_orientation =~ /reverse/ig) { $subject_gene_orientation = 'revcom';	#reverse oversættes til revcom
													#ellers normal
	} else { $subject_gene_orientation = 'normal';}

	my $number_of_subject_introns = ($subject_chromosome_position =~ tr/,//) - 1;		#antal introns bestemmes ud fra headerens 														#udtrukne kromosom position


	return ($subject_protein_acc_ID, $subject_chromosome_nr, $subject_chromosome_position, $subject_gene_orientation, 
		$number_of_subject_introns);
}


#####################################################################################

sub write_blast_report_html {	#subrutine der udprinter blast rapporten i html format til filen "searchio2.html"

	my ($result_obj, $unique_hash_key) = @_;

	my $writerhtml = new Bio::SearchIO::Writer::HTMLResultWriter();

	my $outhtml = new Bio::SearchIO(-writer => $writerhtml, -file => ">$unique_hash_key.html");	#ouput er searchio.html

	$outhtml->write_result($$result_obj);

}


#############################################################################

sub query_seq_alignment_nomatch_residues {		#linker query positionen til Aminosyren for de anminosyrer der ikke matcher en Aa i subjekt 								#sekvensen i en hash.  	
							
	my ($hsp_obj) = @_;
	my %query_nomatch_hash = ();
	my @new_query_string = ();

	my @query_string = split "", $$hsp_obj->query_string;	#query_string metoden trækker den alignet del af query sekvensen ud
print "query_string er: ", $$hsp_obj->query_string,"\n";
 
	foreach (@query_string) {					#klipper gaps ud af query sekvensen. Ellers kan man få forkerte nomatch positioner

		if ($_ ne '-') {push @new_query_string, $_};

	}

	my $start_query_number = $$hsp_obj->start('query');	#start('query') metoden trækker query alignment start positionen ud 
print "start query nummer er: ",$start_query_number, "\n";		#Dvs. den position hvor query'ets alignment med subjektet starter

	$start_query_number = $start_query_number - 1;		#nødvendig modifikation af query start positionen

print "start query nummer er nu: ",$start_query_number, "\n";
print "protein mismatch positionerne i query sekvensen er:","\n";

	foreach ($$hsp_obj->seq_inds('query', 'nomatch')) {	#seq_inds('query', 'nomatch') metoden trækker positionerne ud på alle de Aa i query 									#sekvensen der ikke har et match på subjekt sekvensen 

print $_, "\n";
print $new_query_string[$_ -1 -$start_query_number], "\n";

		$query_nomatch_hash{$_} = $new_query_string[$_ -1 -$start_query_number];	#nødvendig modifikation af query nomatch 														#positionen, 
												#trækker derefter den tilsvarende aminosyre ud af query 												#sekvensen og hasher den til positionen.

	}

	return %query_nomatch_hash;

}	


################################################################


sub subject_seq_alignment_nomatch_residues {	#linker subjekt positionen til Aminosyren for de anminosyrer der ikke matcher en Aa i query sekvensen i 						#en hash.

	my ($hsp_obj) = @_;
	my %subject_nomatch_hash = ();
	my @new_subject_string = ();

	my @subject_string = split "", $$hsp_obj->hit_string;	#hit_string metoden trækker den alignet del af subjekt sekvensen ud
print "subject_string er: ", $$hsp_obj->hit_string, "\n";

	foreach (@subject_string) {					#klipper gaps ud af subject sekvensen. Ellers kan man få forkerte nomatch 										#positioner
		if ($_ ne '-') {push @new_subject_string, $_};

	}

	my $start_subject_number = $$hsp_obj->start('hit');	#start('hit') metoden trækker subjekt alignment start positionen ud 
print "start subject nummer er: ",$start_subject_number, "\n";	#Dvs. den position hvor subjektets alignment med query'en starter

	$start_subject_number = $start_subject_number - 1;	#nødvendig modifikation af query start positionen

print "start subject nummer er nu: ",$start_subject_number, "\n";
print "protein mismatch positionerne i subject sekvensen er:","\n";

	foreach ($$hsp_obj->seq_inds('hit', 'nomatch')) {	#seq_inds('hit', 'nomatch') metoden trækker positionerne ud på alle de Aa i subjekt 									#sekvensen der ikke har et match på query sekvensen 

print $_, "\n";
print $new_subject_string[$_ -1 -$start_subject_number], "\n";

		$subject_nomatch_hash{$_} = $new_subject_string[$_ -1 -$start_subject_number];	#nødvendig modifikation af subjekt nomatch 														#positionen, trækker derefter den tilsvarende 														#aminosyre ud af subjekt sekvensen og hasher den 														#til positionen.
		
	}

	return %subject_nomatch_hash;

}	



###################################################################


sub check_if_full_length_subject_aligned {	#tjekker om hele subject input protein sekvensen er med i alignmenten

	my ($hsp, $hit) = @_;

print "S længden er: ", my $total_subject_protein_length = $$hit->length;		#længden af hele subject protein input sekvensen
print "\n";
print "S længden alignet er: ", my $alignment_subject_protein_length = $$hsp->length('hit');	#længden af hele subject protein sekvensen 														#alignet, eksklusiv gaps
print "\n";

	if ($total_subject_protein_length == $alignment_subject_protein_length) {

		return 'SUBJECT_FULL_LENGTH';

	} else {

	return 'SUBJECT_NOT_FULL_LENGTH';

	}

}


#############################################################################

sub retrieve_aligned_query_region {	#udtrækker regionen af query input protein sekvensen der er med i alignmenten

	my ($hsp) = @_;
	my @query_aligned_region = $$hsp->range('query');		#range('query') metoden giver regionen af hele query protein sekvensen alignet
#print "query range er: ", shift @query_aligned_region, "\n";		#F.eks. (1, 1160)
	return @query_aligned_region;

}


#############################################################################

sub retrieve_aligned_subject_region {	#udtrækker regionen af subject input protein sekvensen der er med i alignmenten

	my ($hsp) = @_;

	my @subject_aligned_region = $$hsp->range('hit');		#range('query') metoden giver regionen af hele subject protein sekvensen alignet
									#F.eks. (1, 1160)
	return @subject_aligned_region;

}


#############################################################################


sub query_seq_alignment_conserved_residues {		#linker query positionen til Aminosyren for de anminosyrer der er konserverede men ikke identiske 								#til en Aa i subjekt sekvensen i en hash.

	my ($hsp_obj) = @_;
	my %query_conserved_hash = ();
	my @new_query_string = ();

	my @query_string = split "", $$hsp_obj->query_string;	#query_string metoden trækker den alignet del af query sekvensen ud

	foreach (@query_string) {					#klipper gaps ud af query sekvensen. Ellers kan man få forkerte nomatch positioner

		if ($_ ne '-') {push @new_query_string, $_};

	}

	my $start_query_number = $$hsp_obj->start('query');	#start('query') metoden trækker query alignment start positionen ud 
									#Dvs. den position hvor query'ets alignment med subjektet starter
print "protein konserverede positioner i query sekvensen er:","\n";

	foreach ($$hsp_obj->seq_inds('query', 'conserved-not-identical')) {	#seq_inds('query', 'conserved-not-identical') metoden trækker 											#positionerne ud på alle de Aa i query sekvensen der er konserverede men 											#ikke identiske med et match på subjekt sekvensen 		

print $_, "\n";
print $new_query_string[$_ -1], "\n";

		$query_conserved_hash{$_} = $new_query_string[$_ -1];	#nødvendig modifikation af query conserved-not-identical positionen, 
										#trækker derefter den tilsvarende aminosyre ud af query 										#sekvensen og hasher den til positionen.	
		

	}

	return %query_conserved_hash;

}	


################################################################


sub subject_seq_alignment_conserved_residues {		#linker subjekt positionen til Aminosyren for de anminosyrer der er konserverede men ikke 								#identiske til en Aa i query sekvensen i en hash.

	my ($hsp_obj) = @_;
	my %subject_conserved_hash = ();
	my @new_subject_string = ();

	my @subject_string = split "", $$hsp_obj->hit_string;	#hit_string metoden trækker den alignet del af subjekt sekvensen ud

	foreach (@subject_string) {					#klipper gaps ud af query sekvensen. Ellers kan man få forkerte nomatch positioner

		if ($_ ne '-') {push @new_subject_string, $_};

	}

	my $start_subject_number = $$hsp_obj->start('hit');	#start('hit') metoden trækker subjekt alignment start positionen ud 
									#Dvs. den position hvor subjektets alignment med query'en starter

print "protein konserverede positioner i subject sekvensen er:","\n";

	foreach ($$hsp_obj->seq_inds('hit', 'conserved-not-identical')) {	#seq_inds('hit', 'conserved-not-identical') metoden trækker 											#positionerne ud på alle de Aa i subjekt sekvensen der er konserverede  										#men ikke identiske med et match på subjekt sekvensen 		


print $_, "\n";
print $new_subject_string[$_ -1], "\n";

		$subject_conserved_hash{$_} = $new_subject_string[$_ -1];	#nødvendig modifikation af subjekt conserved-not-identical 											#positionen, trækker derefter den tilsvarende 											#aminosyre ud af subjekt sekvensen og hasher den 											#til positionen.
		
	}

	return %subject_conserved_hash;

}	



###################################################################


sub result_analysis {

	my ($result_hash) = @_;

print "analyse\n";

	#trækker det unikke hash ID ud for HSP'en
	my ($unique_hash_key) = keys %$result_hash;
	
print "key er: ", $unique_hash_key, "\n";

	my $chromosome_location = $$result_hash{$unique_hash_key}[21];

print "kromo loka er: ", $chromosome_location, "\n";

	#sender det unikke protein ID til "wright_chromosome.out" filen hvis Query and Subject generne er 100% ens, ellers sendes det til 		
	#"wrong_chromosome.out" filen
	if ($chromosome_location eq 'wright_chromosome') {
print "rigtig kromo\n";
#		my $count_wright_chr++;

		#appender unik protein ID til "wright_chromosome.out" filen 
		open(FH_WRIGHT_Chr, ">>wright_chromosome.out") or die "cannot open wright_chromosome.out file\n";

		print FH_WRIGHT_Chr $unique_hash_key, "\n";

		close FH_WRIGHT_Chr;

	} else {
print "forkert kromo\n";

#		my $count_wrong_chr++;

		#appender unik protein ID til "wrong_chromosome.out" fil 
		open(FH_WRONG_Chr, ">>wrong_chromosome.out") or die "cannot open wrong_chromosome.out file\n";

		print FH_WRONG_Chr $unique_hash_key, "\n";

		close FH_WRONG_Chr;

	}

print "\# Q introns er: ", $$result_hash{$unique_hash_key}[4], "\n";
print "\# S introns er: ", $$result_hash{$unique_hash_key}[9], "\n";



	#sender det unikke protein ID til "wright_introns.out" filen hvis Query and Subject generne er 100% ens, ellers sendes det til 			
	#"wrong_introns.out" filen
	if ($$result_hash{$unique_hash_key}[4] == $$result_hash{$unique_hash_key}[9]) {

#		my $count_wright_introns++;

print "samme antal introns\n";
		#appender unik protein ID til "wright_introns.out" filen 
		open(FH_WRIGHT_I, ">>wright_introns.out") or die "cannot open wright_introns.out file\n";

		print FH_WRIGHT_I $unique_hash_key, "\n";

		close FH_WRIGHT_I;

	} else {

#		my $count_wrong_introns++;

print "forkert introns\n";
		#appender unik protein ID til "wrong_introns.out" fil 
		open(FH_WRONG_I, ">>wrong_introns.out") or die "cannot open wrong_introns.out file\n";

		print FH_WRONG_I $unique_hash_key, "\n";

		close FH_WRONG_I;

	}


	#sender det unikke protein ID til "wright_gene_orientation.out" filen hvis Query and Subject generne har samme orientation, ellers sendes det til 		#"wrong_gene_orientation.out" filen
	if ($$result_hash{$unique_hash_key}[3] eq $$result_hash{$unique_hash_key}[8]) {

#		my $count_wright_gene_orientation++;
print "samme gen orientation\n";

		#appender unik protein ID til "wright_gene_orientation.out" filen 
		open(FH_WRIGHT_GO, ">>wright_gene_orientation.out") or die "cannot open wright_gene_orientation.out file\n";

		print FH_WRIGHT_GO $unique_hash_key, "\n";

		close FH_WRIGHT_GO;

	} else {

#		my $count_wrong_gene_orientation++;

print "forkert gen orientation\n";
		#appender unik protein ID til "wrong_gene_orientation.out" filen 
		open(FH_WRONG_GO, ">>wrong_gene_orientation.out") or die "cannot open wrong_gene_orientation.out file\n";

		print FH_WRONG_GO $unique_hash_key, "\n";

		close FH_WRONG_GO;

	}


print "%_ID er: ", 	$$result_hash{$unique_hash_key}[12], "\n";

	#sender det unikke protein ID til "wright_align.out" filen hvis Query and Subject generne er 100% ens, ellers sendes det til 			
	#"wrong_align.out" filen
	if ($$result_hash{$unique_hash_key}[12] == 100) {

#		my $count_wright_align++;
print "%ID er 100\n";

		#appender unik protein ID til "wright_align.out" filen 
		open(FH_WRIGHT_ALIGN, ">>wright_align.out") or die "cannot open wright_align.out file\n";

		print FH_WRIGHT_ALIGN $unique_hash_key, "\n";

		close FH_WRIGHT_ALIGN;

	} else {

#		my $count_wrong_align++;

print "%ID er ikke 100\n";
		#appender unik protein ID til "wrong_align.out" filen 
		open(FH_WRONG_ALIGN, ">>wrong_align.out") or die "cannot open wrong_align.out file\n";

		print FH_WRONG_ALIGN $unique_hash_key, "\n";

		close FH_WRONG_ALIGN;

	}

				
print "Q_align er: ", 	$$result_hash{$unique_hash_key}[10], "\n";

	#sender det unikke protein ID til "wright_Q_align.out" filen hvis Query sekvensen er fuldt alignet med Subject sekvensen, ellers sendes det til 	#"wrong_Q_align.out" filen
	if ($$result_hash{$unique_hash_key}[10] eq 'QUERY_FULL_LENGTH') {

#		my $count_wright_Q_align++;
print "Q er fuldt alignet\n";

		#appender unik protein ID til "wright_Q_align.out" filen 
		open(FH_WRIGHT_Q_ALIGN, ">>wright_Q_align.out") or die "cannot open wright_Q_align.out file\n";

		print FH_WRIGHT_Q_ALIGN $unique_hash_key, "\n";

		close FH_WRIGHT_Q_ALIGN;

	} else {

#		my $count_wrong_Q_align++;

print "Q er ikke fuldt alignet\n";
		#appender unik protein ID til "wrong_Q_align.out" filen 
		open(FH_WRONG_Q_ALIGN, ">>wrong_Q_align.out") or die "cannot open wrong_Q_align.out file\n";

		print FH_WRONG_Q_ALIGN $unique_hash_key, "\n";

		close FH_WRONG_Q_ALIGN;

	}
	
			
print "S_align er: ", 	$$result_hash{$unique_hash_key}[11], "\n";

	#sender det unikke protein ID til "wright_S_align.out" filen hvis Subject sekvensen er fuldt alignet med Query sekvensen, ellers sendes det til 	#"wrong_S_align.out" filen
	if ($$result_hash{$unique_hash_key}[11] eq 'SUBJECT_FULL_LENGTH') {

#		my $count_wright_S_align++;
print "S er fuldt alignet\n";

		#appender unik protein ID til "wright_S_align.out" filen 
		open(FH_WRIGHT_S_ALIGN, ">>wright_S_align.out") or die "cannot open wright_S_align.out file\n";

		print FH_WRIGHT_S_ALIGN $unique_hash_key, "\n";

		close FH_WRIGHT_S_ALIGN;

	} else {

#		my $count_wrong_S_align++;

print "S er ikke fuldt alignet\n";
		#appender unik protein ID til "wrong_S_align.out" filen 
		open(FH_WRONG_S_ALIGN, ">>wrong_S_align.out") or die "cannot open wrong_S_align.out file\n";

		print FH_WRONG_S_ALIGN $unique_hash_key, "\n";

		close FH_WRONG_S_ALIGN;

	}
				

	#sender det unikke protein ID og antallet af nomatches til "Q_nomatch.out" filen hvis Query sekvensen har nomatches/mismatches med Subject 		#sekvensen, ellers sendes kun det unikke protein ID til "no_Q_nomatch.out" filen
	if (%{$$result_hash{$unique_hash_key}[13]}) {
print "her er Q nomatches\n";
#		my $count_Q_nomatch++;

		my $count_Q_nomatch_ele = keys %{$$result_hash{$unique_hash_key}[13]};
print "antal nomatches er: ", $count_Q_nomatch_ele, "\n";

		#appender unik protein ID til "Q_nomatch.out" filen 
		open(FH_Q_NOMATCH, ">>Q_nomatch.out") or die "cannot open Q_nomatch.out file\n";

		print FH_Q_NOMATCH $unique_hash_key, "=>", $count_Q_nomatch_ele, "\n";

		close FH_Q_NOMATCH;


	} else {
#		my $count_Q_no_nomatch++;

		#appender unik protein ID til "no_Q_nomatch.out" filen 
		open(FH_NO_Q_NOMATCH, ">>no_Q_nomatch.out") or die "cannot open no_Q_nomatch.out file\n";

		print FH_NO_Q_NOMATCH $unique_hash_key, "\n";

		close FH_NO_Q_NOMATCH;


print "her er ingen Q nomatches\n";
		
	}

	#sender det unikke protein ID og antallet af nomatches til "S_nomatch.out" filen hvis Subject sekvensen har nomatches/mismatches med Query 		#sekvensen, ellers sendes kun det unikke protein ID til "no_S_nomatch.out" filen
	if (%{$$result_hash{$unique_hash_key}[14]}) {
print "her er S nomatches\n";
#		my $count_S_nomatch++;

		my $count_S_nomatch_ele = keys %{$$result_hash{$unique_hash_key}[14]};
print "antal nomatches er: ", $count_S_nomatch_ele, "\n";

		#appender unik protein ID til "S_nomatch.out" filen 
		open(FH_S_NOMATCH, ">>S_nomatch.out") or die "cannot open S_nomatch.out file\n";

		print FH_S_NOMATCH $unique_hash_key, "=>", $count_S_nomatch_ele, "\n";

		close FH_S_NOMATCH;


	} else {



		#appender unik protein ID til "no_S_nomatch.out" filen 
		open(FH_NO_S_NOMATCH, ">>no_S_nomatch.out") or die "cannot open no_S_nomatch.out file\n";

		print FH_NO_S_NOMATCH $unique_hash_key, "\n";

		close FH_NO_S_NOMATCH;


print "her er ingen S nomatches\n";
		
	}


	#sender det unikke protein ID og antallet af konserverede substitutioner til "Q_conserved.out" filen hvis Query sekvensen har konserverede 		#substitutioner med Subject sekvensen, ellers sendes kun det unikke protein ID til "no_Q_conserved.out" filen
	if (%{$$result_hash{$unique_hash_key}[15]}) {
print "her er Q konserverede\n";
#		my $count_Q_conserved++;

		my $count_Q_conserved_ele = keys %{$$result_hash{$unique_hash_key}[15]};
print "antal konserverede er: ", $count_Q_conserved_ele, "\n";

		#appender unik protein ID til "Q_conserved.out" filen 
		open(FH_Q_CONSERVED, ">>Q_conserved.out") or die "cannot open Q_conserved.out file\n";

		print FH_Q_CONSERVED $unique_hash_key, "=>", $count_Q_conserved_ele, "\n";

		close FH_Q_CONSERVED;


	} else {

#		my $count_Q_no_conserved++;

		#appender unik protein ID til "no_Q_conserved.out" filen 
		open(FH_NO_Q_CONSERVED, ">>no_Q_conserved.out") or die "cannot open no_Q_conserved.out file\n";

		print FH_NO_Q_CONSERVED $unique_hash_key, "\n";

		close FH_NO_Q_CONSERVED;


print "her er ingen Q konserverede\n";
		
	}

	#sender de unikke protein IDs for både Q og S, og antallet af konserverede substitutioner til "S_conserved.out" filen hvis Subject sekvensen har 		#konserverede substitutioner med Query sekvensen, ellers sendes kun de unikke protein IDs til "no_S_conserved.out" filen
	if (%{$$result_hash{$unique_hash_key}[16]}) {
print "her er S konserverede\n";
#		my $count_S_conserved++;

		my $count_S_conserved_ele = keys %{$$result_hash{$unique_hash_key}[16]};
print "antal konserverede er: ", $count_S_conserved_ele, "\n";

		#appender unik protein ID til "S_conserved.out" filen 
		open(FH_S_CONSERVED, ">>S_conserved.out") or die "cannot open S_conserved.out file\n";

		print FH_S_CONSERVED $unique_hash_key, "=>", $$result_hash{$unique_hash_key}[5],":",$count_S_conserved_ele, "\n";

		close FH_S_CONSERVED;


	} else {

#		my $count_S_no_conserved++;

		#appender unik protein ID til "no_S_conserved.out" filen 
		open(FH_NO_S_CONSERVED, ">>no_S_conserved.out") or die "cannot open no_S_conserved.out file\n";

		print FH_NO_S_CONSERVED $unique_hash_key,"=>", $$result_hash{$unique_hash_key}[5], "\n";

		close FH_NO_S_CONSERVED;


print "her er ingen S konserverede\n";
		
	}


print "Q start nr er: ", my $query_alignment_start_nr = ${$$result_hash{$unique_hash_key}[19]}[0], "\n";
print "Q slut nr er: ", my $query_alignment_end_nr = ${$$result_hash{$unique_hash_key}[19]}[1], "\n";
print "S start nr er: ",${$$result_hash{$unique_hash_key}[20]}[0], "\n";
print "S slut nr er: ", ${$$result_hash{$unique_hash_key}[20]}[1], "\n";

	#sender de unikke protein IDs for Q og S til "full_align.out" filen hvis Query og subject sekvensen har alle Aa'ere alignet
	if ((my $query_alignment_start_nr = ${$$result_hash{$unique_hash_key}[19]}[0]) == 1 
		&& ((my $query_alignment_end_nr = ${$$result_hash{$unique_hash_key}[19]}[1]) == $$result_hash{$unique_hash_key}[22]) 
		&& (my $subject_alignment_start_nr = ${$$result_hash{$unique_hash_key}[20]}[0]) == 1 
		&& ((my $subject_alignment_end_nr = ${$$result_hash{$unique_hash_key}[20]}[1]) == $$result_hash{$unique_hash_key}[23])) {

print "Q og S er fuldt alignet\n";
		
#		my $count_Q_and_S_full_align++;

		#appender unikke protein IDs for Q og S til "Q_and_S_full_align.out" filen 
		open(FH_Q_AND_S_FULL_ALIGN, ">>Q_and_S_full_align.out") or die "cannot open Q_and_S_full_align.out file\n";

		print FH_Q_AND_S_FULL_ALIGN $unique_hash_key,"=>", $$result_hash{$unique_hash_key}[5], "\n";

		close FH_Q_AND_S_FULL_ALIGN;


	} 

	#sender de unikke protein IDs for Q og S, og S forkortelsen til "S_start_trunc.out" filen hvis Subject sekvensen er forkortet i starten af 
	#alignmenten i forhold til Query sekvensen
	elsif (($query_alignment_start_nr = ${$$result_hash{$unique_hash_key}[19]}[0]) > 1 
		&& (($query_alignment_end_nr = ${$$result_hash{$unique_hash_key}[19]}[1]) == $$result_hash{$unique_hash_key}[22]) 
		&& ($subject_alignment_start_nr = ${$$result_hash{$unique_hash_key}[20]}[0]) == 1 
		&& (($subject_alignment_end_nr = ${$$result_hash{$unique_hash_key}[20]}[1]) == $$result_hash{$unique_hash_key}[23])) {


print "S er forkortet i starten\n";
		
#		my $count_Q_start_trunc++;

		#appender unikke protein IDs for Q og S, og forkortelsens længde til "S_start_trunc.out" filen 
		open(FH_S_START_TRUNC, ">>S_start_trunc.out") or die "cannot open S_start_trunc.out file\n";

		print FH_S_START_TRUNC $unique_hash_key,"=>", $$result_hash{$unique_hash_key}[5],":",($query_alignment_start_nr - 1), "\n";

		close FH_S_START_TRUNC;

	} 


	#sender de unikke protein IDs for Q og S, og S forlængelsen til "S_start_extended.out" filen hvis Subject sekvensen er forlænget i starten af 
	#alignmenten i forhold til query sekvensen
	elsif (($query_alignment_start_nr = ${$$result_hash{$unique_hash_key}[19]}[0]) == 1 
		&& (($query_alignment_end_nr = ${$$result_hash{$unique_hash_key}[19]}[1]) == $$result_hash{$unique_hash_key}[22]) 
		&& ($subject_alignment_start_nr = ${$$result_hash{$unique_hash_key}[20]}[0]) > 1 
		&& (($subject_alignment_end_nr = ${$$result_hash{$unique_hash_key}[20]}[1]) == $$result_hash{$unique_hash_key}[23])) {


print "S er forlænget i starten\n";
		
#		my $count_S_start_extented++;

		#appender unikke protein IDs for Q og S, og forlængelsens længde til "S_start_extended.out" filen 
		open(FH_S_START_EXTENDED, ">>S_start_extended.out") or die "cannot open S_start_extended.out file\n";

		print FH_S_START_EXTENDED $unique_hash_key,"=>", $$result_hash{$unique_hash_key}[5],":",($subject_alignment_start_nr - 1), 			
		"\n";

		close FH_S_START_EXTENDED;

	} 

	#sender de unikke protein IDs for Q og S, og længden af S forkortelsen til "S_end_trunc.out" filen hvis Subject sekvensen er forkortet i 		#slutningen af alignmenten i forhold til Query sekvensen
	elsif (($query_alignment_start_nr = ${$$result_hash{$unique_hash_key}[19]}[0]) == 1 
		&& (($query_alignment_end_nr = ${$$result_hash{$unique_hash_key}[19]}[1]) != $$result_hash{$unique_hash_key}[22]) 
		&& ($subject_alignment_start_nr = ${$$result_hash{$unique_hash_key}[20]}[0]) == 1 
		&& (($subject_alignment_end_nr = ${$$result_hash{$unique_hash_key}[20]}[1]) == $$result_hash{$unique_hash_key}[23])) {


print "S er forkortet i enden\n";
		
#		my $count_S_end_trunc++;

		#appender unikke protein IDs for Q og S, og forkortelsens længde til "S_end_trunc.out" fil 
		open(FH_S_END_TRUNC, ">>S_end_trunc.out") or die "cannot open S_end_trunc.out file\n";

		print FH_S_END_TRUNC $unique_hash_key,"=>", $$result_hash{$unique_hash_key}[5],":",

		($$result_hash{$unique_hash_key}[22] - $query_alignment_end_nr), "\n";

		close FH_S_END_TRUNC;

	} 

	#sender de unikke protein IDs for Q og S, og længden af S forlængelsen til "S_end_extented.out" filen hvis Subject sekvensen er forlænget i enden 		#af alignmenten i forhold til query sekvensen
	elsif (($query_alignment_start_nr = ${$$result_hash{$unique_hash_key}[19]}[0]) == 1 
		&& (($query_alignment_end_nr = ${$$result_hash{$unique_hash_key}[19]}[1]) == $$result_hash{$unique_hash_key}[22]) 
		&& ($subject_alignment_start_nr = ${$$result_hash{$unique_hash_key}[20]}[0]) == 1 
		&& (($subject_alignment_end_nr = ${$$result_hash{$unique_hash_key}[20]}[1]) != $$result_hash{$unique_hash_key}[23])) {


print "S er forlænget i enden\n";
		
#		my $count_S_end_extended++;

		#appender unikke protein IDs for Q og S, og forlængelsens længde til "S_end_extended.out" filen 
		open(FH_S_END_EXTENDED, ">>S_end_extended.out") or die "cannot open S_end_extent.out file\n";

		print FH_S_END_EXTENDED $unique_hash_key,"=>", $$result_hash{$unique_hash_key}[5],":",

		$$result_hash{$unique_hash_key}[23] - $subject_alignment_end_nr, "\n";

		close FH_S_END_EXTENDED;

	} 


	#sender de unikke protein IDs for Q og S, og længden af S forkortelsen i starten og enden til "S_start_end_trunc.out" filen hvis Subject 		#sekvensen er forkortet i starten og enden af alignmenten i forhold til query sekvensen
	elsif (($query_alignment_start_nr = ${$$result_hash{$unique_hash_key}[19]}[0]) > 1 
		&& (($query_alignment_end_nr = ${$$result_hash{$unique_hash_key}[19]}[1]) != $$result_hash{$unique_hash_key}[22]) 
		&& ($subject_alignment_start_nr = ${$$result_hash{$unique_hash_key}[20]}[0]) == 1 
		&& (($subject_alignment_end_nr = ${$$result_hash{$unique_hash_key}[20]}[1]) == $$result_hash{$unique_hash_key}[23])) {


print "S er forkortet i starten og i enden\n";
		
#		my $count_S_start_end_trunc++;

		#appender unikke protein IDs for Q og S, og forkortelsernes længde til "S_start_end_trunc.out" fil 
		open(FH_S_START_END_TRUNC, ">>S_start_end_trunc.out") or die "cannot open S_start_end_trunc.out file\n";

		print FH_S_START_END_TRUNC $unique_hash_key,"=>", $$result_hash{$unique_hash_key}[5],":",

		($query_alignment_start_nr - 1), ":",

		($$result_hash{$unique_hash_key}[22] - $query_alignment_end_nr), "\n";

		close FH_S_START_END_TRUNC;

	} 

		
	#sender de unikke protein IDs for Q og S, og længden af S forlængelserne i starten og enden til "S_start_end_extended.out" filen hvis Subject 
	#sekvensen er forlænget i starten og enden af alignmenten i forhold til query sekvensen
	elsif (($query_alignment_start_nr = ${$$result_hash{$unique_hash_key}[19]}[0]) == 1 
		&& (($query_alignment_end_nr = ${$$result_hash{$unique_hash_key}[19]}[1]) == $$result_hash{$unique_hash_key}[22]) 
		&& ($subject_alignment_start_nr = ${$$result_hash{$unique_hash_key}[20]}[0]) > 1 
		&& (($subject_alignment_end_nr = ${$$result_hash{$unique_hash_key}[20]}[1]) != $$result_hash{$unique_hash_key}[23])) {


print "S er forlænget i starten og i enden\n";
		
#		my $count_S_start_end_extended++;

		#appender unikke protein IDs for Q og S, og forlængelsernes længde til "S_start_end_extended.out" fil 
		open(FH_S_START_END_EXTENDED, ">>S_start_end_extended.out") or die "cannot open S_start_end_extended.out file\n";

		print FH_S_START_END_EXTENDED $unique_hash_key,"=>", $$result_hash{$unique_hash_key}[5],":",

		($subject_alignment_start_nr - 1), ":",

		($$result_hash{$unique_hash_key}[23] - $subject_alignment_end_nr), "\n";

		close FH_S_START_END_EXTENDED;

	} 

		
	#sender de unikke protein IDs for Q og S, og længden af S forkortelsen i starten og S forlængelsen i enden til "S_start_trunc_end_extended.out" 	#filen hvis Subject sekvensen er forkortet i starten og forlænget i enden af alignmenten i forhold til query sekvensen
	elsif (($query_alignment_start_nr = ${$$result_hash{$unique_hash_key}[19]}[0]) > 1 
		&& (($query_alignment_end_nr = ${$$result_hash{$unique_hash_key}[19]}[1]) == $$result_hash{$unique_hash_key}[22]) 
		&& ($subject_alignment_start_nr = ${$$result_hash{$unique_hash_key}[20]}[0]) == 1 
		&& (($subject_alignment_end_nr = ${$$result_hash{$unique_hash_key}[20]}[1]) != $$result_hash{$unique_hash_key}[23])) {


print "S er forkortet i starten og forlænget i enden\n";
		
#		my $count_S_start_trunc_end_extended++;

		#appender unikke protein IDs for Q og S, og start forkortelsen og forlængelsens længde i enden til "S_start_trunc_end_extended.out" filen 
		open(FH_S_START_TRUNC_END_EXTENDED, ">>S_start_trunc_end_extended.out") or die "cannot open S_start_trunc_end_extended.out file\n";

		print FH_S_START_TRUNC_END_EXTENDED $unique_hash_key,"=>", $$result_hash{$unique_hash_key}[5],":",

		($query_alignment_start_nr - 1), ":",

		($$result_hash{$unique_hash_key}[23] - $subject_alignment_end_nr), "\n";

		close FH_S_START_TRUNC_END_EXTENDED;

	} 

	#sender de unikke protein IDs for Q og S, og længden af S forlængelsen i starten og S forkortelsen i enden til "S_start_extended_end_trunc.out" 	#filen hvis Subject sekvensen er forlænget i starten og forkortet i enden af alignmenten i forhold til query sekvensen
	elsif (($query_alignment_start_nr = ${$$result_hash{$unique_hash_key}[19]}[0]) == 1 
		&& (($query_alignment_end_nr = ${$$result_hash{$unique_hash_key}[19]}[1]) != $$result_hash{$unique_hash_key}[22]) 
		&& ($subject_alignment_start_nr = ${$$result_hash{$unique_hash_key}[20]}[0]) > 1 
		&& (($subject_alignment_end_nr = ${$$result_hash{$unique_hash_key}[20]}[1]) == $$result_hash{$unique_hash_key}[23])) {


print "S er forlænget i starten og forkortet i enden\n";
		
#		my $count_S_start_extended_end_trunc++;

		#appender unikke protein IDs for Q og S, og start forlængelsen og forkortelsens længde i enden til "S_start_extended_end_trunc.out" filen 
		open(FH_S_START_EXTENDED_END_TRUNC, ">>S_start_extended_end_trunc.out") or die "cannot open S_start_extended_end_trunc.out file\n";

		print FH_S_START_EXTENDED_END_TRUNC $unique_hash_key,"=>", $$result_hash{$unique_hash_key}[5],":",

		($subject_alignment_start_nr - 1), ":",

		($$result_hash{$unique_hash_key}[22] - $query_alignment_end_nr), "\n";

		close FH_S_START_EXTENDED_END_TRUNC;

	} 

}


sub parse_hittet_S_list {	#parser "hittet_S_list.out" filen. Subject IDs der er hittet af en query sekvens gemmes i en liste. Query IDs der har 					#hittet en subject sekvens gemmes også i en liste. Begge lister returnes.

	my @hittet_subject_list = ();
	my @hittet_query_list = ();


	open(FH_hittet_S_list, "hittet_S_list.out");	#åbner "hittet_S_list.out" filen

	my @hittet_S_list = <FH_hittet_S_list>;	#hver linie i "hittet_S_list.out" filen har et Subject ID og et query ID for de sekvenser der er 								#homologe

	foreach (@hittet_S_list) {	
		chomp @hittet_S_list;
print $_,"\n";
		my @list = split(/\t/, $_);	#subject og query ID'erne separeres til elementer i en liste

		push(@hittet_subject_list, $list[0]);	#subject ID pushes ind i liste
		push(@hittet_query_list, $list[1]);		#query ID pushes ind i liste

	}

print "i sub ",$hittet_subject_list[0],"\n";
print "i sub ",$hittet_query_list[0],"\n";

	return (\@hittet_subject_list, \@hittet_query_list);	

}


sub compare_lists {	#sammenligner alle elementer i liste 1 og 2 med hinanden og putter de elementer der er tilstede i list1 men ikke i list2 i list3
			#og returnere denne


	my ($list1, $list2) = @_;
	my @list3 = ();

print "i compare sub: ", @$list1[0],"\n"; 			
print "i compare sub: ", @$list2[0],"\n";

	
	foreach my $ele (@$list1) {

		unless (grep $ele eq $_, @$list2) {	

		push(@list3,$ele);

		}
	}

return \@list3

}