package compbio.ws.server;

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

import javax.jws.WebParam;
import javax.jws.WebService;

import org.apache.log4j.Logger;

import compbio.data.msa.FoldWS;
import compbio.data.msa.JABAService;
import compbio.data.msa.JManagement;
import compbio.data.msa.Metadata;
import compbio.data.sequence.Alignment;
import compbio.data.sequence.RNAstruct;
import compbio.data.sequence.FastaSequence;
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.LimitsManager;
import compbio.metadata.Option;
import compbio.metadata.Preset;
import compbio.metadata.PresetManager;
import compbio.metadata.ResultNotAvailableException;
import compbio.metadata.RunnerConfig;
import compbio.metadata.WrongParameterException;
import compbio.runner.Util;
import compbio.runner.structure.RNAalifold;

@WebService(endpointInterface = "compbio.data.msa.FoldWS", targetNamespace = JABAService.SERVICE_NAMESPACE, serviceName = "RNAalifoldWS")
public class RNAalifoldWS implements FoldWS<RNAalifold> {

	private static Logger log = Logger.getLogger(ClustalWS.class);
	
	private static final RunnerConfig<RNAalifold> rnaalifoldOptions = Util.
			getSupportedOptions(RNAalifold.class);
	
	private static final PresetManager<RNAalifold> rnaalifoldPresets = Util
			.getPresets(RNAalifold.class);

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

	@Override
	public String fold(Alignment alignment)
			throws JobSubmissionException {
		
		// Validate clustal input here?
		ConfiguredExecutable<RNAalifold> confRNAalifold = init(alignment);
		return WSUtil.fold(alignment, confRNAalifold, log, "fold", getLimit(""));
	}
	
	
	ConfiguredExecutable<RNAalifold> init(Alignment dataset) throws JobSubmissionException {
		RNAalifold rnaalifold = new RNAalifold();
		rnaalifold.setInput(SkeletalExecutable.INPUT)
				.setOutput(SkeletalExecutable.OUTPUT)
				.setError(SkeletalExecutable.ERROR);
		ConfiguredExecutable<RNAalifold> confRNAalifold = Configurator
				.configureExecutable(rnaalifold, dataset.getSequences());
		return confRNAalifold;
	}
	
	@Override
	public String presetFold(Alignment alignment,
			Preset<RNAalifold> preset) throws JobSubmissionException,
			WrongParameterException {
		// validate
		if (preset == null) {
			throw new WrongParameterException("Preset must be Provided!");
		}
		Limit<RNAalifold> limit = getLimit(preset.getName());
		ConfiguredExecutable<RNAalifold> confRNAalifold = init(alignment);
		confRNAalifold.addParameters(preset.getOptions());
		return WSUtil.fold(alignment, confRNAalifold, log, "presetFold", limit);
	}
		
	@Override 
	public String customFold(Alignment alignment,
			List<Option<RNAalifold>> options) throws JobSubmissionException,
			WrongParameterException {
		// validate
		ConfiguredExecutable<RNAalifold> confRNAalifold = init(alignment);
		List<String> params = WSUtil.getCommands(options, 
				RNAalifold.KEY_VALUE_SEPARATOR);
		confRNAalifold.addParameters(params);
		log.info("Setting parameters: " + params);
		return WSUtil.fold(alignment, confRNAalifold, log, "customFold", 
				getLimit(""));
	}
	
	@Override
	public RunnerConfig<RNAalifold> getRunnerOptions() {
		return rnaalifoldOptions;
	}
	
	@SuppressWarnings("unchecked")
	public String getResult(String jobId) throws ResultNotAvailableException {
		
		WSUtil.validateJobId(jobId);
		AsyncExecutor asyncEngine = Configurator.getAsyncEngine(jobId);
		ConfiguredExecutable<RNAalifold> rnaalifold = (ConfiguredExecutable<RNAalifold>) asyncEngine
				.getResults(jobId);
		return rnaalifold.getResults();
	}
	
	@Override
	public boolean cancelJob(String jobId) {
		WSUtil.validateJobId(jobId);
		boolean result = WSUtil.cancelJob(jobId);
		return result;
	}
	
	@Override
	public JobStatus getJobStatus(String jobId) {
		WSUtil.validateJobId(jobId);
		JobStatus status = WSUtil.getJobStatus(jobId);
		return status;
	}
	
	@Override
	public Limit<RNAalifold> getLimit(String presetName) {
		if (limitMan == null) {
			// No limit is configured
			return null;
		}
		Limit<RNAalifold> limit = limitMan.getLimitByName(presetName);
		return limit;
	}
	
	@Override
	public LimitsManager<RNAalifold> getLimits() {
		return limitMan;
	}
	
	@Override 
	// PlaceHolder
	public PresetManager<RNAalifold> getPresets() {
		if (rnaalifoldPresets == null) {
			// No presets are configured
			return null;
		}
		return rnaalifoldPresets;
	}

	@Override
	// PlaceHolder 
	public ChunkHolder pullExecStatistics(String jobId, long position) {

//		WSUtil.validateJobId(jobId);
//		String file = Configurator.getWorkDirectory(jobId) + File.separator
//				+ RNAalifold.getStatFile();
//		ChunkHolder cholder = WSUtil.pullFile(file, position);
//		return cholder;
		return new ChunkHolder("", -1);
	}
}