/*
 *                    BioJava development code
 *
 * This code may be freely distributed and modified under the
 * terms of the GNU Lesser General Public Licence.  This should
 * be distributed with the code.  If you do not have a copy,
 * see:
 *
 *      http://www.gnu.org/copyleft/lesser.html
 *
 * Copyright for this code is held jointly by the individual
 * authors.  These should be listed in @author doc comments.
 *
 * For more information on the BioJava project and its aims,
 * or to join the biojava-l mailing list, visit the home page
 * at:
 *
 *      http://www.biojava.org/
 *
 */
package org.biojava.nbio.core.alignment.matrices;

import org.biojava.nbio.core.alignment.template.SubstitutionMatrix;
import org.biojava.nbio.core.sequence.compound.AminoAcidCompound;
import org.biojava.nbio.core.sequence.compound.AminoAcidCompoundSet;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;



public class AAIndexFileParser {
	int scale = -1;

	Map<String,SubstitutionMatrix<AminoAcidCompound>> matrices;

	ScaledSubstitutionMatrix currentMatrix;
	String currentRows;
	String currentCols;
	int currentRowPos;
	private short[][] matrix;
	short max;
	short min;
	private List<AminoAcidCompound> rows, cols;
	boolean inMatrix;
	boolean symmetricMatrix ;


	public AAIndexFileParser(){
		matrices  = new HashMap<String, SubstitutionMatrix<AminoAcidCompound>>();
	}

	/** parse an inputStream that points to an AAINDEX database file
	 *
	 * @param inputStream
	 * @throws IOException
	 */
	public void parse(InputStream inputStream) throws IOException {

		currentMatrix = null;
		currentRows = "";
		currentCols = "";
		max = Short.MIN_VALUE;
		min = Short.MAX_VALUE;
		inMatrix = false;

		BufferedReader buf = new BufferedReader (new InputStreamReader (inputStream));
		String line = null;
		line = buf.readLine();

		while (  line != null ) {

			if ( line.startsWith("//")) {
				finalizeMatrix();
				inMatrix = false;

			} else if ( line.startsWith("H ")){
				// a new matric!
				newMatrix(line);
			} else if ( line.startsWith("D ")) {
				currentMatrix.setDescription(line.substring(2));
			} else if ( line.startsWith("M ")) {
				initMatrix(line);
				inMatrix = true;
			} else if ( line.startsWith("  ")){
				if ( inMatrix)
					processScores(line);
			}

			line = buf.readLine();
		}

	}


	//  process a line such as >    -0.3     1.6     0.7     0.8    -2.6     3.0<
	private void processScores(String line) {

		String[] values = line.trim().split(" +");

		// increment the current row we are talking about
		currentRowPos++;



		for ( int i =0 ; i < values.length ; i++){

			if ( values[i].endsWith(".")) {
				values[i] = values[i] + "0";
			}

			// special case: MEHP950101
			if (values[i].equals("-")) {
				values[i] = "0";
			}

			if ( scale == -1 ) {
				scale = determineScale(values[0]);
			}


			Float score = Float.parseFloat(values[i]);
			score = scale * score;

			Short s = (short) Math.round(score);

			matrix[currentRowPos][i] = s;

			if ( values.length < cols.size() || ( symmetricMatrix)){
				//System.out.println(values.length + " " + cols.size() + " " + currentRowPos + " " + i + " " +  line);

				matrix[i][currentRowPos] = s;

				symmetricMatrix = true;

			}

			if ( score > max)
				max = s;
			if ( score < min)
				min = s;


		}
	}

	private int determineScale(String value) {

		String[] spl = value.split("\\.");

		if (spl.length <= 1)
			return 1;

		String digits = spl[1];

		return (int)Math.round(Math.pow(10, digits.length()));

	}

	// process a line of type >M rows = ARNDCQEGHILKMFPSTWYV, cols = ARNDCQEGHILKMFPSTWYV<
	private void initMatrix(String line) {
		String[] spl = line.split(" ");

		// trim off the final , character
		currentRows = spl[3].substring(0, spl[3].length()-1);
		currentCols = spl[6];
		currentRowPos = -1;

		int nrRows = currentRows.length();
		int nrCols = currentCols.length();

		matrix = new short[nrRows][nrCols];

		rows = new ArrayList<AminoAcidCompound>();
		cols = new ArrayList<AminoAcidCompound>();


		//System.out.println(">" + currentRows+"<");
		AminoAcidCompoundSet compoundSet = AminoAcidCompoundSet.getAminoAcidCompoundSet();
		for ( int i = 0 ; i < currentRows.length() ; i ++){
			char c = currentRows.charAt(i);
			AminoAcidCompound aa = compoundSet.getCompoundForString(String.valueOf(c));

			rows.add(aa);
		}

		for ( int i = 0 ; i < currentCols.length() ; i ++){
			char c = currentRows.charAt(i);
			AminoAcidCompound aa = compoundSet.getCompoundForString(String.valueOf(c));

			cols.add(aa);
		}





		currentMatrix.setScale(scale);
	}


	private void newMatrix(String line) {
		symmetricMatrix = false;
		scale = -1;

		currentMatrix = new ScaledSubstitutionMatrix();
		currentMatrix.setName(line.substring(2));


		//System.out.println("new Matrix " + currentMatrix.getName());
	}

	//
	private SubstitutionMatrix<AminoAcidCompound> finalizeMatrix() {

		currentMatrix.setMatrix(matrix);
		currentMatrix.setMax(max);
		currentMatrix.setMin(min);
		currentMatrix.setCols(cols);
		currentMatrix.setRows(rows);
		currentMatrix.setScale(scale);
		matrices.put(currentMatrix.getName(), currentMatrix);

		return currentMatrix;

	}

	public Map<String, SubstitutionMatrix<AminoAcidCompound>> getMatrices() {
		return matrices;
	}
}
