package jalview.ws.jws2;

import jalview.api.AlignCalcWorkerI;
import jalview.bin.Cache;
import jalview.datamodel.SequenceFeature;
import jalview.datamodel.SequenceI;
import jalview.gui.AlignFrame;
import jalview.schemes.GraduatedColor;
import jalview.ws.jws2.jabaws2.Jws2Instance;
import jalview.ws.params.WsParamSetI;

import java.awt.Color;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import compbio.data.sequence.Range;
import compbio.data.sequence.Score;
import compbio.data.sequence.ScoreManager.ScoreHolder;
import compbio.metadata.Argument;

public class AADisorderClient extends JabawsAlignCalcWorker implements
        AlignCalcWorkerI
{

  String typeName;

  String methodName;

  String groupName;

  AlignFrame af;

  public AADisorderClient(Jws2Instance sh, AlignFrame alignFrame,
          WsParamSetI preset, List<Argument> paramset)
  {
    super(sh, alignFrame, preset, paramset);
    af = alignFrame;
    typeName = sh.action;
    methodName = sh.serviceType;

    submitGaps = false;
    alignedSeqs = false;
    nucleotidesAllowed = false;
    proteinAllowed = true;
    bySequence = true;
  }

  @Override
  public String getServiceActionText()
  {
    return "Submitting amino acid sequences for disorder prediction.";
  }

  @Override
  public void updateResultAnnotation(boolean immediate)
  {

    if (immediate || !calcMan.isWorking(this) && scoremanager != null)
    {
      boolean dispFeatures = false;
      Map<String,Object> fc=new Hashtable<String, Object>();
      for (String seqId : seqNames.keySet())
      {
        SequenceI dseq, seq = seqNames.get(seqId);
        int base = seq.getStart() - 1;
        while ((dseq = seq).getDatasetSequence() != null)
        {
          seq = seq.getDatasetSequence();
        }
        ;
        ScoreHolder scores = scoremanager.getAnnotationForSequence(seqId);
        float last=Float.NaN,val=Float.NaN;
        for (Score scr : scores.scores)
        {

          if (scr.getRanges() != null && scr.getRanges().size() > 0)
          {
            Iterator<Float> vals = scr.getScores().iterator();
            // make features on sequence
            for (Range rn : scr.getRanges())
            {

              SequenceFeature sf;
              if (vals.hasNext())
              {
                sf = new SequenceFeature(typeName + "(" + scr.getMethod()
                        + ")", "Disordered Region", base + rn.from, base
                        + rn.to, val=vals.next().floatValue(), methodName);
              }
              else
              {
                sf = new SequenceFeature(typeName + "(" + scr.getMethod()
                        + ")", "Disordered Region", null, base + rn.from,
                        base + rn.to, methodName);
              }
              dseq.addSequenceFeature(sf);
              if (last!=val && last!=Float.NaN)
              {
                fc.put(sf.getType(),sf);
              }
              last=val;
              dispFeatures = true;
            }
          }
          else
          {
            Iterator<Float> vals = scr.getScores().iterator();
            for (int start = base + 1; vals.hasNext(); start++)
            {
              SequenceFeature sf = new SequenceFeature(typeName + "("
                      + scr.getMethod() + ")", "Disordered Region", start,
                      start, val=vals.next().floatValue(), methodName);
              if (last!=val && last!=Float.NaN)
              {
                fc.put(sf.getType(),sf);
              }
              last=val;
              dseq.addSequenceFeature(sf);
              dispFeatures = true;
            }
          }
        }
      }
      {
        if (dispFeatures)
        {
          jalview.gui.FeatureRenderer fr = ((jalview.gui.AlignmentPanel) ap).cloneFeatureRenderer();
          // TODO: configure feature display settings for added types if they don't already exist
          for (String ft:fc.keySet())
          {
            Cache.log.debug("Set graduated feature for new type:"+ft);
            Object gc=fr.getFeatureStyle(ft);
            if (gc instanceof Color)
            {
              // set graduated color as fading to white for minimum, and autoscaling to values on alignment
              GraduatedColor ggc=new GraduatedColor(Color.white, (Color)gc,Float.MIN_VALUE, Float.MAX_VALUE);
              ggc.setAutoScaled(true);
              fr.setColour(ft, ggc);
            }
          }
          af.alignPanel.updateFeatureRendererFrom(fr);
          af.alignPanel.av.setShowSequenceFeatures(true);
          ap.paintAlignment(true);
        }
      }
    }
  }

}