package ext.edu.ucsf.rbvi.strucviz2;

import java.awt.Color;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import ext.edu.ucsf.rbvi.strucviz2.StructureManager.ModelType;
import ext.edu.ucsf.rbvi.strucviz2.port.ListenerThreads;

/**
 * This object maintains the Chimera communication information.
 */
public class ChimeraManager
{

  static private Process chimera;

  static private ListenerThreads chimeraListenerThreads;

  static private Map<Integer, ChimeraModel> currentModelsMap;

  private static Logger logger = LoggerFactory
          .getLogger(ext.edu.ucsf.rbvi.strucviz2.ChimeraManager.class);

  private StructureManager structureManager;

  public ChimeraManager(StructureManager structureManager)
  {
    this.structureManager = structureManager;
    chimera = null;
    chimeraListenerThreads = null;
    currentModelsMap = new HashMap<Integer, ChimeraModel>();
    
  }

  public List<ChimeraModel> getChimeraModels(String modelName)
  {
    List<ChimeraModel> models = getChimeraModels(modelName,
            ModelType.PDB_MODEL);
    models.addAll(getChimeraModels(modelName, ModelType.SMILES));
    return models;
  }

  public List<ChimeraModel> getChimeraModels(String modelName,
          ModelType modelType)
  {
    List<ChimeraModel> models = new ArrayList<ChimeraModel>();
    for (ChimeraModel model : currentModelsMap.values())
    {
      if (modelName.equals(model.getModelName())
              && modelType.equals(model.getModelType()))
      {
        models.add(model);
      }
    }
    return models;
  }

  public Map<String, List<ChimeraModel>> getChimeraModelsMap()
  {
    Map<String, List<ChimeraModel>> models = new HashMap<String, List<ChimeraModel>>();
    for (ChimeraModel model : currentModelsMap.values())
    {
      String modelName = model.getModelName();
      if (!models.containsKey(modelName))
      {
        models.put(modelName, new ArrayList<ChimeraModel>());
      }
      if (!models.get(modelName).contains(model))
      {
        models.get(modelName).add(model);
      }
    }
    return models;
  }

  public ChimeraModel getChimeraModel(Integer modelNumber,
          Integer subModelNumber)
  {
    Integer key = ChimUtils.makeModelKey(modelNumber, subModelNumber);
    if (currentModelsMap.containsKey(key))
    {
      return currentModelsMap.get(key);
    }
    return null;
  }

  public ChimeraModel getChimeraModel()
  {
    return currentModelsMap.values().iterator().next();
  }

  public Collection<ChimeraModel> getChimeraModels()
  {
    // this method is invoked by the model navigator dialog
    return currentModelsMap.values();
  }

  public int getChimeraModelsCount(boolean smiles)
  {
    // this method is invokes by the model navigator dialog
    int counter = currentModelsMap.size();
    if (smiles)
    {
      return counter;
    }

    for (ChimeraModel model : currentModelsMap.values())
    {
      if (model.getModelType() == ModelType.SMILES)
      {
        counter--;
      }
    }
    return counter;
  }

  public boolean hasChimeraModel(Integer modelNubmer)
  {
    return hasChimeraModel(modelNubmer, 0);
  }

  public boolean hasChimeraModel(Integer modelNubmer, Integer subModelNumber)
  {
    return currentModelsMap.containsKey(ChimUtils.makeModelKey(modelNubmer,
            subModelNumber));
  }

  public void addChimeraModel(Integer modelNumber, Integer subModelNumber,
          ChimeraModel model)
  {
    currentModelsMap.put(
            ChimUtils.makeModelKey(modelNumber, subModelNumber), model);
  }

  public void removeChimeraModel(Integer modelNumber, Integer subModelNumber)
  {
    int modelKey = ChimUtils.makeModelKey(modelNumber, subModelNumber);
    if (currentModelsMap.containsKey(modelKey))
    {
      currentModelsMap.remove(modelKey);
    }
  }

