/*
 * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
 * Copyright (C) $$Year-Rel$$ The Jalview Authors
 * 
 * This file is part of Jalview.
 * 
 * Jalview is free software: you can redistribute it and/or
 * modify it under the terms of the GNU General Public License 
 * as published by the Free Software Foundation, either version 3
 * of the License, or (at your option) any later version.
 *  
 * Jalview is distributed in the hope that it will be useful, but 
 * WITHOUT ANY WARRANTY; without even the implied warranty 
 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
 * PURPOSE.  See the GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
 * The Jalview Authors are detailed in the 'AUTHORS' file.
 */
package jalview.ws;

import jalview.bin.Cache;
import jalview.datamodel.AlignedCodonFrame;
import jalview.datamodel.Alignment;
import jalview.datamodel.AlignmentI;
import jalview.datamodel.AlignmentView;
import jalview.datamodel.SequenceI;
import jalview.gui.AlignFrame;
import jalview.gui.WebserviceInfo;
import jalview.util.MessageManager;
import jalview.viewmodel.seqfeatures.FeatureRendererSettings;

import java.util.ArrayList;
import java.util.List;
import java.util.Timer;
import java.util.TimerTask;

import static java.lang.String.format;

public abstract class AWSThread
{
  
  private final Timer timer = new Timer();

  /**
   * view that this job was associated with
   */
  protected AlignmentI currentView = null;

  /**
   * feature settings from view that job was associated with
   */
  protected FeatureRendererSettings featureSettings = null;

  /**
   * metadata about this web service
   */
  protected WebserviceInfo wsInfo = null;

  /**
   * original input data for this job
   */
  protected AlignmentView input = null;

  /**
   * dataset sequence relationships to be propagated onto new results
   */
  protected List<AlignedCodonFrame> codonframe = null;

  /**
   * are there jobs still running in this thread.
   *
   * fixme: initialize with an empty array?
   */
  protected boolean jobComplete = false;

  /**
   * one or more jobs being managed by this thread.
   */
  protected AWsJob[] jobs = null;

  /**
   * full name of service
   */
  protected String WebServiceName = null;

  protected char defGapChar = '-';

  /**
   * header prepended to all output from job
   */
  protected String OutputHeader;

  /**
   * only used when reporting a web service out of memory error - the job ID
   * will be concatenated to the URL
   */
  protected String WsUrl = null;

  /*
   * The AlignFrame from which the service was requested.
   */
  private AlignFrame alignFrame;

  public void start()
  {
    if (jobs == null)
    {
      jobComplete = true;
      Cache.log.debug(
          "WebServiceJob poll loop finished with no jobs created.");
      wsInfo.setStatus(WebserviceInfo.STATE_STOPPED_ERROR);
      wsInfo.appendProgressText(
          MessageManager.getString("info.no_jobs_ran"));
      wsInfo.setFinishedNoResults();
      return;
    }
    TimerTask task = new TimerTask() {
      @Override
      public void run() 
      {
        JobStateSummary jstate = new JobStateSummary();
        for (final AWsJob job : jobs)
        {
          if (!job.submitted && job.hasValidInput())
          {
            StartJob(job);
          }
          Cache.log.debug(format(
                  "Job %s is %ssubmitted", job, job.submitted ? "" : "not "));
          if (job.submitted && !job.subjobComplete)
          {
            Cache.log.debug(format(
                    "Polling Job %s Result state was:%s(ServerError=%b)",
                    job, job.getState(), job.isServerError()));
            try
            {
              pollJob(job);
              if (!job.hasResponse())
                throw new Exception("Timed out when communicating with server. Try again later.");
              else
                Cache.log.debug(format("Job %s Result state:%s(ServerError=%b)",
                        job, job.getState(), job.isServerError()));
            } catch (Exception exc)
            {
              // Deal with Transaction exceptions
              wsInfo.appendProgressText(job.jobnum, MessageManager
                      .formatMessage("info.server_exception", WebServiceName,
                          exc.getMessage()));
              // always output the exception's stack trace to the log
              Cache.log.warn(format("%s job(%s) Server exception.",
                      WebServiceName, job.jobnum));
              exc.printStackTrace();
              
              if (job.allowedServerExceptions > 0)
              {
                job.allowedServerExceptions--;
              }
              else
              {
                Cache.log.warn(format("Dropping job %s %s", job, job.jobId));
                job.subjobComplete = true;
                wsInfo.setStatus(job.jobnum, WebserviceInfo.STATE_STOPPED_SERVERERROR);
              }
            } catch (OutOfMemoryError oomerror)
            {
              jobComplete = true;
              job.subjobComplete = true;
              job.clearResponse();
              wsInfo.setStatus(job.jobnum, WebserviceInfo.STATE_STOPPED_ERROR);
              Cache.log.error(format("Out of memory when retrieving Job %s id:%s/%s",
                      job, WsUrl, job.jobId), oomerror);
              new jalview.gui.OOMWarning("retrieving result for " + WebServiceName, oomerror);
              System.gc();
            }
          }
          jstate.updateJobPanelState(wsInfo, OutputHeader, job);
        }
        // Decide on overall state based on collected jobs[] states
        updateGlobalStatus(jstate);
        if (jobComplete)
        {
          // jobs should never be null at this point
          parseResult(); // tidy up and make results available to user
          timer.cancel();
        }
      }
    };
    timer.schedule(task, 0, 5000);
  }

