package jalview.workers;

import java.util.ArrayList;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;

import jalview.api.AlignCalcManagerI;
import jalview.api.AlignCalcWorkerI;

public class AlignCalcManager implements AlignCalcManagerI
{
  private List<Class> blackList = new ArrayList<Class>();

  /**
   * global record of calculations in progress
   */
  private static Hashtable<Class, AlignCalcWorkerI> inProgress = new Hashtable<Class, AlignCalcWorkerI>();

  /**
   * record of calculations pending or in progress in the current context
   */
  private Map<Class, List<AlignCalcWorkerI>> updating = new Hashtable<Class, List<AlignCalcWorkerI>>();

  @Override
  public void notifyStart(AlignCalcWorkerI worker)
  {
    List<AlignCalcWorkerI> upd = updating.get(worker.getClass());
    if (upd == null)
    {
      updating.put(worker.getClass(),
              upd = new ArrayList<AlignCalcWorkerI>());
    }
    // upd.add(worker);
  }

  @Override
  public  synchronized boolean alreadyDoing(AlignCalcWorkerI worker)
  {
    return inProgress.containsKey(worker.getClass());
  }

  @Override
  public synchronized boolean notifyWorking(AlignCalcWorkerI worker)
  {
    // synchronized (inProgress)
    {
      // TODO: decide if we should throw exceptions here if multiple workers
      // start to work
      if (inProgress.get(worker.getClass()) != null)
      {
        if (false)
        {
          System.err
                  .println("Warning: Multiple workers are running of type "
                          + worker.getClass());
        }
        return false;
      }
      inProgress.put(worker.getClass(), worker);
    }
    return true;
  }

  @Override
  public synchronized void workerComplete(AlignCalcWorkerI worker)
  {
    inProgress.remove(worker.getClass());
    List<AlignCalcWorkerI> upd = updating.get(worker.getClass());
    if (upd != null)
    {
      upd.remove(worker);
    }

  }

  @Override
  public void workerCannotRun(AlignCalcWorkerI worker)
  {
    blackList.add(worker.getClass());
  }

  public boolean isBlackListed(Class workerType)
  {
    return blackList.contains(workerType);
  }

  @Override
  public void startWorker(AlignCalcWorkerI worker)
  {
    new Thread(worker).start();
  }

  @Override
  public synchronized boolean isWorking(AlignCalcWorkerI worker)
  {
//    System.err.println("isWorking : worker "+(worker!=null ? worker.getClass():"null")+ " "+hashCode());
    return worker!=null && inProgress.get(worker.getClass()) == worker;
  }
  @Override
  public boolean isWorking()
  {
//    System.err.println("isWorking "+hashCode());
    return inProgress.size()>0;
  }
}