  public List<ChimeraModel> openModel(String modelPath, ModelType type)
  {
    logger.info("chimera open " + modelPath);
    stopListening();
    List<String> response = null;
    // TODO: [Optional] Handle modbase models
    if (type == ModelType.MODBASE_MODEL)
    {
      response = sendChimeraCommand("open modbase:" + modelPath, true);
      // } else if (type == ModelType.SMILES) {
      // response = sendChimeraCommand("open smiles:" + modelName, true);
      // modelName = "smiles:" + modelName;
    }
    else
    {
      response = sendChimeraCommand("open " + modelPath, true);
    }
    if (response == null)
    {
      // something went wrong
      logger.warn("Could not open " + modelPath);
      return null;
    }
    List<ChimeraModel> models = new ArrayList<ChimeraModel>();
    int[] modelNumbers = null;
    if (type == ModelType.PDB_MODEL)
    {
      for (String line : response)
      {
        if (line.startsWith("#"))
        {
          modelNumbers = ChimUtils.parseOpenedModelNumber(line);
          if (modelNumbers != null)
          {
            int modelNumber = ChimUtils.makeModelKey(modelNumbers[0],
                    modelNumbers[1]);
            if (currentModelsMap.containsKey(modelNumber))
            {
              continue;
            }
            String modelName = modelPath;
            // TODO: [Optional] Convert path to name in a better way
            if (modelPath.lastIndexOf(File.separator) > 0)
            {
              modelName = modelPath.substring(modelPath
                      .lastIndexOf(File.separator) + 1);
            }
            else if (modelPath.lastIndexOf("/") > 0)
            {
              modelName = modelPath
                      .substring(modelPath.lastIndexOf("/") + 1);
            }
            ChimeraModel newModel = new ChimeraModel(modelName, type,
                    modelNumbers[0], modelNumbers[1]);
            currentModelsMap.put(modelNumber, newModel);
            models.add(newModel);
            modelNumbers = null;
          }
        }
      }
    }
    else
    {
      // TODO: [Optional] Open smiles from file would fail. Do we need it?
      // If parsing fails, iterate over all open models to get the right one
      List<ChimeraModel> openModels = getModelList();
      for (ChimeraModel openModel : openModels)
      {
        String openModelName = openModel.getModelName();
        if (openModelName.endsWith("..."))
        {
          openModelName = openModelName.substring(0,
                  openModelName.length() - 3);
        }
        if (modelPath.startsWith(openModelName))
        {
          openModel.setModelName(modelPath);
          int modelNumber = ChimUtils
                  .makeModelKey(openModel.getModelNumber(),
                          openModel.getSubModelNumber());
          if (!currentModelsMap.containsKey(modelNumber))
          {
            currentModelsMap.put(modelNumber, openModel);
            models.add(openModel);
          }
        }
      }
    }

    // assign color and residues to open models
    for (ChimeraModel newModel : models)
    {
      // get model color
      Color modelColor = getModelColor(newModel);
      if (modelColor != null)
      {
        newModel.setModelColor(modelColor);
      }

      // Get our properties (default color scheme, etc.)
      // Make the molecule look decent
      // chimeraSend("repr stick "+newModel.toSpec());

      // Create the information we need for the navigator
      if (type != ModelType.SMILES)
      {
        addResidues(newModel);
      }
    }

    sendChimeraCommand("focus", false);
    startListening();
    return models;
  }

  public void closeModel(ChimeraModel model)
  {
    // int model = structure.modelNumber();
    // int subModel = structure.subModelNumber();
    // Integer modelKey = makeModelKey(model, subModel);
    stopListening();
    logger.info("chimera close model " + model.getModelName());
    if (currentModelsMap.containsKey(ChimUtils.makeModelKey(
            model.getModelNumber(), model.getSubModelNumber())))
    {
      sendChimeraCommand("close " + model.toSpec(), false);
      // currentModelNamesMap.remove(model.getModelName());
      currentModelsMap.remove(ChimUtils.makeModelKey(
              model.getModelNumber(), model.getSubModelNumber()));
      // selectionList.remove(chimeraModel);
    }
    else
    {
      logger.warn("Could not find model " + model.getModelName()
              + " to close.");
    }
    startListening();
  }

  public void startListening()
  {
    sendChimeraCommand("listen start models; listen start select", false);
  }

  public void stopListening()
  {
    sendChimeraCommand("listen stop models; listen stop select", false);
  }

  /**
   * Select something in Chimera
   * 
   * @param command
   *          the selection command to pass to Chimera
   */
  public void select(String command)
  {
    sendChimeraCommand("listen stop select; " + command
            + "; listen start select", false);
  }

  public void focus()
  {
    sendChimeraCommand("focus", false);
  }

  public void clearOnChimeraExit()
  {
    chimera = null;
    currentModelsMap.clear();
    chimeraListenerThreads = null;
    structureManager.clearOnChimeraExit();
  }

  public void exitChimera()
  {
    if (isChimeraLaunched() && chimera != null)
    {
      sendChimeraCommand("stop really", false);
      try
      {
        chimera.destroy();
      } catch (Exception ex)
      {
        // ignore
      }
    }
    clearOnChimeraExit();
  }