  protected void updateGlobalStatus(JobStateSummary jstate)
  {
    if (jstate.running > 0)
    {
      wsInfo.setStatus(WebserviceInfo.STATE_RUNNING);
    }
    else if (jstate.queuing > 0)
    {
      wsInfo.setStatus(WebserviceInfo.STATE_QUEUING);
    }
    else
    {
      jobComplete = true;
      if (jstate.finished > 0)
      {
        wsInfo.setStatus(WebserviceInfo.STATE_STOPPED_OK);
      }
      else if (jstate.error > 0)
      {
        wsInfo.setStatus(WebserviceInfo.STATE_STOPPED_ERROR);
      }
      else if (jstate.serror > 0)
      {
        wsInfo.setStatus(WebserviceInfo.STATE_STOPPED_SERVERERROR);
      }
    }
  }
  
  public void interrupt()
  {
    timer.cancel();
  }

  /**
   * query web service for status of job. on return, job.result must not be null
   * - if it is then it will be assumed that the job status query timed out and
   * a server exception will be logged.
   * 
   * @param job
   * @throws Exception
   *           will be logged as a server exception for this job
   */
  public abstract void pollJob(AWsJob job) throws Exception;

  /**
   * submit job to web service
   * 
   * @param job
   */
  public abstract void StartJob(AWsJob job);

  /**
   * process the set of AWsJob objects into a set of results, and tidy up.
   */
  public abstract void parseResult();

  /**
   * helper function to conserve dataset references to sequence objects returned
   * from web services 1. Propagates AlCodonFrame data from
   * <code>codonframe</code> to <code>al</code> TODO: refactor to datamodel
   * 
   * @param al
   */
  public void propagateDatasetMappings(Alignment al)
  {
    if (codonframe != null)
    {
      SequenceI[] alignment = al.getSequencesArray();
      for (int sq = 0; sq < alignment.length; sq++)
      {
        for (AlignedCodonFrame acf : codonframe)
        {
          final SequenceI seq = alignment[sq];
          if (acf != null && acf.involvesSequence(seq))
          {
            al.addCodonFrame(acf);
            break;
          }
        }
      }
    }
  }

  /**
   * 
   * @return gap character to use for any alignment generation
   */
  public char getGapChar()
  {
    return defGapChar;
  }

  /**
   * 
   * @param alignFrame
   *          reference for copying mappings across
   * @param wsinfo
   *          gui attachment point
   * @param input
   *          input data for the calculation
   * @param webServiceName
   *          name of service
   * @param wsUrl
   *          url of the service being invoked
   */
  public AWSThread(AlignFrame alignFrame, WebserviceInfo wsinfo,
          AlignmentView input, String webServiceName, String wsUrl)
  {
    this(alignFrame, wsinfo, input, wsUrl);
    WebServiceName = webServiceName;
  }

  /**
   * Extracts additional info from alignment view's context.
   * 
   * @param alframe
   *          - reference for copying mappings and display styles across
   * @param wsinfo2
   *          - gui attachment point - may be null
   * @param alview
   *          - input data for the calculation
   * @param wsurl2
   *          - url of the service being invoked
   */
  public AWSThread(AlignFrame alframe, WebserviceInfo wsinfo2,
          AlignmentView alview, String wsurl2)
  {
    super();
    this.alignFrame = alframe;
    currentView = alframe.getCurrentView().getAlignment();
    featureSettings = alframe.getFeatureRenderer().getSettings();
    defGapChar = alframe.getViewport().getGapCharacter();
    this.wsInfo = wsinfo2;
    this.input = alview;
    WsUrl = wsurl2;
    if (alframe != null)
    {
      List<AlignedCodonFrame> cf = alframe.getViewport().getAlignment()
              .getCodonFrames();
      if (cf != null)
      {
        codonframe = new ArrayList<>();
        codonframe.addAll(cf);
      }
    }
  }

  protected AlignFrame getRequestingAlignFrame()
  {
    return this.alignFrame;
  }
}