#!/usr/bin/perl -w

use strict;
use warnings;

### Aqui tenim el programa, el qual s'executara apartir d'un document executor en bash. Aquest es trobara en el mateix directori que el document bash i que el document proteines multifasta, no cal res més.

###### PASSAR DE MULTIFASTA A DIVERSOS FASTA ######
print "Extreiem les proteines del document multifasta\n";

my $proteines_multifasta = 'proteines_multifasta.fa';
my @vector; # Vector en el qual emmagatzarem cada linia del nostre document multifasta
my @n; # Vector en el qual emmagatzamem les primeres linies de cada proteina, les que començen amb >, per tal de donar nom al document
my $nomfitxer;


my $comptador = 1; #comptador que evita que es tanqui un document la primera vegada que entrem al bucle el qual encara no hem obert, i si ens tanqui els documenta en la resta de voltes

open (FASTA, $proteines_multifasta)|| die ("can't open $proteines_multifasta"); # Obres el document multifasta sota el head FASTA
system ("mkdir ./selenoproteines"); # Accio de crear una carpeta al path en el qual es troba el progarama que s'anomenara selenoproteines


while (<FASTA>) #Mentre que hi hagin linies al document, el bucle anira fent
{
 @vector = split (//,$_); # Emmagatzemar cada linia en questio en el vector, separant per caracters. Per tant en la primera línia el símbol > quedarà en la posició 0 del vector
 #print " $vector[0] \n";
 if($vector[0] eq ">") # Amb aquest if només hi entrarem si ens trobem en la primera linia de un sequencia, per aixo obrirem un document
 {
   if ($comptador != 1) # Aquest if el fem servir per poder tencar el documents un cop hem arribat a una nova sequencia, i ho posem aixi per que es la manera per evitar tencar un document inexistent en el cas del primer
   {
	   close OUTPUT; #Tanquem el document
   }
   $comptador = $comptador + 1;
   @n = split (" ", $_); #guardem la línia en el vector @n separant per espais. Per tant, el identificador de la proteina (SPP*) quedara en la posició 0
   $nomfitxer = substr ($n[0], 1); # Aquí escollim la primera posicio del vector n (que es la primera linia de cada proteina) que sera el nom de la proteina, i eliminem la primera posicio que sera el >
   #print "$nomfitxer\n";
   system ("mkdir ./selenoproteines/$nomfitxer"); # Accio de crear una carpeta al home que s'anomenara com la proteina i on guardarem la proteina corresponent
   system ("mkdir ./selenoproteines/$nomfitxer/exonerate"); # A continuació anem fent diverses carpetes dins de la carpeta de cada proteina. Cadascuna d'elles per emmagatzemar un futur document.
   system ("mkdir ./selenoproteines/$nomfitxer/exonerate/cDNA");
   system ("mkdir ./selenoproteines/$nomfitxer/exonerate/exons");
   system ("mkdir ./selenoproteines/$nomfitxer/exonerate/genspredits");
   system ("mkdir ./selenoproteines/$nomfitxer/exonerate/protpredites");
   system ("mkdir ./selenoproteines/$nomfitxer/exonerate/protcanviX_U");
   system ("mkdir ./selenoproteines/$nomfitxer/genewise");
   system ("mkdir ./selenoproteines/$nomfitxer/Tcoffee");
   system ("mkdir ./selenoproteines/$nomfitxer/Tcoffee/exonerate");
   system ("mkdir ./selenoproteines/$nomfitxer/Tcoffee/genewise");
   
   open (OUTPUT, ">", "./selenoproteines/$nomfitxer/$nomfitxer.fa"); # obrir documentfasta sota el nom de la variable i sota un head OUTPUT (que no variara en tot el programa, nomes variara el nom del fitxer)
 }
 print OUTPUT $_; # aquest print va incloent les linies d'aminoacids dins del document fasta fins que es torna a trobar un >
}

	
###### CANVIAR LES U PER X ######
print "Executem un canvi de Us per Xs en les proteines\n";

my $dirname = './selenoproteines'; #Li donem un Path al dirname, el qual sera la carpeta selenoproteines, on tenim totes les carpetes de les proteines i les proteines obtingudes del pas anterior
opendir(DIR, $dirname) or die "Could not open $dirname\n"; #Al obrir el dirname, estem obrint la carpeta del nostre Path, dins de la qual tenim els documents amb els que volem treballar

while (my $protein = readdir(DIR)) #buscar les linies que no comencin amb > i canviar U per X i %, @ i # per res
{
  #print "$protein\n";
  next if $protein =~ /^\./;
  open (FILE, "$dirname/$protein/$protein.fa") || die ("can't open $protein"); #Aqui asignem la variable global filename als documents de dins de la carpeta i els obrim
  while (<FILE>)
  {
    my @vector = split (//,$_); # Es fa un vector de cada linia, separant per lletres. 
    if ($vector[0] eq ">") # Estarem a la primera linia del document i ho aprofitarem per donar el nom al nou document que generem
    {
	  open (OUTPUT, ">", "$dirname/$protein/$protein.U_X.fa");
      print OUTPUT $_;
    } 
 # Emmagatzemar cada linia en questio en el vector
    if ($vector[0] ne ">") # Entrarem en aquest if quan no estiguem a la primera linia del doc, per tant, quan ja estem llegint la sequencia de la proteina. Aqui es on volem canviar les U.
    { 
       #print $_;      
       my $linia = $_; # Declares una variable que sera igual a la linia del document
       $linia =~ s/U/X/; # Si ens trobem una U la canviem per una X
       $linia =~ s/\%//; # Si ens trobem un %, el borrem
       #$linia =~ s/\%%//;# Aixo ho fem perque vam veure que dos % seguits no els borrava (no sabem si funcionara, CAL REVISAR)
       $linia =~ s/\@//;# Si ens trobem una arrova, la borrem
       $linia =~ s/\#//;# Si ens trobem una almoadilla, la borrem
       print OUTPUT "$linia"; #La línia modificada es printa sobre el document, havent canviat tots els elements mencionats previament
	 }
  }
  close OUTPUT; # Tenquem el fitxer, per poder-ne obrir un altre
}
closedir(DIR);# Un cop finalitzat el bucle, tanquem la carpeta en la que treballavem.

print "Ta to canviao\n";

#### TBLASTN #### 
print "Començem el tblast\n";

opendir(DIR, $dirname) or die "Could not open $dirname\n";# Obrim de nou el directori (que serà selenoproteines, ja que esta delcarat a dalt de tot)

while (my $protein = readdir(DIR)) # Amb aquest while li diem al programa que mentre que hi hagin elements dins de la carpeta selenoproteines fem aquesta acció. En concret, dins de selenoproteines tenim 1 carptea per cada proteina, per tant, executarà el blast un cop per cada proteina
{
  next if $protein =~ /^\./; #Aquesta comanda serveix per ignorar els fitxers ocults. Literalment saltem al fitxer seguent si ens trobem un fitxer ocult.
  my $blast = "tblastn -query $dirname/$protein/$protein.U_X.fa -db /cursos/20428/BI/genomes/2016/Neotoma_lepida/genome.fa -evalue 0.01 -outfmt 7 -out $dirname/$protein/$protein.blast.fa"; # Executem el blast per el document que volem i per hits amb valor d'e menors a 0,01 i printant-ho en una taula (podem intantar fer-ho amb -outfmt 6 que nomes ens treu la taula)
  system($blast); # El system executa la comanda de blast com si del shell es tractes.
}
print "Blast finalitzat\n";

#### PARSEGEM EL BLAST #####

print "Començem a parsejar el blast\n";

opendir(DIR, $dirname) or die "Could not open $dirname\n"; # Tornem a obrir la carpeta selenoproteines

#Declarem una serie de varialbes que pendran sentit més avall.
my $contig; 
my $maxim;
my $minim;
my $contiganterior = 0;# Fem servir aquesta variable inicialitzada com a 0, per acumular el contig. La cosa es que nosaltres només voldrem fer el fastasubseq un cop estiguem segurs que el contig seguent no és igual al acutal. Però no hi ha manera de fer això sense passar de linia. Per això guardem el nom del contig anterior en aquesta variable i executem el fasta subseq una volta desprès del que tocaria

#variables per a fastasubseq
my $startfastasubseq; # Posició inicial pel fasta subseq
my $length; # Llargada del subseq
my $llargadacontiganterior;
my @contiganterior;
my $posicio;
my $llargada;
my $end;
my $start;
my $protein;
my @line;
my $fastalength;
my @llargada;
my @llarganterior;

while (my $protein = readdir(DIR)) #Ens mantindrem dins del bucle sempre que hi hagi carpetes dins de selenoproteines
{
	next if $protein =~ /^\./; #Altre cop ignorem els fitxers ocults
		
	open (FILE, "$dirname/$protein/$protein.blast.fa") || die ("can't open $dirname/$protein"); #Obrim el blast de dins de cada carpeta (un per volta), osigui el blast de cada proteina
	print "Processant proteina: ",$protein,"\n";
	while (<FILE>)
	{	#es parseja el primer fitxer
		
		if (grep(!/#/, $_)) #Com que en el blast en surten les primeres linies que no volem aprofitar i aquestes començen amb #, amb aquest if, fem que nomes entrin aquelles linies que no començen per #.
		{
			my @line = split (" ", $_); #Emmagatzamem cada línia de la taula del blast en aquest vector, separant per espais. Per tant cada posició del vector serà una columna de la taula.
	  		$contig = $line[1]; # A la columna 2 hi ha el nom del contig
    		$protein = $line[0];# A la columna 1 hi ha el nom de la proteina.
			
			#print "$contig\n";
			my $fetch = "fastafetch /cursos/20428/BI/genomes/2016/Neotoma_lepida/genome.fa /cursos/20428/BI/genomes/2016/Neotoma_lepida/genome.index '$contig' > $dirname/$protein/$protein" . "_" . "$contig.fa"; # Apliquem el fastafetch sobre el contig ($contig), així obtenim un document amb el contig a partir del genoma i del index. 
       		system($fetch);# Com sempre el system executa la comanda guardada a la variable.

			$start = $line[8]; #Recordem que les posicions incials i finals de la sequencia es troben en les columnes 9 i 10 respectivament. Axiò es el que guardem en aquestes variables.
    		$end = $line[9];

			if ($start > $end) # Aquest if, ens diu que si el start es més gran que l'end (i per tant, si la es troba a la cadena reverse), que es capgirin els valors.
			{
				$start = $line [9];
				$end = $line [8];
     	  	}
			

			# Aqui farem el fastasubseq en si, per el contig anterior, sempre i quan no sigui igual al contig actual o que no sigui la primera linia del blast que llegim (ja que no sabriem si el seguent hit serà al mateix contig o no). Per tant, en aquesta part treballarem amb la variable $contiganterior, ja que totes les accions ens interesa fer-la sobre el contig anterior.
			if ($contiganterior ne $contig && $contiganterior ne 0)
			{
				print "$contig\n";
				print "$contiganterior\n";
				#print "$minim\n";
				#print "$maxim\n";
				
				$startfastasubseq = $minim - 50000; #Agafem el minim, que sera la posició incial per tots els hits d'un contig, i li restem 50 mil
				#print "$startfastasubseq\n";
		  		if ($startfastasubseq < 0) # Amb aquest if, estem dient que si el nostre start del fasta subseq es menor que 0, establim el punt inicial pel fasta subseq com a 0.
		  		{
		    			$startfastasubseq = 0;
		  		}
		  		#print "$startfastasubseq\n";
				$length = $maxim + 50000 - $startfastasubseq;# Fem la llargada del contig pel fastasubseq. Per tant, diem que sera el maxim (posició final per tots els hits d'un contig) més 50 mil. I això li restem el punt incial, per tenir la llargada ($length).
				$fastalength = "fastalength $dirname/$protein/${protein}_${contiganterior}.fa"; # Aquesta funció ens serveix per determinar la llargada d'un document fasta (per tant, no et conta la primera línia).
				@llargada = qx/$fastalength/; # Aquí enlloc de fer un system fem sevir el qx, el qual enlloc de nomes executar-ho, ens permet guardar el valor en un vector. (no nomès printa el número, també printa el nom del contig)
				@llarganterior = split (" ", $llargada[0]); # Com que en la posició 0 del vector llargada ens guardarà el printat pel qx i no sols hi ha el número, ens interesa extreure el número. Per això fem un vector fent un split de la posició 0 del vector @llargada.
				$llargadacontiganterior = $llarganterior[0]; # Com que el número quedarà en la primera posició del vector, guardem aquest valor en la variable $llargadacontiganterior. Així podrem comparar aquesta llargada amb el $length que li hem calculat anteriorment. 
				print "Llargada del contig: ",$llargadacontiganterior,"\n";
				#print "Primer",$length,"\n";
					if ($llargadacontiganterior < ($startfastasubseq + $length)) # En aquest if, el que fem es comparar la llargada real del contig amb la llargada que calculem nosaltres pel fastasubseq ($length + $startfastasubseq -- ho sumem perque ens interessa veure la llargada total--). Si el nostre calcul tingues una llargada major que la del contig, la nostra $length pel fastasubseq passaria a ser la llargaria del contig. 
		     		{
						$length = $llargadacontiganterior - $startfastasubseq;
		     		}
		     	print "Llargada sub seq: ",$length,"\n";
				my $subseq = "fastasubseq $dirname/$protein/${protein}_${contiganterior}.fa $startfastasubseq $length > $dirname/$protein/${protein}_${contiganterior}.subseq.fa"; # Ara apliquem el fastasubseq sobre el contig d'interès, aplicant el punt de començament ($startfastasubseq) i la llargada determinada ($length).
				system ($subseq);  #executem la funció subseq
			}
			
			# Aqui ajustem el maxim i el minim per el contig amb el que estem treballant, no el contig anterior. Per tant, això encaixa amb el que hi havia abans del fastasubseq.
			
			if ($contiganterior eq 0 || $contiganterior ne $contig) # En aquest if nomès hi entrarem si el contiganterior és 0 (per tant, quan estiguem llegint la primer línia) o quan el contiganterior no sigui igual al actual. Dins d'aquest canviarem el valor de $contiganterior per el contig acutal, a més a més d'ajustar els valor de màxim i mínim. 
			{ 
			 	$contiganterior = $contig;
			 	$maxim = $end;
			 	$minim = $start;
	  	   	}
		  	else # Per tant, aquí nomès entrarem en cas de que el contiganterior ($contiganterior) sigui igual que el contig actual ($contig). I aquí el que farem és reajustar els valors del màxim (punt final del subseq) i mínim (punt inicial del subseq) en base als start i end del nou hit del mateix contig. 
		  	{
			  	if ($end > $maxim) # Si el final del nou hit és més gran que el màxim ja establert, voldrà dir que hem d'allargar el màxim del subseq. Per això fem que ara el màxim prengui el valor de end.
			  	{
			    	$maxim = $end;
			  	}
			  	if ($start < $minim) # Si el principi del nou hit és més petit que el mínim ja establert, voldrà dir que hem d'allargar el mínim del subseq. Per això fem que ara el mínim prengui el valor de start.
			  	{
			    	$minim = $start;
			  	}
		   	}
					
		} 
	}
	#A continuació tenim repetit tot el códig per a fer el fasta subseq. Per tant, els comentaris serien els mateixos que abans. Perque el repeteixo aqui fora del bucle? Doncs, perque com que estem treballant amb el contig anterior, al sortir del bucle (perque s'han acabat les línies del document de blast) no fariem els fastasubseq del últim contig. Així doncs posem aquesta part de codig perque al sortir del bucle executara el fasta subseq pel últim contig. 
	$startfastasubseq = $minim - 50000;
	#print "$startfastasubseq\n";
	if ($startfastasubseq < 0)
	{
			$startfastasubseq = 0;
	}
	#print "$startfastasubseq\n";
	$length = $maxim + 50000 - $startfastasubseq;
	$fastalength = "fastalength $dirname/$protein/${protein}_${contiganterior}.fa";
	@llargada = qx/$fastalength/;
	@llarganterior = split (" ", $llargada[0]);
	$llargadacontiganterior = $llarganterior[0];
	print "Llargada del contig: ",$llargadacontiganterior,"\n";
	#print "Primer",$length,"\n";
		if ($llargadacontiganterior < ($startfastasubseq + $length))
		{
			$length = $llargadacontiganterior - $startfastasubseq;
		}
	print "Llargada sub seq: ",$length,"\n";
	my $subseq = "fastasubseq $dirname/$protein/${protein}_${contiganterior}.fa $startfastasubseq $length > $dirname/$protein/${protein}_${contiganterior}.subseq.fa";
	system ($subseq);
	close(FILE); # Tanquem el document de blast
}

print "Parseig finalitzat !!\n";

#### EXONERATE, EGREP, FASTAGFF, FASTATRANSLATE I TCOFFEE ####

# En aquesta part del programa, executarem proteina per proteina (més ben dit contig per contig), totes les accions anomenades en el títol. 
print "Començem l' exonerate\n";

my $dirname = "./selenoproteines";
my $comptador = 0;
my $exonername;
my $exonname;
my @nomexoner;
my $cDNAname;
my $translate;
my $canviu;
my $alineament;
my $gwise;
my @sentit;
my $tcadena;

opendir(DIR, $dirname) or die "Could not open $dirname\n"; #Obrim la carpeta de selenoproteines

while (my $protein = readdir(DIR)) # Mentre que hi hagin carpetes dins de la carpeta selenoproteines anirem fent les accions següents.
{
	next if $protein =~ /^\./; # Ens saltem els documents/carpetes ocults/es
	opendir (PROT, "$dirname/$protein") or die "Could not open $protein\n"; #obrim el primer directori, osigui la primera carpeta 
	$comptador = 0;
	
	while (my $filename = readdir (PROT)) # Amb aquest while, mentre que hi hagi documents dins de la carpeta fem les accions següents.
	{
		next if $filename =~ /^\./; # Obiem els fitxer ocults
		print "$filename\n";
		if (grep(/\.subseq.fa/, $filename)) # Nomes entrarem en aquest if (i per tant, farem les accions de Exonerate, egrep,...) si el document te extensió subseq.fa. Així doncs, nomès farem les accions següents pels subseqs.
		{
			$comptador = $comptador + 1;#comptador random, no té cap importancia dins del programa.
			print "$comptador\n";
			print "Treballarem sobre aquest doc: ",$filename,"\n";
			#### EXONERATE ####
			@nomexoner = split (/\./, "$filename"); # El filename sera el nom del document, per tant, SPP0000xxxx_LZxxxxx.subseq.fa. Agafem aquest nom i el coloquem dins d'un vector separant per punts. Així el que ens interessa canviar són les dues últimes posicions segons el documents.  
			print "Aquest es el vector: ",@nomexoner,"\n";
			$nomexoner[scalar (@nomexoner) - 2] = "exonerate";# Canviem la penúltima posició del vector per el nom exonerate.
			$nomexoner[scalar (@nomexoner) - 1] = "gff";# Canviem la última posició del vector per gff. Recordar que la primera posició del vector és 0, per això li hem de restar 1 a la llargada del vector, per obtenir la posició del vector.
			$exonername = join (".", @nomexoner); # Dins de la variable $exonername juntem els diferents elements de vector a través de punts. Així doncs, en aquesta variable englobem el nom del document del exonerate
			print "Nom exonerate: ",$exonername,"\n";
			
			my $exonerate = ("exonerate -m p2g --exhaustive yes --showtargetgff -q '$dirname/$protein/$protein.U_X.fa' -t $dirname/$protein/$filename > $dirname/$protein/exonerate/genspredits/$exonername"); # Portem a terme el exonerate, a partir de les proteines model canviades i el subseq.
			system ($exonerate);
			
			#### EGREP ####
			$nomexoner[scalar (@nomexoner) - 2] = "exon";# Aprofitem el vector @nomexoner, per anar canviant els noms dels documents. En aquest cas estem canviant exonerate per exon. Això es seguiex aplicant en la resta del programa.  
			$exonname = join (".", @nomexoner);# Es fa exactament el mateix que en el exonerate. Juntem les components del vector a travès de punts, per obtenir el nom del document que generarem. Això es segueix aplicant en la resta del programa. 
			print "Nom exo: ",$exonname,"\n";
			
			my $exon = ("egrep -w exon $dirname/$protein/exonerate/genspredits/$exonername > $dirname/$protein/exonerate/exons/$exonname"); # Apliquem el egrep sobre l'exonerate per tal de seleccionar nomès els exons del exonerate.
			system ($exon);
			
			#### FASTASEQFROM GFF ####
			$nomexoner[scalar (@nomexoner) - 2] = "cDNA";
			$nomexoner[scalar (@nomexoner) - 1] = "fa";
			$cDNAname = join (".", @nomexoner);
			
			my $fastaseqfrom = ("fastaseqfromGFF.pl $dirname/$protein/$filename $dirname/$protein/exonerate/exons/$exonname > $dirname/$protein/exonerate/cDNA/$cDNAname"); # En aquesta funció, a partir dels exons obtinguts, generarem un cDNA.
			system ($fastaseqfrom);
			
			#### FASTATRANSLATE ####
			$nomexoner[scalar (@nomexoner) - 2] = "protpred";
			$translate = join (".", @nomexoner);
			
			my $fastatranslate = ("fastatranslate -f $dirname/$protein/exonerate/cDNA/$cDNAname -F 1 > $dirname/$protein/exonerate/protpredites/$translate"); # Apliquem aquesta funció per traduir el cDNa obtingut anteriorment, obtenint així una proteïna predita per el nostre organisme. Aquesta proteina és possible que contingui alguna selenocisteina. Aquesta es traduirà com *, ja que vindrà de un codo stop. 
			system ($fastatranslate);
			
			#### CANVI DE LES X PER U #### En aquesta part del programa el que farem és canviar els * generats pel fastatranslate per Us, per poder fer el T-coffee
			$nomexoner[scalar (@nomexoner) - 2] = "protcanviu";
			$canviu = join (".", @nomexoner);
			
			open (CANVIU, "$dirname/$protein/exonerate/protpredites/$translate") || die ("can't open $dirname/$protein/exonerate/protpredites/$translate"); #Obrim un document sota el head de CANVI, el qual sera el document generat pel fastatranslate (el que conte la proteina predita)
			
			open(OUTPUT, ">", "$dirname/$protein/exonerate/protcanviX_U/$canviu"); # Creem un document en la carpeta procanviX_U sota el nom de $canviu. I en aquest hi printarem la proteina canviada. 
			while (<CANVIU>)# mentre hi hagi linies en el document del translate, anirem fent.
			{
				my @vector = split (//,$_); # Guardem la línia en un vector, el qual separarem per caracters.
				if ($vector[0] eq ">") # Si la primera posició del vector (osigui la línia) és un >, printarem directament la linia sense fer el canvi, ja que es la primera linia del document.
				{
					print OUTPUT $_;
				}
				if ($vector[0] ne ">")# Si la primera posició de la línia no és un > vol dir que no estem a la primera línia, i per tant, que estem dins de la seqüència de la proteïna. Així doncs si la línia té un * ho canviarem per una U i printarem la linia en el document nou.
				{
					my $linia = $_;
					$linia =~ tr/\*/U/; #Canviar els possibles * per Us
					print OUTPUT "$linia";
				}	
			}
			close OUTPUT; #Tanquem el document.
			
			#### T-COFFEE PER EXONERATE ####
			$nomexoner[scalar (@nomexoner) - 2] = "tcalineament";
			$alineament = join (".", @nomexoner);
						
			my $etcoffee = ("t_coffee '$dirname/$protein/$protein.U_X.fa' $dirname/$protein/exonerate/protcanviX_U/$canviu > $dirname/$protein/Tcoffee/exonerate/$alineament"); # Fem el T-coffee sobre la proteina del model canviada i la nostre proteina amb Us. Es generà un alineament.
			system ($etcoffee);
			
			#### GENEWISE #### Per fer el genewise, hem de saber si el gen es troba a la cadena reversa o a la forward, per poder discriminar entre genewise amb o sense trev. Aquesta informació la trobem al document dels exons, on ens surt un simbol + o - segons en la cadena que es trobi. 
			$nomexoner[scalar (@nomexoner) - 2] = "genewise";
			$gwise = join (".", @nomexoner);
			
			open (GENE, "$dirname/$protein/exonerate/exons/$exonname") || die ("can't open $dirname/$protein/exonerate/exons/$exonname"); # Obrim el document dels exons corresponent
			
			while (<GENE>) #Mentre que hi hagi linies anem fent. 
			{
				#print "$_\n";
				@sentit = split (/	/,$_); #Fiquem la línia en un vector, separant per tabulacions. 
				#print "@sentit\n";
				$tcadena = $sentit[6]; # Ens interessa la 7 posició, que es on trobarem els símbols + o -.
			}
			close (GENE); # Tanquem el document.
			print "$tcadena\n";
								
			if ($tcadena eq "+") # Si està a la cadena forward (per tant $tcadena és +). Aplicarem el genewise sense -trev.
			{
				print "El gen es troba a la cadena forward\n";
				my $genewise = ("genewise -pep -pretty -cdna -gff '$dirname/$protein/$protein.fa' $dirname/$protein/$filename > $dirname/$protein/genewise/$gwise"); 
				system ($genewise);
			}
			if ($tcadena eq "-") # Si està a la cadena reverse (per tant $tcadena és -). Aplicarem el genwise amb -trev.
			{
				print "El gen es troba a la cadena reverse\n";
				my $genewise = ("genewise -pep -pretty -trev -cdna -gff '$dirname/$protein/$protein.fa' $dirname/$protein/$filename > $dirname/$protein/genewise/$gwise"); 
				system ($genewise);
			}
		}
	}
	closedir (PROT); # Tanquem la carpeta de la proteina. Per passar a la següent o per finalitzar
}
closedir (DIR); # Tanquem la carpeta de selenoproteines.

#### S'ha acabat el programa !!!!
