package compbio.ws.server;

import java.io.File;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;

import javax.annotation.Resource;
import javax.jws.WebService;
import javax.xml.ws.WebServiceContext;

import org.apache.log4j.Logger;

import compbio.data.msa.SequenceAnnotation;
import compbio.data.sequence.FastaSequence;
import compbio.data.sequence.Score;
import compbio.data.sequence.ScoreManager;
import compbio.engine.AsyncExecutor;
import compbio.engine.Configurator;
import compbio.engine.client.ConfiguredExecutable;
import compbio.metadata.ChunkHolder;
import compbio.metadata.JobStatus;
import compbio.metadata.JobSubmissionException;
import compbio.metadata.Limit;
import compbio.metadata.LimitExceededException;
import compbio.metadata.LimitsManager;
import compbio.metadata.Option;
import compbio.metadata.Preset;
import compbio.metadata.PresetManager;
import compbio.metadata.ResultNotAvailableException;
import compbio.metadata.RunnerConfig;
import compbio.metadata.UnsupportedRuntimeException;
import compbio.metadata.WrongParameterException;
import compbio.runner.Util;
import compbio.runner.conservation.AACon;

@WebService(endpointInterface = "compbio.data.msa.SequenceAnnotation", targetNamespace = "http://msa.data.compbio/01/12/2010/", serviceName = "AAConWS")
public class AAConWS implements SequenceAnnotation<AACon> {

	// Ask for resource injection
	@Resource
	WebServiceContext wsContext;

	private static Logger statLog = Logger.getLogger("AAConWS-stats");

	private static Logger log = Logger.getLogger(AAConWS.class);

	private static final RunnerConfig<AACon> aaconOptions = Util
			.getSupportedOptions(AACon.class);

	private static final PresetManager<AACon> aaconPresets = Util
			.getPresets(AACon.class);

	private static final LimitsManager<AACon> limitMan = compbio.runner.Util
			.getLimits(new AACon().getType());

	ConfiguredExecutable<AACon> init(List<FastaSequence> sequences)
			throws JobSubmissionException {
		AACon aacon = new AACon();
		aacon.setInput("fasta.in").setOutput("aacon.out");
		return Configurator.configureExecutable(aacon, sequences);
	}

	@Override
	public ScoreManager getAnnotation(String jobId)
			throws ResultNotAvailableException {
		WSUtil.validateJobId(jobId);
		AsyncExecutor asyncEngine = Configurator.getAsyncEngine(jobId);
		ConfiguredExecutable<AACon> aacon = (ConfiguredExecutable<AACon>) asyncEngine
				.getResults(jobId);
		HashSet<Score> mas = aacon.getResults();
		// ScoreManager result = new HashMap<String, HashSet<Score>>();
		// result.put("Alignment", mas);
		log.trace(jobId + " getConservation : " + mas);
		// FIXME
		return null;
	}
	/*
	 * @SuppressWarnings("unchecked") public JalviewAnnotation
	 * getJalviewAnnotation(String jobId) throws ResultNotAvailableException {
	 * MultiAnnotatedSequence<Method> result = getResult(jobId); // TODO //
	 * log(jobId, "getResults"); return result.toJalviewAnnotation(); }
	 */

	@Override
	public Limit<AACon> getLimit(String presetName) {
		if (limitMan == null) {
			// Limit is not defined
			return null;
		}
		return limitMan.getLimitByName(presetName);
	}

	@Override
	public LimitsManager<AACon> getLimits() {
		return limitMan;
	}

	@Override
	public ChunkHolder pullExecStatistics(String jobId, long position) {
		WSUtil.validateJobId(jobId);
		String file = Configurator.getWorkDirectory(jobId) + File.separator
				+ AACon.getStatFile();
		return WSUtil.pullFile(file, position);
	}

	@Override
	public boolean cancelJob(String jobId) {
		WSUtil.validateJobId(jobId);
		return WSUtil.cancelJob(jobId);
	}

	@Override
	public JobStatus getJobStatus(String jobId) {
		WSUtil.validateJobId(jobId);
		return WSUtil.getJobStatus(jobId);
	}

	@Override
	public PresetManager<AACon> getPresets() {
		return aaconPresets;
	}

	@Override
	public RunnerConfig<AACon> getRunnerOptions() {
		return aaconOptions;
	}

	String analize(List<FastaSequence> sequences,
			ConfiguredExecutable<AACon> confExec, Logger log, String method,
			Limit<AACon> limit) throws JobSubmissionException {
		if (limit != null && limit.isExceeded(sequences)) {
			throw LimitExceededException.newLimitExceeded(limit, sequences);
		}

		compbio.runner.Util.writeInput(sequences, confExec);
		AsyncExecutor engine = Configurator.getAsyncEngine(confExec);
		String jobId = engine.submitJob(confExec);
		return jobId;
	}

	@Override
	public String analize(List<FastaSequence> sequences)
			throws UnsupportedRuntimeException, LimitExceededException,
			JobSubmissionException {
		WSUtil.validateFastaInput(sequences);
		ConfiguredExecutable<AACon> confAAcon = init(sequences);

		// set default conservation method to fastest - SHENKIN
		// TODO: This violates encapsulation, should be moved to the runners
		// level.
		confAAcon.addParameters(Arrays.asList("-m=SHENKIN"));
		return analize(sequences, confAAcon, null, "analize", getLimit(""));
	}

	@Override
	public String customAnalize(List<FastaSequence> sequences,
			List<Option<AACon>> options) throws UnsupportedRuntimeException,
			LimitExceededException, JobSubmissionException,
			WrongParameterException {
		WSUtil.validateFastaInput(sequences);
		ConfiguredExecutable<AACon> confAACon = init(sequences);
		// Could not do that! Space separated values
		// will all be treated as keys! thus duplicates removed
		// String params = cbuilder.getCommand();
		List<String> params = WSUtil.getCommands(options,
				AACon.KEY_VALUE_SEPARATOR);
		confAACon.addParameters(params);
		return analize(sequences, confAACon, null, "customAnalize",
				getLimit(""));
	}

	@Override
	public String presetAnalize(List<FastaSequence> sequences,
			Preset<AACon> preset) throws UnsupportedRuntimeException,
			LimitExceededException, JobSubmissionException,
			WrongParameterException {
		WSUtil.validateFastaInput(sequences);
		if (preset == null) {
			throw new WrongParameterException("Preset must be provided!");
		}
		ConfiguredExecutable<AACon> confAAcon = init(sequences);
		confAAcon.addParameters(preset.getOptions());
		Limit<AACon> limit = getLimit(preset.getName());
		return WSUtil.align(sequences, confAAcon, null, "presetAnalize", limit);
	}

}