/*
 *                    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.structure.align;

/**
 * Simple Callable Class that calculates a pairwise alignment in a different
 * thread, so that multiple pairwise alignments can be run in parallel
 * (examples: all-to-all alignments, DB search alignments).
 * Adapted to a more general implementation since 4.1.0, because before it
 * was thought for DB search only.
 *
 * @author Aleix Lafita
 *
 */
import org.biojava.nbio.structure.Atom;
import org.biojava.nbio.structure.Structure;
import org.biojava.nbio.structure.StructureTools;
import org.biojava.nbio.structure.align.ce.ConfigStrucAligParams;
import org.biojava.nbio.structure.align.client.PdbPair;
import org.biojava.nbio.structure.align.model.AFPChain;
import org.biojava.nbio.structure.align.util.AtomCache;
import org.biojava.nbio.structure.align.util.SynchronizedOutFile;
import org.biojava.nbio.structure.align.xml.AFPChainXMLConverter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
import java.util.concurrent.Callable;
import java.util.zip.GZIPOutputStream;

public class CallableStructureAlignment implements  Callable<AFPChain> {

	private final static Logger logger = LoggerFactory.getLogger(
			CallableStructureAlignment.class);

	//Structure information
	private PdbPair pair;
	private AtomCache cache;
	private Atom[] ca1;
	private Atom[] ca2;

	//File output information - for DB searches
	private SynchronizedOutFile outFile;
	private File outFileDir;

	//Algorithm information
	private String algorithmName;
	private ConfigStrucAligParams params;

	/**
	 * Default constructor. Used in DB search.
	 * Instantiates an empty object, everything has to be set independently.
	 */
	public CallableStructureAlignment() {}

	/**
	 * Constructor for all-to-all alignment calculation.
	 * Used for MultipleMC seed alignment calculation, for example.
	 *
	 * @param ca1 Atoms to align of the first structure
	 * @param ca2 Atoms to align of the second structure
	 * @param algorithmName the pairwise aligner algorithm to use, a new
	 * 			instance will be created for each thread.
	 * @param params parameter bean for the alignment.
	 */
	public CallableStructureAlignment(Atom[] ca1, Atom[] ca2, String algorithmName, ConfigStrucAligParams params){
		this.ca1 = ca1;
		this.ca2 = ca2;
		this.algorithmName = algorithmName;
		this.params = params;
	}

	@Override
	public AFPChain call() throws Exception {

		//Prepare the alignment algorithm
		StructureAlignment algorithm = StructureAlignmentFactory.getAlgorithm(algorithmName);
		if (params!=null) algorithm.setParameters(params);

		AFPChain afpChain = null;
		try {
			//Download the Atoms if they are not provided from the outisde (DB searches usually)
			if (ca1 == null) {
				Structure structure1 = cache.getStructure(pair.getName1());
				ca1 =  StructureTools.getRepresentativeAtomArray(structure1);
			} else ca1 = StructureTools.cloneAtomArray(ca1);

			Structure structure2 = null;
			if (ca2 == null) {
				structure2 = cache.getStructure(pair.getName2());
				ca2 = StructureTools.getRepresentativeAtomArray(structure2);
			} else ca2 = StructureTools.cloneAtomArray(ca2);

			afpChain = algorithm.align(ca1, ca2);

			if (pair!=null){
				afpChain.setName1(pair.getName1());
				afpChain.setName2(pair.getName2());
			}

			//Do not output anything if there is no File information
			if (outFile != null && outFileDir != null){
				String desc2 = structure2.getPDBHeader().getDescription();
				if ( desc2 == null)
					desc2="";
				afpChain.setDescription2(desc2);
				String result = afpChain.toDBSearchResult();
				logger.info("{}", result);

				outFile.write(result);

				String xml = AFPChainXMLConverter.toXML(afpChain, ca1, ca2);
				writeXML(outFileDir,pair.getName1(), pair.getName2(), xml);
			}

		} catch ( Exception e){
			logger.error("Exception: ", e);
		}
		return afpChain;
	}

	public PdbPair getPair() {
		return pair;
	}

	public void setPair(PdbPair pair) {
		this.pair = pair;
	}

	public AtomCache getCache() {
		return cache;
	}

	public void setCache(AtomCache cache) {
		this.cache = cache;
	}

	public SynchronizedOutFile getOutFile() {
		return outFile;
	}

	public void setOutFile(SynchronizedOutFile outFile) {
		this.outFile = outFile;
	}

	public Atom[] getCa1() {
		return ca1;
	}

	public void setCa1(Atom[] ca1) {
		this.ca1 = ca1;
	}

	private void writeXML(File outFileF, String name1, String name2, String xml)
	{
		try{
			// Create file
			File newF = new File(outFileF, "dbsearch_" +name1+"_" + name2+".xml.gz");

			FileOutputStream fstream = new FileOutputStream(newF);

			GZIPOutputStream gz = new GZIPOutputStream(fstream);
			OutputStreamWriter writer = new OutputStreamWriter(gz);
			writer.write(xml);
			writer.close();
		} catch (Exception e){//Catch exception if any
			logger.error("Exception: ", e);
		}
	}

	public void setOutputDir(File outFileF) {
		this.outFileDir = outFileF;
	}

	public void setAlgorithmName(String algorithmName) {
		this.algorithmName = algorithmName;
	}

	public void setParameters(ConfigStrucAligParams parameters) {
		this.params = parameters;
	}
}