package compbio.ws.server;

import java.io.File;
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.conservation.AACon;
import compbio.runner.disorder.Jronn;

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

	// Ask for resource injection
	@Resource
	WebServiceContext wsContext;

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

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

	private static final RunnerConfig<Jronn> jronnOptions = Util
			.getSupportedOptions(Jronn.class);

	private static final PresetManager<Jronn> jronnPresets = Util
			.getPresets(Jronn.class);

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

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

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

	@Override
	public Limit<Jronn> getLimit(String presetName) {
		if (limitMan == null) {
			return null;
		}
		return limitMan.getLimitByName(presetName);
	}

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

	@Override
	public ChunkHolder pullExecStatistics(String jobId, long position) {
		WSUtil.validateJobId(jobId);
		String file = Configurator.getWorkDirectory(jobId) + File.separator
				+ Jronn.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<Jronn> getPresets() {
		return jronnPresets;
	}

	@Override
	public RunnerConfig<Jronn> getRunnerOptions() {
		return jronnOptions;
	}

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

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

	@Override
	public String customAnalize(List<FastaSequence> sequences,
			List<Option<Jronn>> options) throws UnsupportedRuntimeException,
			LimitExceededException, JobSubmissionException,
			WrongParameterException {
		WSUtil.validateFastaInput(sequences);
		ConfiguredExecutable<Jronn> confJronn = init(sequences);

		List<String> params = WSUtil.getCommands(options,
				AACon.KEY_VALUE_SEPARATOR);
		confJronn.addParameters(params);
		return analize(sequences, confJronn, null, "customAnalize",
				getLimit(""));
	}

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

}