package jalview.api;

import java.util.List;

import jalview.datamodel.AlignmentAnnotation;
import jalview.ws.jws2.AAConsClient;

public interface AlignCalcManagerI
{


  /**
   * tell manager that a worker is initialised and has started to run
   * @param worker
   */
  void notifyStart(AlignCalcWorkerI worker);

  /**
   * check if a calculation of this type is already active
   * @param worker
   * @return
   */
  boolean alreadyDoing(AlignCalcWorkerI worker);

  /**
   * tell manager that worker is now processing data
   * @param worker
   */
  boolean notifyWorking(AlignCalcWorkerI worker);


  /**
   * notify manager that the worker has completed, and results may be ready to collect
   * @param worker
   */
  void workerComplete(AlignCalcWorkerI worker);

  /**
   * indicate that a worker like this cannot run on the platform and shouldn't be started again
   * @param worker
   */
  void workerCannotRun(AlignCalcWorkerI worker);

  /**
   * indicate that a worker like this may be run on the platform.
   * @param worker of class to be removed from the execution blacklist
   */
  void workerMayRun(AlignCalcWorkerI worker);
  /**
   * launch a new worker
   * @param worker
   */
  void startWorker(AlignCalcWorkerI worker);

  /**
   *
   * @param worker
   * @return
   */
  boolean isWorking(AlignCalcWorkerI worker);

  /**
   * if any worker thread is operational, return true!
   * @return
   */
  boolean isWorking();


  /**
   * register a restartable worker
   * @param worker
   */
  void registerWorker(AlignCalcWorkerI worker);

  /**
   * restart any registered workers
   */
  void restartWorkers();

  /**
   *
   * @param alignmentAnnotation
   * @return true if a currently registered and working worker indicates its involvement with the given alignmentAnnotation
   */
  boolean workingInvolvedWith(AlignmentAnnotation alignmentAnnotation);

  /**
   * kick any known instances of the given worker class to update their annotation
   * @param workerClass
   */
  void updateAnnotationFor(Class workerClass);

  /**
   * return any registered workers of the given class
   * @param workerClass
   * @return null or one or more workers of the given class
   */
  List<AlignCalcWorkerI> getRegisteredWorkersOfClass(
          Class workerClass);

  /**
   * start any workers of the given class
   * @param workerClass
   * @return false if no workers of given class were registered
   * (note - blacklisted classes cannot be restarted, so this method will return true for blacklisted workers)
   */
  boolean startRegisteredWorkersOfClass(Class workerClass);

  /**
   * work out if there is an instance of a worker that is *waiting* to start
   * calculating
   *
   * @param workingClass
   * @return true if workingClass is already waiting to calculate. false if it
   *         is calculating, or not queued.
   */
  boolean isPending(AlignCalcWorkerI workingClass);

  /**
   * deregister and otherwise remove any registered and working instances of the given worker type
   * @param typeToRemove
   */
  void removeRegisteredWorkersOfClass(Class typeToRemove);

}