package jalview.schemes;

import jalview.datamodel.AnnotatedCollectionI;
import jalview.datamodel.SequenceCollectionI;
import jalview.datamodel.SequenceI;

import java.util.LinkedHashMap;
import java.util.Map;

public class ColourSchemes
{
  /*
   * singleton instance of this class
   */
  private static ColourSchemes instance = new ColourSchemes();

  /*
   * a map from scheme name to an instance of it
   */
  private Map<String, ColourSchemeI> schemes;

  /**
   * Returns the singleton instance of this class
   * 
   * @return
   */
  public static ColourSchemes getInstance()
  {
    return instance;
  }

  private ColourSchemes()
  {
    loadColourSchemes();
  }

  /**
   * Loads an instance of each standard or user-defined colour scheme
   * 
   * @return
   */
  void loadColourSchemes()
  {
    /*
     * store in an order-preserving map, so items can be added to menus 
     * in the order in which they are 'discovered'
     */
    schemes = new LinkedHashMap<String, ColourSchemeI>();

    for (JalviewColourScheme cs : JalviewColourScheme.values())
    {
      try
      {
        registerColourScheme(cs.getSchemeClass().newInstance());
      } catch (InstantiationException | IllegalAccessException e)
      {
        System.err.println("Error instantiating colour scheme for "
                + cs.toString() + " " + e.getMessage());
      }
    }
  }

  /**
   * Registers a colour scheme
   * 
   * @param cs
   */
  public void registerColourScheme(ColourSchemeI cs)
  {
    String name = cs.getSchemeName();
    if (name == null)
    {
      System.err.println("ColourScheme name may not be null");
      return;
    }

    /*
     * name is lower-case for non-case-sensitive lookup
     * (name in the colour keeps its true case)
     */
    String lower = name.toLowerCase();
    if (schemes.containsKey(lower))
    {
      System.err
              .println("Warning: overwriting colour scheme named " + name);
    }
    schemes.put(lower, cs);
  }

  /**
   * Removes a colour scheme by name
   * 
   * @param name
   */
  public void removeColourScheme(String name)
  {
    schemes.remove(name);
  }
  
  /**
   * Returns an instance of the colour scheme with which the given view may be
   * coloured
   * 
   * @param name
   *          name of the colour scheme
   * @param forData
   *          the data to be coloured
   * @param optional
   *          map from hidden representative sequences to the sequences they
   *          represent
   * @return
   */
  public ColourSchemeI getColourScheme(String name,
          AnnotatedCollectionI forData,
          Map<SequenceI, SequenceCollectionI> hiddenRepSequences)
  {
    if (name == null)
    {
      return null;
    }
    ColourSchemeI cs = schemes.get(name.toLowerCase());
    return cs == null ? null : cs.getInstance(forData, hiddenRepSequences);
  }

  /**
   * Returns an instance of the colour scheme with which the given view may be
   * coloured
   * 
   * @param name
   *          name of the colour scheme
   * @param forData
   *          the data to be coloured
   * @return
   */
  public ColourSchemeI getColourScheme(String name,
          AnnotatedCollectionI forData)
  {
    return getColourScheme(name, forData, null);
  }

  /**
   * Returns an iterable set of the colour schemes, in the order in which they
   * were added
   * 
   * @return
   */
  public Iterable<ColourSchemeI> getColourSchemes()
  {
    return schemes.values();
  }

  /**
   * Answers true if there is a scheme with the given name, else false. The test
   * is not case-sensitive.
   * 
   * @param name
   * @return
   */
  public boolean nameExists(String name)
  {
    if (name == null)
    {
      return false;
    }
    name = name.toLowerCase();
    for (ColourSchemeI scheme : getColourSchemes())
    {
      if (name.equals(scheme.getSchemeName().toLowerCase()))
      {
        return true;
      }
    }
    return false;
  }
}