package jalview.ext.archaeopteryx;

import jalview.datamodel.SequenceI;
import jalview.ext.treeviewer.TreeFrameI;
import jalview.ext.treeviewer.TreeI;
import jalview.ext.treeviewer.TreeNodeI;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.forester.archaeopteryx.Archaeopteryx;
import org.forester.io.writers.PhylogenyWriter;
import org.forester.phylogeny.Phylogeny;
import org.forester.phylogeny.PhylogenyMethods;
import org.forester.phylogeny.PhylogenyNode;

public class Tree implements TreeI
{
  private final Phylogeny tree;


  public Tree()
  {
    tree = new Phylogeny();
  }

  public Tree(Phylogeny aptxTree)
  {
    tree = aptxTree;
    wrapAllTreeNodes();

  }

  private void wrapAllTreeNodes()
  {
    for (Iterator<PhylogenyNode> iterator = tree
            .iteratorPostorder(); iterator.hasNext();)
    {
      PhylogenyNode foresterNode = iterator.next();
      TreeNodeI treeNode = TreeNode
              .getUniqueWrapper(foresterNode);

    }
  }

  @Override
  public TreeNodeI getRoot()
  {
    TreeNodeI root = TreeNode.getUniqueWrapper(tree.getRoot());
    return root;
  }

  @Override
  public void setTreeName(String name)
  {
    tree.setName(name);

  }

  @Override
  public TreeNodeI getNodeWithName(String name)
  {
    return TreeNode.getUniqueWrapper(tree.getNode(name));

  }

  @Override
  public String[] getAllLeafNames()
  {
    return tree.getAllExternalNodeNames();
  }

  @Override
  public void setRerootable(boolean b)
  {
    tree.setRerootable(b);

  }

  @Override
  public void setRooted(boolean b)
  {
    tree.setRooted(b);

  }

  @Override
  public boolean isEmpty()
  {
    return tree.isEmpty();
  }

  @Override
  public String getTreeName()
  {
    return tree.getName();
  }

  @Override
  public void setRoot(TreeNodeI rootNode)
  {
    PhylogenyNode treeRoot = TreeNode.unwrapNode(rootNode);
    tree.setRoot(treeRoot);
    wrapAllTreeNodes();

  }

  @Override
  public double getMaximumLength(boolean adjustForCollapsedSubtrees)
  {
    return tree.calculateHeight(adjustForCollapsedSubtrees);
  }

  @Override
  public Iterator<TreeNodeI> iterateInPreOrder()
  {
    Iterator<TreeNodeI> iter = new TreeIterator(
            tree.iteratorPreorder());
    return iter;
  }

  @Override
  public Iterator<TreeNodeI> iterateInLevelOrder()
  {
    Iterator<TreeNodeI> iter = new TreeIterator(
            tree.iteratorLevelOrder());
    return iter;
  }

  @Override
  public Iterator<TreeNodeI> iterateInPostOrder()
  {
    Iterator<TreeNodeI> iter = new TreeIterator(
            tree.iteratorPostorder());
    return iter;
  }

  @Override
  public TreeNodeI getFurthestNode()
  {
    PhylogenyNode furthestNode = PhylogenyMethods
            .calculateNodeWithMaxDistanceToRoot(tree);
    return TreeNode.getUniqueWrapper(furthestNode);
  }

  @Override
  public TreeFrameI createTreeViewerFromTree(String instanceTitle)
  {
    return new AptxFrame(Archaeopteryx.createApplication(tree,
            AptxInit.APTX_CONFIG,
            instanceTitle));
  }

  @Override
  public List<SequenceI> getNodeSequences()
  {
    List<SequenceI> treeSeqs = new ArrayList<>();
    Iterator<TreeNodeI> iter = iterateInPreOrder();
    while (iter.hasNext())
    {

      SequenceI nodeSeq = iter.next().getSequence();
      if (nodeSeq != null)
      {
        treeSeqs.add(nodeSeq);
      }
    }
    return treeSeqs;
  }

  @Override
  public TreeNodeI[] getAllNodes()
  {
    TreeNodeI[] treeNodes = new TreeNodeI[tree.getNodeCount()];
    Iterator<TreeNodeI> iter = iterateInPreOrder();
    int i = 0;
    while (iter.hasNext())
    {
      treeNodes[i++] = iter.next();
    }
    return treeNodes;
  }

  @Override
  public void outputAsFile(File outputFile) throws IOException
  {
    PhylogenyWriter treeWriter = new PhylogenyWriter();
    treeWriter.toPhyloXML(tree, 0, outputFile);


  }

}