  public Map<Integer, ChimeraModel> getSelectedModels()
  {
    Map<Integer, ChimeraModel> selectedModelsMap = new HashMap<Integer, ChimeraModel>();
    List<String> chimeraReply = sendChimeraCommand(
            "list selection level molecule", true);
    if (chimeraReply != null)
    {
      for (String modelLine : chimeraReply)
      {
        ChimeraModel chimeraModel = new ChimeraModel(modelLine);
        Integer modelKey = ChimUtils.makeModelKey(
                chimeraModel.getModelNumber(),
                chimeraModel.getSubModelNumber());
        selectedModelsMap.put(modelKey, chimeraModel);
      }
    }
    return selectedModelsMap;
  }

  public List<String> getSelectedResidueSpecs()
  {
    List<String> selectedResidues = new ArrayList<String>();
    List<String> chimeraReply = sendChimeraCommand(
            "list selection level residue", true);
    if (chimeraReply != null)
    {
      for (String inputLine : chimeraReply)
      {
        String[] inputLineParts = inputLine.split("\\s+");
        if (inputLineParts.length == 5)
        {
          selectedResidues.add(inputLineParts[2]);
        }
      }
    }
    return selectedResidues;
  }

  public void getSelectedResidues(
          Map<Integer, ChimeraModel> selectedModelsMap)
  {
    List<String> chimeraReply = sendChimeraCommand(
            "list selection level residue", true);
    if (chimeraReply != null)
    {
      for (String inputLine : chimeraReply)
      {
        ChimeraResidue r = new ChimeraResidue(inputLine);
        Integer modelKey = ChimUtils.makeModelKey(r.getModelNumber(),
                r.getSubModelNumber());
        if (selectedModelsMap.containsKey(modelKey))
        {
          ChimeraModel model = selectedModelsMap.get(modelKey);
          model.addResidue(r);
        }
      }
    }
  }

  /**
   * Return the list of ChimeraModels currently open. Warning: if smiles model
   * name too long, only part of it with "..." is printed.
   * 
   * 
   * @return List of ChimeraModel's
   */
  // TODO: [Optional] Handle smiles names in a better way in Chimera?
  public List<ChimeraModel> getModelList()
  {
    List<ChimeraModel> modelList = new ArrayList<ChimeraModel>();
    List<String> list = sendChimeraCommand("list models type molecule",
            true);
    if (list != null)
    {
      for (String modelLine : list)
      {
        ChimeraModel chimeraModel = new ChimeraModel(modelLine);
        modelList.add(chimeraModel);
      }
    }
    return modelList;
  }

  /**
   * Return the list of depiction presets available from within Chimera. Chimera
   * will return the list as a series of lines with the format: Preset type
   * number "description"
   * 
   * @return list of presets
   */
  public List<String> getPresets()
  {
    ArrayList<String> presetList = new ArrayList<String>();
    List<String> output = sendChimeraCommand("preset list", true);
    if (output != null)
    {
      for (String preset : output)
      {
        preset = preset.substring(7); // Skip over the "Preset"
        preset = preset.replaceFirst("\"", "(");
        preset = preset.replaceFirst("\"", ")");
        // string now looks like: type number (description)
        presetList.add(preset);
      }
    }
    return presetList;
  }

  public boolean isChimeraLaunched()
  {
    // TODO: [Optional] What is the best way to test if chimera is launched?

    // sendChimeraCommand("test", true) !=null
    if (chimera != null)
    {
      return true;
    }
    return false;
  }

  public boolean launchChimera(List<String> chimeraPaths)
  {
    // Do nothing if Chimera is already launched
    if (isChimeraLaunched())
    {
      return true;
    }

    // Try to launch Chimera (eventually using one of the possible paths)
    String error = "Error message: ";
    String workingPath = "";
    // iterate over possible paths for starting Chimera
    for (String chimeraPath : chimeraPaths)
    {
      File path = new File(chimeraPath);
      if (!path.canExecute())
      {
        error += "File '" + path + "' does not exist.\n";
        continue;
      }
      try
      {
        List<String> args = new ArrayList<String>();
        args.add(chimeraPath);
        args.add("--start");
        args.add("ReadStdin");
        ProcessBuilder pb = new ProcessBuilder(args);
        chimera = pb.start();
        error = "";
        workingPath = chimeraPath;
        logger.info("Strarting " + chimeraPath);
        break;
      } catch (Exception e)
      {
        // Chimera could not be started
        error += e.getMessage();
      }
    }
    // If no error, then Chimera was launched successfully
    if (error.length() == 0)
    {
      // Initialize the listener threads
      chimeraListenerThreads = new ListenerThreads(chimera,
              structureManager);
      chimeraListenerThreads.start();
      // structureManager.initChimTable();
      structureManager.setChimeraPathProperty(workingPath);
      // TODO: [Optional] Check Chimera version and show a warning if below 1.8
      // Ask Chimera to give us updates
      startListening();
      return true;
    }

    // Tell the user that Chimera could not be started because of an error
    logger.warn(error);
    return false;
  }

