//LE API JAVA SONO DISPONIBILI A QUESTO LINK: /usr/share/doc/openjdk-7-doc/
//http://profs.sci.univr.it/~farinelli/courses/algBio/algBio.html

import java.util.*;

public class ProvaParziale1516{
  
  
  private static class FastaSeq implements Comparable<FastaSeq>{
    public String nome; //descrizione della sequenza
    public String seq; //sequenza di dati

	/**
	* Costruttore con tre argomenti
	*
	* @param n nome da assegnare al taxi
	* @param v numero di ore da assegnare
	* @param f valore da assegnare allo stato del taxi (true = libero)
	*/
    public FastaSeq(String n, String s){
      nome = n;
      seq = s;
    }

    public String toString(){
      return "("+nome+","+seq+")";
    }

	/**
	* ritorna la percentuale AT della stringa
	* @return la percentuale AT, zero se la stringa contiene zero caratteri.
	*/
	public double getATPerc(){
		int count = 0;
		for (int i=0; i<seq.length(); i++){
			if (seq.charAt(i)=='A' || seq.charAt(i) == 'T'){
				count++;
			}
		}
		return seq.length()>0?((double)count)/seq.length()*100:0.;
	}

	/**
	* @return la lunghezza della sequenza
	*/	
	public int getLength(){
		return seq.length(); 
	}

    /**
    * Implementa il metodo equals per oggetti di tipo FastaSeq.
    * Due oggetti Fasta sono uguali se hanno la stessa descrizione (nome), 
	* e la staessa sequenza (seq)
    *
    * @param obj oggetto con cui comparare l'oggetto di invocazione
    * @return true se i due oggetti sono uguali false altrimenti. 
    */
    public boolean equals(Object obj){
      if (obj instanceof FastaSeq){
	  		FastaSeq s = (FastaSeq) obj;
			return (nome.equals(s.nome) && seq.equals(s.seq));
      }
      return false;	    
    }

   /**
    * Implementa il metodo compareTo per oggetti di tipo FastaSeq. (25)
    * Una FastaSeq x e' maggiore/minore di un FastaSeq y se il campo descrizione (nome) di x e'
	* maggiore/minore della descrione (nome) di y (secondo l'ordine lessicografico definito sulle stringhe).
 	* Se i nomi sono uguali, x e' maggiore/minore di y se il campo sequenza (seq) di x e'
	* maggiore/minore del campo sequenza (seq) di y (secondo l'ordine lessicografico definito sulle stringhe). Altrimenti le FastaSeq sono uguali. 
	* Ad esempio se le FastaSeq sono fs1=<">n1","CCGAT"> e fs2=<">n2","AAGAT"> 
	* il metodo dovrebbe ritornare un valore positivo (fs1 < fs2). 
	* Se le FastaSeq sono fs1=<">n1","CCGAT"> e fs3=<">n1","AAGAT"> 
	* il metodo dovrebbe ritornare un valore positivo (fs1 > fs3). 
	* Se le FastaSeq sono fs1=<">n1","CCGAT"> e fs4=<">n1","CCGAT"> 
	* il metodo dovrebbe ritornare 0 (fs1 = fs3). 
   *
    * @param fs FastaSeq da comparare
    * @return un intero positivo/negativo/nullo se l'oggetto di invocazione e' maggiore/minora/uguale al parametro t
    */
    public int compareTo(FastaSeq fs){
		System.out.println("metodo da implementare");
		return -1;	
    }
 } 

  
  /**
  * date due liste di interi: seq e subseq, contare il numero di occorrenze di subseq in seq (30 Punti). 
  * Ad esempio date le liste <1,5,2,1,5,4>, <1,5> il metodo ritorna 2.
  * Date le liste <1,5,2,1,5,4>, <1,5,4> il metodo ritorna 1.
  * Date le liste <1,5,2,1,5,4>, <1,2,4> il metodo ritorna 0.
  *
  *  @param seq lista di interi
  *  @param subseq lista di interi
  *  @return un intero che rappresneta il numero di occorrenze di subseq in seq
  */	
  public static int overlapCount(List<Integer> seq, List<Integer> subseq){
		System.out.println("metodo da implementare");
		return -1;	
  }
  
 
/**
  * Date due liste di FastaSeq restituisce l'insieme degli elementi comuni
  * alle due liste (Punti 20).
  *	
  * @return l'insieme di elementi in comune tra le due liste
  * @param l1 la prima lista
  * @param l2 la seconda lista
  */
  public static Set<FastaSeq> elementiComuni(List<FastaSeq> l1, List<FastaSeq> l2){
		System.out.println("metodo da implementare");
		return null;	
  } 
  
