package compbio.ws.server;

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.ScoreManager;
import compbio.engine.AsyncExecutor;
import compbio.engine.Configurator;
import compbio.engine.client.ConfiguredExecutable;
import compbio.engine.client.SkeletalExecutable;
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.disorder.Disembl;

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

	// Ask for resource injection
	@Resource
	WebServiceContext wsContext;

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

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

	private static final RunnerConfig<Disembl> disemblOptions = Util
			.getSupportedOptions(Disembl.class);

	private static final PresetManager<Disembl> disemblPresets = Util
			.getPresets(Disembl.class);

	private static final LimitsManager<Disembl> limitMan = compbio.engine.client.Util
			.getLimits(new Disembl().getType());

	ConfiguredExecutable<Disembl> init(List<FastaSequence> sequences)
			throws JobSubmissionException {
		Disembl disembl = new Disembl();
		disembl.setInput(SkeletalExecutable.INPUT);
		return Configurator.configureExecutable(disembl, sequences);
	}

	@Override
	public ScoreManager getAnnotation(String jobId)
			throws ResultNotAvailableException {
		WSUtil.validateJobId(jobId);
		AsyncExecutor asyncEngine = Configurator.getAsyncEngine(jobId);
		ConfiguredExecutable<Disembl> disembl = (ConfiguredExecutable<Disembl>) asyncEngine
				.getResults(jobId);
		ScoreManager mas = disembl.getResults();
		log.trace(jobId + " getDisorder : " + mas);
		return mas;
	}

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

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

	@Override
	public ChunkHolder pullExecStatistics(String jobId, long position) {
		// Execution stat is not supported
		return new ChunkHolder("", -1);
	}

	@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<Disembl> getPresets() {
		return disemblPresets;
	}

	@Override
	public RunnerConfig<Disembl> getRunnerOptions() {
		return disemblOptions;
	}

	String analize(List<FastaSequence> sequences,
			ConfiguredExecutable<Disembl> confExec, Logger log, String method,
			Limit<Disembl> 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<Disembl> confDisembl = init(sequences);

		return analize(sequences, confDisembl, null, "analize", getLimit(""));
	}

	/*
	 * No options are supported, thus the result of this call will be as simple
	 * call to analize without parameters
	 */
	@Override
	public String customAnalize(List<FastaSequence> sequences,
			List<Option<Disembl>> options) throws UnsupportedRuntimeException,
			LimitExceededException, JobSubmissionException,
			WrongParameterException {
		return analize(sequences);
	}

	/*
	 * No presets are supported, thus the result of this call will be as simple
	 * call to analize without parameters
	 */
	@Override
	public String presetAnalize(List<FastaSequence> sequences,
			Preset<Disembl> preset) throws UnsupportedRuntimeException,
			LimitExceededException, JobSubmissionException,
			WrongParameterException {

		return analize(sequences);
	}

}