  /**
   * Determine the color that Chimera is using for this model.
   * 
   * @param model
   *          the ChimeraModel we want to get the Color for
   * @return the default model Color for this model in Chimera
   */
  public Color getModelColor(ChimeraModel model)
  {
    List<String> colorLines = sendChimeraCommand(
            "list model spec " + model.toSpec() + " attribute color", true);
    if (colorLines == null || colorLines.size() == 0)
    {
      return null;
    }
    return ChimUtils.parseModelColor((String) colorLines.get(0));
  }

  /**
   * 
   * Get information about the residues associated with a model. This uses the
   * Chimera listr command. We don't return the resulting residues, but we add
   * the residues to the model.
   * 
   * @param model
   *          the ChimeraModel to get residue information for
   * 
   */
  public void addResidues(ChimeraModel model)
  {
    int modelNumber = model.getModelNumber();
    int subModelNumber = model.getSubModelNumber();
    // Get the list -- it will be in the reply log
    List<String> reply = sendChimeraCommand(
            "list residues spec " + model.toSpec(), true);
    if (reply == null)
    {
      return;
    }
    for (String inputLine : reply)
    {
      ChimeraResidue r = new ChimeraResidue(inputLine);
      if (r.getModelNumber() == modelNumber
              || r.getSubModelNumber() == subModelNumber)
      {
        model.addResidue(r);
      }
    }
  }

  public List<String> getAttrList()
  {
    List<String> attributes = new ArrayList<String>();
    final List<String> reply = sendChimeraCommand("list resattr", true);
    if (reply != null)
    {
      for (String inputLine : reply)
      {
        String[] lineParts = inputLine.split("\\s");
        if (lineParts.length == 2 && lineParts[0].equals("resattr"))
        {
          attributes.add(lineParts[1]);
        }
      }
    }
    return attributes;
  }

  public Map<ChimeraResidue, Object> getAttrValues(String aCommand,
          ChimeraModel model)
  {
    Map<ChimeraResidue, Object> values = new HashMap<ChimeraResidue, Object>();
    final List<String> reply = sendChimeraCommand("list residue spec "
            + model.toSpec() + " attribute " + aCommand, true);
    if (reply != null)
    {
      for (String inputLine : reply)
      {
        String[] lineParts = inputLine.split("\\s");
        if (lineParts.length == 5)
        {
          ChimeraResidue residue = ChimUtils
                  .getResidue(lineParts[2], model);
          String value = lineParts[4];
          if (residue != null)
          {
            if (value.equals("None"))
            {
              continue;
            }
            if (value.equals("True") || value.equals("False"))
            {
              values.put(residue, Boolean.valueOf(value));
              continue;
            }
            try
            {
              Double doubleValue = Double.valueOf(value);
              values.put(residue, doubleValue);
            } catch (NumberFormatException ex)
            {
              values.put(residue, value);
            }
          }
        }
      }
    }
    return values;
  }

  /**
   * Send a command to Chimera.
   * 
   * @param command
   *          Command string to be send.
   * @param reply
   *          Flag indicating whether the method should return the reply from
   *          Chimera or not.
   * @return List of Strings corresponding to the lines in the Chimera reply or
   *         <code>null</code>.
   */
  public List<String> sendChimeraCommand(String command, boolean reply)
  {
    if (!isChimeraLaunched())
    {
      return null;
    }

    chimeraListenerThreads.clearResponse(command);
    String text = command.concat("\n");
    // System.out.println("send command to chimera: " + text);
    try
    {
      // send the command
      chimera.getOutputStream().write(text.getBytes());
      chimera.getOutputStream().flush();
    } catch (IOException e)
    {
      // logger.info("Unable to execute command: " + text);
      // logger.info("Exiting...");
      logger.warn("Unable to execute command: " + text);
      logger.warn("Exiting...");
      clearOnChimeraExit();
      return null;
    }
    if (!reply)
    {
      return null;
    }
    return chimeraListenerThreads.getResponse(command);
  }

  public StructureManager getStructureManager()
  {
    return structureManager;
  }

}