import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.swing.table.DefaultTableModel;

public class Two_cond2ttest extends Thread {
Thread t;
String[] gene_id;
String[][] exp;
public	HashMap<String,ArrayList<Double>> expt = new HashMap<String,ArrayList<Double>>();
public	HashMap<String,Integer> genm = new HashMap<String,Integer>();
public	HashMap<String,Integer> genm2 = new HashMap<String,Integer>();
public	HashMap<String,ArrayList<Integer>> stabw = new HashMap<String,ArrayList<Integer>>();
public	HashMap<String,ArrayList<Integer>> stabw2 = new HashMap<String,ArrayList<Integer>>();
String dat1, dat2, dat3, dat1b, dat2b, dat3b, spikein, exp1, exp2;

public Two_cond2ttest(String dat1, String dat2, String dat3, String dat1b, String dat2b, String dat3b, String spikein)
{
	this.dat1 = dat1; this.dat2 = dat2; this.dat3 = dat3; this.dat1b = dat1b; this.dat2b = dat2b; this.dat3b = dat3b;
	this.spikein = spikein;
}
// Start für Thread Übergabe
public void start(Thread t)
{
	this.t = t;
	super.start();
}
// Neue RUN
public void run(){
	// Warten auf andere Threads...
	if(t != null)
	{
		try{t.join();t = null;}
		catch(InterruptedException e) {}
	}
    try 
    {
    	// Experimentnummer ermitteln - Spikein
		Pattern p = Pattern.compile("Expt(\\d+)_.*");
		Matcher m1 = p.matcher(dat1);
		Matcher m2 = p.matcher(dat1b);
		m1.find();m2.find();
		exp1 = m1.group(1);
		exp2 = m2.group(1);
    	// Dateinamen bauen
		int point = dat1.indexOf(".");
		dat1 = dat1.substring(0, point);
		point = dat2.indexOf(".");
		dat2 = dat2.substring(0, point);
		point = dat3.indexOf(".");
		dat3 = dat3.substring(0, point);
		point = dat1b.indexOf(".");
		dat1b = dat1b.substring(0, point);
		point = dat2b.indexOf(".");
		dat2b = dat2b.substring(0, point);
		point = dat3b.indexOf(".");
		dat3b = dat3b.substring(0, point);
		spikein(spikein);
		buildmvsd(dat1+"_m2s.mrg",dat2+"_m2s.mrg",dat3+"_m2s.mrg",1);
		buildmvsd(dat1b+"_m2s.mrg",dat2b+"_m2s.mrg",dat3b+"_m2s.mrg",2);
        ttest_out();
        Stammfenster.progress.setValue(99);
	} 
    catch (IOException e) 
	{
		e.printStackTrace();
	}
}
// Einlesen Spikein geneID enthält Liste gespikte Gene
// expt Hashmap mit ArrayList - enthält jede Zeile der Spikein
	public void spikein(String name) throws IOException
	{
		String line = "";
		int zeile = 0, count = 14*2;
		exp = new String[count][count];
		BufferedReader spin = new BufferedReader(new FileReader(name));
		while(line != null)
		{
			if(line.startsWith("Gene ID"))
			{		
				// Anfang löschen
				line = line.replace("Gene ID","");
				line = line.replace("\"", "");
				line = line.replaceAll("\"	\""," ");
				line = line.replace(" ","\t");
				// Splitten bei "\t" -> Array für alle Gene
				count = line.compareTo("\t");
				gene_id = new String[count];
				gene_id = line.split("\t");
				for( int c = 0; c < gene_id.length ; c++)
				{
					if(gene_id[c].equals(""))
					{
						gene_id[c] = null;
					}
				}
			}
			else if(line.startsWith("EXP"))
			{
				Pattern p = Pattern.compile("EXP\\s+\\d+\\t+(\\S+)\\t+(\\S+)\\t+(\\S+)\\t+(\\S+)+\\t+(\\S+)+\\t+(\\S+)\\t+(\\S+)\\t+(\\S+)\\t+(\\S+)+\\t+(\\S+)+\\t+(\\S+)\\t+(\\S+)\\t+(\\S+)\\t+(\\S+)");
				Matcher m1 = p.matcher(line);
				if(m1.find())
				{
					for(int i = 1;i < 15;i++)
					{
						 exp[zeile][i] = m1.group(i);
					}
					zeile++;
				}
			}
			line = spin.readLine();
		}
		// Eintragen in Hashtable schrieben
		// Eintrag immer für 3 Gene
		int zz = 0,tri = 0;
		for(String gei:gene_id)
		{
			if(gei != null)
			{
				expt.put(gei,new ArrayList<Double>());
				for(int ii = 0;ii < 15;ii++)
				{
/*					try{expt.get(gei).add(Double.parseDouble(exp[zz][ii]));}
					catch(Exception e){}*/
					if(exp[zz][ii] != "" && exp[zz][ii] != null)
					{
						expt.get(gei).add(Double.parseDouble(exp[zz][ii]));
					}
				}
				if(tri == 2){tri = -1;zz++;}
				tri++;
			}
		}
	}
// Einlesen der übergebenen Dateinamen gleichzeitig
	public void buildmvsd(String dat1, String dat2, String dat3, int v) throws IOException
	{
		String line1 = "", line2 = "", line3 = "";
		// READ
		BufferedReader d1 = new BufferedReader(new FileReader(dat1));
		BufferedReader d2 = new BufferedReader(new FileReader(dat2));
		BufferedReader d3 = new BufferedReader(new FileReader(dat3));
		//Jedes Gen durchgehen und Werte zu Hashtable (Index Gen) addieren
		while(line1 != null)
		{
			// Genname ermitteln
			Pattern p = Pattern.compile("(\\S+)\\t+(\\d+)\\..*");
			Matcher m1 = p.matcher(line1);
			if(m1.find())
			{
				String ge = m1.group(1);
				String mm = m1.group(2);
				try{set_hm(ge,Double.parseDouble(mm), v);}
				catch(Exception e){e.printStackTrace();}
			}
		  line1 = d1.readLine();
		}
		while(line2 != null)
		{
			// Genname ermitteln
			Pattern p = Pattern.compile("(\\S+)\\t+(\\d+)\\..*");
			Matcher m1 = p.matcher(line2);
			if(m1.find())
			{
				String ge = m1.group(1);
				String mm = m1.group(2);
				try{set_hm(ge,Double.parseDouble(mm), v);}
				catch(Exception e){e.printStackTrace();}
			}
		  line2 = d2.readLine();
		}
		while(line3 != null)
		{
			// Genname ermitteln
			Pattern p = Pattern.compile("(\\S+)\\t+(\\d+)\\..*");
			Matcher m1 = p.matcher(line3);
			if(m1.find())
			{
				String ge = m1.group(1);
				String mm = m1.group(2);
				try{set_hm(ge,Double.parseDouble(mm), v);}
				catch(Exception e){e.printStackTrace();}
			}
		 line3 = d3.readLine();
		}
	}
// p-Wert durch Ttest ermitteln und Ausgabe erstellen
	public void ttest_out()
	{
		// Tabelle löschen
		((DefaultTableModel)Stammfenster.outputModel).fireTableStructureChanged();
		((DefaultTableModel)Stammfenster.outputModel).setRowCount(1);
		int row = 0, colum = 0;
		// WRITE
	try {PrintWriter daten = new PrintWriter("ttestout.txt");
	System.out.println("START TTEST!!!");
			double pvalue = 0;
			double ave1 = 0, ave2 = 0, sd1 = 0, sd2 = 0, fce = 0, fcc = 0, lnp = 0;
			String conc1 = "-", conc2 = "-";
			int num1 = 0, num2 = 0;
			// Werte durch Ttest ermitteln
			Ttest tt = new Ttest();
				for(String g:genm.keySet()) // Index aller Gene
				{
					if(g != null && g != "")
					{
						//System.out.println("FOR TTEST...");
						ave1 = genm.get(g)/3;
						String all1 = stabw.get(g).get(0)+","+stabw.get(g).get(1)+","+stabw.get(g).get(2);
						ave2 = genm2.get(g)/3;
						String all2 = stabw2.get(g).get(0)+","+stabw2.get(g).get(1)+","+stabw2.get(g).get(2);
						sd1 = stabw.get(g).get(3);
						sd2 = stabw2.get(g).get(3);
						fcc = ave2/ave1;
						// Prüfen ob Wert gespiked ist
						if(expt.containsKey(g))
						{
							try
							{
								double c1,c2;
								c1 = expt.get(g).get(Integer.parseInt(exp1));
								c2 = expt.get(g).get(Integer.parseInt(exp2));
								conc1 = c1+"";
								conc2 = c2+"";
								fce = c2/c1;
							}
							catch(Exception e){}
						}
						else{conc1 = "-"; conc2 = "-"; fce = 0;}
						num1 = 3;num2 = 3;
						pvalue = tt.rcp_ttest_welch_m(ave1, ave2, sd1, sd2, num1, num2);
						lnp = tt.rcp_ttest_welch_m(Math.log(ave1), Math.log(ave2), Math.log(sd1), Math.log(sd2), num1, num2);
						daten.println(g+"\t"+conc1+"\t"+all1+"\t"+ave1+"\t"+sd1+"\t"+conc2+"\t"+all2+"\t"+ave2+"\t"+sd2+"\t"+fce+"\t"+fcc+"\t"+pvalue+"\t"+lnp);
						//Stammfenster.output.setText(Stammfenster.output.getText()+g+"\t"+conc1+"\t"+all1+"\t"+ave1+"\t"+sd1+"\t"+conc2+"\t"+all2+"\t"+ave2+"\t"+sd2+"\t"+fc+"\tp:"+pvalue+"\n");
						String[] ou = new String[13];
						ou[0] = g; ou[1] = conc1; ou[2] = all1+""; ou[3] = ave1+""; ou[4] = sd1+""; ou[5] = conc2+""; ou[6] = all2+""; ou[7] = ave2+""; ou[8] = sd2+""; ou[9] = fce+""; ou[10] = fcc+""; ou[11] = pvalue+""; ou[12] = lnp+"";
						// Größe der Tabelle anpassen
						if(Stammfenster.outputModel.getRowCount() <= row){((DefaultTableModel) Stammfenster.outputModel).setRowCount(row+2);}
						// FC-Filter
						double fcstart  = Double.parseDouble(Stammfenster.fcstart.getText()); double fccc = Double.parseDouble(ou[10]);double fcstop = Double.parseDouble(Stammfenster.fcstop.getText());
						double schwelle = Double.parseDouble(Stammfenster.ttthreshold.getText());
						if(fccc <  fcstart && fccc < fcstop && ave1 != 0 && ave2 != 0)
						{
							if(pvalue <= schwelle) //&& lnp <= schwelle)
							{
								// Tabelle füllen
								for(colum = 0; colum < 13; colum++)
								{
									Stammfenster.outputModel.setValueAt(ou[colum],row,colum);
								}
								row++;
							}
						}
					}
				}
			daten.close();
		 }
		 catch (FileNotFoundException e) 
	     {
	         e.printStackTrace();
	     }	
	}
// HashMap mit Wert füllen. Falls gesetzt hinzufügen, sonst neu setzen
	// Berechnen der Standardabweichung
	public void set_hm(String gen, double me, int v)
	{
		double sta = 0, mw = 0, summe = 0, quadsum = 0; 
		int d = 0, s1 = 0, s2 = 0, s3 = 0;
		int mean = (int)me, n = 3;
		if(v == 1)
		{
			if(genm.containsKey(gen))
			{
				// Meanwert addieren
				genm.put(gen, genm.get(gen) + mean);
				// zu Hashmap für SA hinzufügen
				stabw.get(gen).add(mean);
				// Wenn alle Werte da, Standardabweichung berrechnen
				if(stabw.get(gen).size() == 3)
				{
					// Werte durchgehen
					d = 0;
					for(int wm: stabw.get(gen))
					{
						summe += wm;
						if(d == 0){s1 = wm;}
						if(d == 1){s2 = wm;}
						if(d == 2){s3 = wm;}
						d++;
					}
					// Formel für Standardabweichung
				    mw = (summe/n);
				    sta = Math.pow(s1 -mw, 2)+Math.pow(s2 -mw, 2)+Math.pow(s3 -mw, 2);
				    sta = 0.5*sta;
				    sta = Math.sqrt(sta);
					stabw.get(gen).add((int)sta);
				}
			}
			else
			{
				// Geneintrag und Meanwert 
				genm.put(gen, mean);
				// Neuen Eintrag in Hashtable für Standardabweichung erstellen
				stabw.put(gen, new ArrayList<Integer>());
				stabw.get(gen).add(mean);
			}
		}
		else
		{
			if(genm2.containsKey(gen))
			{
				// Meanwert addieren
				genm2.put(gen, genm2.get(gen) + mean);
				// zu Hashmap für SA hinzufügen
				stabw2.get(gen).add(mean);
				// Wenn alle Werte da, Standardabweichung berrechnen
				if(stabw2.get(gen).size() == 3)
				{
					// Werte durchgehen
					d = 0;
					for(int wm: stabw2.get(gen))
					{
						summe += wm;
						if(d == 0){s1 = wm;}
						if(d == 1){s2 = wm;}
						if(d == 2){s3 = wm;}
						d++;
					}
					// Formel für Standardabweichung
					mw = summe / n;
				    sta = Math.pow(s1 -mw, 2)+Math.pow(s2 -mw, 2)+Math.pow(s3 -mw, 2);
				    sta = 0.5*sta;
				    sta = Math.sqrt(sta);
					stabw2.get(gen).add((int)sta);
				}
			}
			else
			{
				// Geneintrag und Meanwert 
				genm2.put(gen, mean);
				// Neuen Eintrag in Hashtable für Standardabweichung erstellen
				stabw2.put(gen, new ArrayList<Integer>());
				stabw2.get(gen).add(mean);
			}
		}
	}
}