  /**
  * Dato un insieme di FastaSeq, il metodo restituisce la FastaSeq piu' lunga che ha una percentuale AT pari almeno a percmin. Se due FastaSeq hanno la stessa lunghezza massima ritornare una qualsiasi delle FastaSeq. (punti 25)
  * Si assuma di non conoscere il range dei valori delle lunghezze. Se l'insieme e' vuoto o se non ci sono valori che soddifino la soglia il metodo ritorna null.
  * Ad esempio se l'insieme	di FastaSeq e' [(>n1,ATCGA),(>n2,ATCGGCCCCCCC),(>n3,ATCGATACCCA),(>n4,ATCGATAT)] il metodo chiamato con percmin = 0 ritorna n2.
  * Il metodo chiamato con percmin = 30 ritorna n3. 
  * Il metodo chiamato con percmin = 60 ritorna n4
  *
  * @param fs insieme di FastaSeq da considerare 
  * @param percmin percentuale minima di AT
  * @return la FastaSeq piu' lunga con percentuale AT pari almeno a percmin
  */
  public static FastaSeq longestFasta(Set<FastaSeq> fs, double percmin){
		System.out.println("metodo da implementare");
		return null;	
  }



  public static void main(String[] args){

 
    System.out.println("**********TEST compareTo() per FastaSeq*************");
    FastaSeq fs1 = new FastaSeq(">n1","CCGAT");
    FastaSeq fs2 = new FastaSeq(">n2","AAGAT");
    FastaSeq fs3 = new FastaSeq(">n1","AAGAT");
    FastaSeq fs4 = new FastaSeq(">n1","CCGAT");

    System.out.println("FastaSeq "+fs1+" comparato a "+fs2+"  Risultato: "+fs1.compareTo(fs2)+" dovrebbe essere (negativo)");
    System.out.println("FastaSeq "+fs1+" comparato a "+fs3+"  Risultato: "+fs1.compareTo(fs3)+" dovrebbe essere (positivo)");
    System.out.println("FastaSeq "+fs1+" comparato a  "+fs4+" Risultato: "+fs1.compareTo(fs4)+" dovrebbe essere (zero)");

    
    System.out.println("**********TEST overlapCount()*************");

    List<Integer> l1 = new ArrayList<Integer>();
    List<Integer> l2 = new ArrayList<Integer>();
    List<Integer> l3 = new ArrayList<Integer>();
    List<Integer> l4 = new ArrayList<Integer>();
    
    l1.add(1); l1.add(5); l1.add(2); l1.add(1); l1.add(5); l1.add(4); 
    l2.add(1); l2.add(5); 
    l3.add(1); l3.add(5); l3.add(4); 
    l4.add(1); l4.add(2); l4.add(4); 

    System.out.println("numero di occorrenze per =  "+l1+" e "+l2+" = "+overlapCount(l1,l2)+" [dovrebbe essere 2]");
    System.out.println("numero di occorrenze per =  "+l1+" e "+l3+" = "+overlapCount(l1,l3)+" [dovrebbe essere 1]");
    System.out.println("numero di occorrenze per =  "+l1+" e "+l4+" = "+overlapCount(l1,l4)+" [dovrebbe essere 0]");
      

    System.out.println("**********TEST elementiComuni()*************");

    List<FastaSeq> lf1 = new LinkedList<FastaSeq>();
    List<FastaSeq> lf2 = new LinkedList<FastaSeq>();
    List<FastaSeq> lf3 = new LinkedList<FastaSeq>();

	FastaSeq e1 = new FastaSeq(">n1","ATCGA");
	FastaSeq e2 = new FastaSeq(">n2","ATCGGCCCCCCC");
	FastaSeq e3 = new FastaSeq(">n3","ATCGATACCCA");
	FastaSeq e4 = new FastaSeq(">n4","ATCGATAT");
	
	lf1.add(e1); lf1.add(e2); lf1.add(e3); lf1.add(e3);     
	lf2.add(e2); lf2.add(e3); lf2.add(e4); lf2.add(e4);         
    
    System.out.println("Liste: lf1 = "+lf1+" lf2 = "+ lf2+"\n Insieme di elementi in comune = " + elementiComuni(lf1,lf2)+ " [dovrebbe essere [(n2,ATCGGCCCCCCC),(n3,ATCGATACCCA)]]");

    System.out.println("Liste: lf1 = "+lf1+" lf3 = "+ lf3+"\n Insieme di elementi in comune = " + elementiComuni(lf1,lf3)+ " [dovrebbe essere []]");

    
    System.out.println("**********TEST longestFasta()*************");

    Set<FastaSeq> fss = new HashSet<FastaSeq>();
	FastaSeq n1 = new FastaSeq(">n1","ATCGA");
	FastaSeq n2 = new FastaSeq(">n2","ATCGGCCCCCCC");
	FastaSeq n3 = new FastaSeq(">n3","ATCGATACCCA");
	FastaSeq n4 = new FastaSeq(">n4","ATCGATAT");
     
	fss.add(n1);
    fss.add(n2);
    fss.add(n3);
    fss.add(n4);
    
    System.out.println("Insieme di fasta "+fss);
    System.out.println("fasta piu' lunga con perc. AT di 0 : "+longestFasta(fss,0.)+" [dovrebbe essere n2]");

    System.out.println("fasta piu' lunga con perc. AT di 30 : "+longestFasta(fss,30.)+" [dovrebbe essere n3]");

    System.out.println("fasta piu' lunga con perc. AT di 60 : "+longestFasta(fss,60.)+" [dovrebbe essere n4]");

       
    
  }

}