#include <queue>

#include <iostream>
#include <ostream>
#include <fstream>

#include "ConstraintTree.h"
#include "Util.h"


namespace Horus {

class CTNode {
  public:
    CTNode (const CTNode& n, const CTChilds& chs = CTChilds()) 
        : symbol_(n.symbol()), childs_(chs), level_(n.level()) { }

    CTNode (Symbol s, unsigned l, const CTChilds& chs = CTChilds())
        : symbol_(s), childs_(chs), level_(l) { }

    unsigned level() const { return level_; }

    void setLevel (unsigned level) { level_ = level; }

    Symbol symbol() const { return symbol_; }

    void setSymbol (Symbol s) { symbol_ = s; }

    CTChilds& childs() { return childs_; }

    const CTChilds& childs() const { return childs_; }

    size_t nrChilds() const { return childs_.size(); }

    bool isRoot() const { return level_ == 0; }

    bool isLeaf() const { return childs_.empty(); }

    CTChilds::iterator findSymbol (Symbol symb);

    void mergeSubtree (CTNode*, bool = true);

    void removeChild (CTNode*);

    void removeChilds();

    void removeAndDeleteChild (CTNode*);

    void removeAndDeleteAllChilds();

    SymbolSet childSymbols() const;

    static CTNode* copySubtree (const CTNode*);

    static void deleteSubtree (CTNode*);

  private:
    void updateChildLevels (CTNode*, unsigned);

    Symbol     symbol_;
    CTChilds   childs_;
    unsigned   level_;

    DISALLOW_ASSIGN (CTNode);
};



inline CTChilds::iterator
CTNode::findSymbol (Symbol symb)
{
  CTNode tmp (symb, 0);
  return childs_.find (&tmp);
}



inline bool
CmpSymbol::operator() (const CTNode* n1, const CTNode* n2) const
{
  return n1->symbol() < n2->symbol();
}



void
CTNode::mergeSubtree (CTNode* n, bool updateLevels)
{
  if (updateLevels) {
    updateChildLevels (n, level_ + 1);
  }
  CTChilds::iterator chIt = childs_.find (n);
  if (chIt != childs_.end()) {
    assert ((*chIt)->symbol() == n->symbol());
    const CTChilds& childsToAdd = n->childs();
    for (CTChilds::const_iterator it = childsToAdd.begin();
         it != childsToAdd.end(); ++ it) {
      (*chIt)->mergeSubtree (*it, false);
    }
    delete n;
  } else {
    childs_.insert (n);
  }
}



void
CTNode::removeChild (CTNode* child)
{
  assert (childs_.contains (child));
  childs_.remove (child);
}



void
CTNode::removeChilds()
{
  childs_.clear();
}



void
CTNode::removeAndDeleteChild (CTNode* child)
{
  removeChild (child);
  CTNode::deleteSubtree (child);
}



void
CTNode::removeAndDeleteAllChilds()
{
  for (CTChilds::const_iterator chIt = childs_.begin();
       chIt != childs_.end(); ++ chIt) {
    deleteSubtree (*chIt);
  }
  childs_.clear();
}



SymbolSet
CTNode::childSymbols() const
{
  SymbolSet symbols;
  for (CTChilds::const_iterator chIt = childs_.begin();
       chIt != childs_.end(); ++ chIt) {
    symbols.insert ((*chIt)->symbol());
  }
  return symbols;
}



void
CTNode::updateChildLevels (CTNode* n, unsigned level)
{
  CTNodes stack;
  stack.push_back (n);
  n->setLevel (level);
  while (stack.empty() == false) {
    CTNode* node = stack.back();
    stack.pop_back();
    for (CTChilds::const_iterator chIt = node->childs().begin();
         chIt != node->childs().end(); ++ chIt) {
      (*chIt)->setLevel (node->level() + 1);
    }
    stack.insert (stack.end(), node->childs().begin(),
        node->childs().end());
  }
}



CTNode*
CTNode::copySubtree (const CTNode* root1)
{
  if (root1->childs().empty()) {
    return new CTNode (*root1);
  }
  CTNode* root2 = new CTNode (*root1);
  typedef std::pair<const CTNode*, CTNode*> StackPair;
  std::vector<StackPair> stack = { StackPair (root1, root2) };
  while (stack.empty() == false) {
    const CTNode* n1 = stack.back().first;
    CTNode* n2 = stack.back().second;
    stack.pop_back();
    // std::cout << "n2 childs: " << n2->childs();
    // std::cout << "n1 childs: " << n1->childs();
    n2->childs().reserve (n1->nrChilds());
    stack.reserve (n1->nrChilds());
    for (CTChilds::const_iterator chIt = n1->childs().begin();
         chIt != n1->childs().end(); ++ chIt) {
      CTNode* chCopy = new CTNode (**chIt);
      n2->childs().insert_sorted (chCopy);
      if ((*chIt)->nrChilds() > 0) {
        stack.push_back (StackPair (*chIt, chCopy));
      }
    }
  }
  return root2;
}



void
CTNode::deleteSubtree (CTNode* n)
{
  assert (n);
  const CTChilds& childs = n->childs();
  for (CTChilds::const_iterator chIt = childs.begin();
       chIt != childs.end(); ++ chIt) {
    deleteSubtree (*chIt);
  }
  delete n;
}



std::ostream&
operator<< (std::ostream& out, const CTNode& n)
{
  out << "(" << n.level() << ") " ;
  out << n.symbol();
  return out;
}



ConstraintTree::ConstraintTree (unsigned nrLvs)
{
  for (unsigned i = 0; i < nrLvs; i++) {
    logVars_.push_back (LogVar (i));
  }
  root_      = new CTNode (0, 0);
  logVarSet_ = LogVarSet (logVars_);
}



ConstraintTree::ConstraintTree (const LogVars& logVars)
{
  root_      = new CTNode (0, 0);
  logVars_   = logVars;
  logVarSet_ = LogVarSet (logVars);
}



ConstraintTree::ConstraintTree (
    const LogVars& logVars,
    const Tuples&  tuples)
{
  root_      = new CTNode (0, 0);
  logVars_   = logVars;
  logVarSet_ = LogVarSet (logVars);
  for (size_t i = 0; i < tuples.size(); i++) {
    addTuple (tuples[i]);
  }
}



ConstraintTree::ConstraintTree (
     std::vector<std::vector<std::string>> names)
{
  assert (names.empty() == false);
  assert (names.front().empty() == false);
  unsigned nrLvs = names[0].size();
  for (size_t i = 0; i < nrLvs; i++) {
    logVars_.push_back (LogVar (i));
  }
  root_      = new CTNode (0, 0);
  logVarSet_ = LogVarSet (logVars_);
  for (size_t i = 0; i < names.size(); i++) {
    Tuple t;
    for (size_t j = 0; j < names[i].size(); j++) {
      assert (names[i].size() == nrLvs);
      t.push_back (LiftedUtils::getSymbol (names[i][j]));
    }
    addTuple (t);
  }
}



ConstraintTree::ConstraintTree (const ConstraintTree& ct)
{
  *this = ct;
}



ConstraintTree::ConstraintTree (
    const CTChilds& rootChilds,
    const LogVars& logVars)
        : root_(new CTNode (Symbol (0), unsigned (0), rootChilds)),
          logVars_(logVars),
          logVarSet_(logVars)
{

}



ConstraintTree::~ConstraintTree()
{
  CTNode::deleteSubtree (root_);
}



bool
ConstraintTree::empty() const
{
  return root_->childs().empty();
}



void
ConstraintTree::addTuple (const Tuple& tuple)
{
  CTNode* prevNode = root_;
  for (size_t i = 0; i < tuple.size(); i++) {
    CTChilds::const_iterator it = prevNode->findSymbol (tuple[i]);
    if (it == prevNode->childs().end()) {
      CTNode* newNode = new CTNode (tuple[i], i + 1);
      prevNode->mergeSubtree (newNode, false);
      prevNode = newNode;
    } else {
      prevNode  = *it;
    }
  }
}



bool
ConstraintTree::containsTuple (const Tuple& tuple)
{
	CTNode* prevNode = root_;
  for (size_t i = 0; i < tuple.size(); i++) {
    CTChilds::const_iterator it = prevNode->findSymbol (tuple[i]);
    if (it == prevNode->childs().end()) {
      return false;
    } else {
      prevNode = *it;
    }
  }
  return true;
}



void
ConstraintTree::moveToTop (const LogVars& lvs)
{
  for (size_t i = 0; i < lvs.size(); i++) {
    size_t pos = Util::indexOf (logVars_, lvs[i]);
    assert (pos != logVars_.size());
    for (size_t j = pos; j-- > i; ) {
      swapLogVar (logVars_[j]);
    }
  }
}



void
ConstraintTree::moveToBottom (const LogVars& lvs)
{
  for (size_t i = lvs.size(); i-- > 0; ) {
    size_t pos = Util::indexOf (logVars_, lvs[i]);
    assert (pos != logVars_.size());
    size_t stop = logVars_.size() - (lvs.size() - i - 1);
    for (size_t j = pos; j < stop - 1; j++) {
      swapLogVar (logVars_[j]);
    }
  }
}



void
ConstraintTree::join (ConstraintTree* ct, bool oneTwoOne)
{
  if (logVarSet_.empty()) {
    CTNode::deleteSubtree (root_);
    root_      = CTNode::copySubtree (ct->root());
    logVars_   = ct->logVars();
    logVarSet_ = ct->logVarSet();
    return;
  }
  if (oneTwoOne) {
    if (logVarSet_.contains (ct->logVarSet())) {
      return;
    }
    if (ct->logVarSet().contains (logVarSet_)) {
      CTNode::deleteSubtree (root_);
      root_      = CTNode::copySubtree (ct->root());
      logVars_   = ct->logVars();
      logVarSet_ = ct->logVarSet();
      return;
    }
  }
  LogVarSet intersect = logVarSet_ & ct->logVarSet_;
  if (intersect.empty()) {
    // cartesian product
    appendOnBottom (root_, ct->root()->childs());
    Util::addToVector (logVars_, ct->logVars_);
    logVarSet_ |= ct->logVarSet_;
  } else {
    moveToTop (intersect.elements());
    ct->moveToTop (intersect.elements());

    Tuples tuples;
    CTNodes appendNodes;
    getTuples (ct->root(), Tuples(), intersect.size(),
        tuples, appendNodes);

    CTNodes::const_iterator appendIt = appendNodes.begin();
    for (size_t i = 0; i < tuples.size(); ++ i, ++ appendIt) {
      bool tupleFounded = join (root_, tuples[i], 0, *appendIt);
      if (oneTwoOne && tupleFounded == false) {
        assert (false);
      }
    }

    LogVars newLvs (ct->logVars().begin() + intersect.size(), 
                    ct->logVars().end());
    Util::addToVector (logVars_, newLvs);
    logVarSet_ |= LogVarSet (newLvs);
  }
}



unsigned
ConstraintTree::getLevel (LogVar X) const
{
  unsigned level = Util::indexOf (logVars_, X);
  level += 1; // root is in level 0, first logVar is in level 1
  return level;
}



void
ConstraintTree::rename (LogVar X_old, LogVar X_new)
{
  assert (logVarSet_.contains (X_old));
  assert (logVarSet_.contains (X_new) == false);
  logVarSet_ -= X_old;
  logVarSet_ |= X_new;
  for (size_t i = 0; i < logVars_.size(); i++) {
    if (logVars_[i] == X_old) {
      logVars_[i] = X_new;
      return;
    }
  }
  assert (false);
}



void
ConstraintTree::applySubstitution (const Substitution& theta)
{
  for (size_t i = 0; i < logVars_.size(); i++) {
    logVars_[i] = theta.newNameFor (logVars_[i]);
  }
  logVarSet_ = LogVarSet (logVars_);
}



void
ConstraintTree::project (const LogVarSet& X)
{
  assert (logVarSet_.contains (X));
  remove ((logVarSet_ - X));
}



ConstraintTree
ConstraintTree::projectedCopy (const LogVarSet& X)
{
  ConstraintTree copy = *this;
  copy.project (X);
  return copy;
}



void
ConstraintTree::remove (const LogVarSet& X)
{
  assert (logVarSet_.contains (X));
  if (X.empty()) {
    return;
  }
  moveToBottom (X.elements());
  unsigned level = getLevel (X.front()) - 1;
  CTNodes nodes = getNodesAtLevel (level);
  for (CTNodes::const_iterator it = nodes.begin();
       it != nodes.end(); ++ it) {
    (*it)->removeAndDeleteAllChilds();
  }
  logVars_.resize (logVars_.size() - X.size());
  logVarSet_ -= X;
}



bool
ConstraintTree::ConstraintTree::isSingleton (LogVar X)
{
  Symbol symb;
  unsigned level = getLevel (X);
  CTNodes stack;
  stack.push_back (root_);
  while (stack.empty() == false) {
    CTNode* node = stack.back();
    stack.pop_back();
    if (node->level() == level) {
      if (symb.valid()) {
        if (node->symbol() != symb) {
          return false;
        }
      } else {
        symb = node->symbol();
      }
    } else {
      stack.insert (stack.end(), node->childs().begin(),
          node->childs().end());
    }
  }
  return true;
}



LogVarSet
ConstraintTree::singletons()
{
  LogVarSet singletons;
  for (size_t i = 0; i < logVars_.size(); i++) {
    if (isSingleton (logVars_[i])) {
      singletons.insert (logVars_[i]);
    }
  }
  return singletons;
}



TupleSet
ConstraintTree::tupleSet (unsigned stopLevel) const
{
  assert (root_->isRoot());
  Tuples tuples;
  if (stopLevel == 0) {
    stopLevel = logVars_.size();
  }
  getTuples (root_, Tuples(), stopLevel, tuples, CTNodes() = {});
  return TupleSet (tuples);
}



TupleSet
ConstraintTree::tupleSet (const LogVars& originalLvs)
{
  LogVars uniqueLvs;
  for (size_t i = 0; i < originalLvs.size(); i++) {
    if (Util::contains (uniqueLvs, originalLvs[i]) == false) {
      uniqueLvs.push_back (originalLvs[i]);
    }
  }

  Tuples tuples;
  moveToTop (uniqueLvs);
  unsigned stopLevel = uniqueLvs.size();
  getTuples (root_, Tuples(), stopLevel, tuples, CTNodes() = {});

  if (originalLvs.size() != uniqueLvs.size()) {
    std::vector<size_t> indexes;
    indexes.reserve (originalLvs.size());
    for (size_t i = 0; i < originalLvs.size(); i++) {
      indexes.push_back (Util::indexOf (uniqueLvs, originalLvs[i]));
    }
    Tuples tuples2;
    tuples2.reserve (tuples.size());
    for (size_t i = 0; i < tuples.size(); i++) {
      Tuple t;
      t.reserve (originalLvs.size());
      for (size_t j = 0; j < originalLvs.size(); j++) {
        t.push_back (tuples[i][indexes[j]]);
      }
      tuples2.push_back (t);
    }
    return TupleSet (tuples2);
  }

  return TupleSet (tuples);
}



void
ConstraintTree::exportToGraphViz (
    const char* fileName,
    bool showLogVars) const
{
  std::ofstream out (fileName);
  if (!out.is_open()) {
    std::cerr << "Error: couldn't open file '" << fileName << "'." ;
    std::cerr << std::endl;
    return;
  }
  out << "digraph {" << std::endl;
  ConstraintTree copy (*this);
  copy.moveToTop (copy.logVarSet_.elements());
  CTNodes nodes = getNodesBelow (copy.root_);
  out << "\"" << copy.root_ << "\"" << " [label=\"R\"]" << std::endl;
  for (CTNodes::const_iterator it = ++ nodes.begin();
       it != nodes.end(); ++ it) {
    out << "\"" << *it << "\"";
    out << " [label=\"" << **it << "\"]" ;
    out << std::endl;
  }
  for (CTNodes::const_iterator it = nodes.begin();
       it != nodes.end(); ++ it) {
    const CTChilds& childs = (*it)->childs();
    for (CTChilds::const_iterator chIt = childs.begin();
         chIt != childs.end(); ++ chIt) {
      out << "\"" << *it << "\"" ;
      out << " -> " ;
      out << "\"" << *chIt << "\"" << std::endl ;
    }
  }
  if (showLogVars) {
    out << "Root [label=\"\", shape=plaintext]" << std::endl;
    for (size_t i = 0; i < copy.logVars_.size(); i++) {
      out << copy.logVars_[i] << " [label=" ;
      out << copy.logVars_[i] << ", " ;
      out << "shape=plaintext, fontsize=14]" << std::endl;
    }
   out << "Root -> " << copy.logVars_[0];
   out << " [style=invis]" << std::endl;
    for (size_t i = 0; i < copy.logVars_.size() - 1; i++) {
      out << copy.logVars_[i] << " -> " << copy.logVars_[i + 1];
      out << " [style=invis]" << std::endl;
    }
  }
  out << "}" <<std::endl;
  out.close();
}



bool
ConstraintTree::isCountNormalized (const LogVarSet& Ys)
{
  assert (logVarSet_.contains (Ys));
  if (Ys.empty()) {
    return true;
  }
  if (Ys.size() == logVars_.size()) {
    assert (LogVarSet (logVars_) == LogVarSet (Ys));
    return true;
  }
  LogVarSet Zs = logVarSet_ - LogVarSet (Ys);
  moveToTop (Zs.elements());
  CTNodes nodes = getNodesAtLevel (Zs.size());
  unsigned count = countTuples (*nodes.begin());
  for (CTNodes::const_iterator it = nodes.begin();
       it != nodes.end(); ++ it) {
    if (countTuples (*it) != count) {
      return false;
    }
  }
  return true;
}



unsigned
ConstraintTree::getConditionalCount (const LogVarSet& Ys)
{
  assert (isCountNormalized (Ys));
  if (Ys.empty()) {
    return 1;
  }
  if (Ys.size() == logVars_.size()) {
    assert (LogVarSet (Ys) == LogVarSet (logVars_));
    return countTuples (root_);
  }
  LogVarSet Zs = logVarSet_ - Ys;
  moveToTop (Zs.elements());
  CTNode* n = root_;
  unsigned l = 0;
  while (l != Zs.size()) {
    n = *(n->childs().begin());
    l ++;
  }
  return countTuples (n);
}



TinySet<unsigned>
ConstraintTree::getConditionalCounts (const LogVarSet& Ys)
{
  TinySet<unsigned> counts;
  assert (logVarSet_.contains (Ys));
  if (Ys.empty()) {
    counts.insert (1);
  } else if (Ys.size() == logVars_.size()) {
    assert (LogVarSet (logVars_) == LogVarSet (Ys));
    counts.insert (countTuples (root_));
  } else {
    LogVarSet Zs = logVarSet_ - LogVarSet (Ys);
    moveToTop (Zs.elements());
    CTNodes nodes = getNodesAtLevel (Zs.size());
    for (CTNodes::const_iterator it = nodes.begin();
         it != nodes.end(); ++ it) {
      counts.insert (countTuples (*it));
    }
  }
  return counts;
}



bool
ConstraintTree::isCartesianProduct (const LogVarSet& Xs)
{
  assert (logVarSet_.contains (Xs));
  if (Xs.size() <= 1) {
    return true;
  }
  moveToTop (Xs.elements());
  for (size_t i = 1; i < Xs.size(); i++) {
    CTNodes nodes = getNodesAtLevel (i);
    for (size_t j = 1; j < nodes.size(); j++) {
      if (nodes[j-1]->nrChilds() != nodes[ j ]->nrChilds()) {
        return false;
      }
      if (nodes[j-1]->childSymbols() != nodes[ j ]->childSymbols()) {
        return false;
      }
    }
  }
  return true;
}



std::pair<ConstraintTree*,ConstraintTree*>
ConstraintTree::split (const Tuple& tuple)
{
  // assumes that my log vars are already on top
  LogVars lvs (logVars_.begin(), logVars_.begin() + tuple.size());
  ConstraintTree tempCt (logVars_, {tuple});
  return split (lvs, &tempCt, lvs);
}



std::pair<ConstraintTree*, ConstraintTree*>
ConstraintTree::split (
    const LogVars& lvs1,
    ConstraintTree* ct,
    const LogVars& lvs2)
{
  assert (lvs1.size() == lvs2.size());
  assert (lvs1.size() == LogVarSet (lvs1).size());
  assert (lvs2.size() == LogVarSet (lvs2).size());
  assert (logVarSet_.contains (lvs1));
  assert (ct->logVarSet().contains (lvs2));
  CTChilds commChilds, exclChilds;
  unsigned stopLevel = lvs1.size();
  split (root_, ct->root(), commChilds, exclChilds, stopLevel);
  ConstraintTree* commCt = new ConstraintTree (commChilds, logVars_);
  ConstraintTree* exclCt = new ConstraintTree (exclChilds, logVars_);
  // std::cout << commCt->tupleSet() << " + " ;
  // std::cout << exclCt->tupleSet() << " = " ;
  // std::cout << tupleSet() << std::endl;
  assert ((commCt->tupleSet() | exclCt->tupleSet()) == tupleSet());
  assert ((exclCt->tupleSet (stopLevel) & ct->tupleSet (stopLevel)).empty());
  return {commCt, exclCt};
}



ConstraintTrees
ConstraintTree::countNormalize (const LogVarSet& Ys)
{
  assert (logVarSet_.contains (Ys));
  LogVarSet Zs = logVarSet_ - Ys;
  if (Ys.empty() || Zs.empty()) {
    return { new ConstraintTree (*this) };
  }
  moveToTop (Zs.elements());
  ConstraintTrees cts;
  std::unordered_map<unsigned, ConstraintTree*> countMap;
  unsigned stopLevel = getLevel (Zs.back());
  const CTChilds& childs = root_->childs();

  for (CTChilds::const_iterator chIt = childs.begin();
       chIt != childs.end(); ++ chIt) {
    const std::vector<std::pair<CTNode*, unsigned>>& res =
        countNormalize (*chIt, stopLevel);
    for (size_t j = 0; j < res.size(); j++) {
      std::unordered_map<unsigned, ConstraintTree*>::iterator it
          = countMap.find (res[j].second);
      if (it == countMap.end()) {
        ConstraintTree* newCt = new ConstraintTree (logVars_);
        it = countMap.insert (std::make_pair (res[j].second, newCt)).first;
        cts.push_back (newCt);
      }
      it->second->root_->mergeSubtree (res[j].first);
    }
  }
  return cts;
}



ConstraintTrees
ConstraintTree::jointCountNormalize (
    ConstraintTree* commCt,
    ConstraintTree* exclCt,
    LogVar X,
    LogVar X_new1,
    LogVar X_new2)
{
  unsigned N = getConditionalCount (X);
  // std::cout << "My tuples:     " << tupleSet() << std::endl;
  // std::cout << "CommCt tuples: " << commCt->tupleSet() << std::endl;
  // std::cout << "ExclCt tuples: " << exclCt->tupleSet() << std::endl;
  // std::cout << "Counted Lv:    " << X << std::endl;
  // std::cout << "X_new1:        " << X_new1 << std::endl;
  // std::cout << "X_new2:        " << X_new2 << std::endl;
  // std::cout << "Original N:    " << N << std::endl;
  // std::cout << endl;

  ConstraintTrees normCts1 = commCt->countNormalize (X);
  std::vector<unsigned> counts1 (normCts1.size());
  for (size_t i = 0; i < normCts1.size(); i++) {
    counts1[i] = normCts1[i]->getConditionalCount (X);
    // std::cout << "normCts1[" << i << "] #" << counts1[i] ;
    // std::cout << " " << normCts1[i]->tupleSet() << std::endl;
  }

  ConstraintTrees normCts2 = exclCt->countNormalize (X);
  std::vector<unsigned> counts2 (normCts2.size());
  for (size_t i = 0; i < normCts2.size(); i++) {
    counts2[i] = normCts2[i]->getConditionalCount (X);
    // std::cout << "normCts2[" << i << "] #" << counts2[i] ;
    // std::cout << " " << normCts2[i]->tupleSet() << std::endl;
  }
  // std::cout << std::endl;

  ConstraintTree* excl1 = 0;
  for (size_t i = 0; i < normCts1.size(); i++) {
    if (counts1[i] == N) {
      excl1 = normCts1[i];
      normCts1.erase (normCts1.begin() + i);
      counts1.erase (counts1.begin() + i);
      // std::cout << "joint-count(" << N << ",0)" << std::endl;
      break;
    }
  }

  ConstraintTree* excl2 = 0;
  for (size_t i = 0; i < normCts2.size(); i++) {
    if (counts2[i] == N) {
      excl2 = normCts2[i];
      normCts2.erase (normCts2.begin() + i);
      counts2.erase (counts2.begin() + i);
      // std::cout << "joint-count(0," << N << ")" << std::endl;
      break;
    }
  }

  for (size_t i = 0; i < normCts1.size(); i++) {
    unsigned j;
    for (j = 0; counts1[i] + counts2[j] != N; j++) ;
    // std::cout << "joint-count(" << counts1[i] ;
    // std::cout <<  "," << counts2[j] << ")" << std::endl;
    const CTChilds& childs = normCts2[j]->root_->childs();
    for (CTChilds::const_iterator chIt = childs.begin();
         chIt != childs.end(); ++ chIt) {
      normCts1[i]->root_->mergeSubtree (CTNode::copySubtree (*chIt));
    }
    delete normCts2[j];
  }

  ConstraintTrees cts = normCts1;
  commCt->rename (X, X_new1);
  exclCt->rename (X, X_new2);
  for (size_t i = 0; i < cts.size(); i++) {
    cts[i]->remove (X);
    cts[i]->join (commCt);
    cts[i]->join (exclCt);
  }

  if (excl1) {
    cts.push_back (excl1);
  }
  if (excl2) {
    cts.push_back (excl2);
  }

  return cts;
}



LogVars
ConstraintTree::expand (LogVar X)
{
  moveToBottom ({X});
  assert (isCountNormalized (X));
  CTNodes nodes = getNodesAtLevel (logVars_.size() - 1);
  unsigned nrSymbols = getConditionalCount (X);
  for (CTNodes::const_iterator it = nodes.begin();
       it != nodes.end(); ++ it) {
    Symbols symbols;
    const CTChilds& childs = (*it)->childs();
    for (CTChilds::const_iterator chIt = childs.begin();
         chIt != childs.end(); ++ chIt) {
      symbols.push_back ((*chIt)->symbol());
    }
    (*it)->removeAndDeleteAllChilds();
    CTNode* prev = *it;
    assert (symbols.size() == nrSymbols);
    for (size_t j = 0; j < nrSymbols; j++) {
      CTNode* newNode = new CTNode (symbols[j], (*it)->level() + j);
      prev->mergeSubtree (newNode);
      prev = newNode;
    }
  }
  LogVars newLvs;
  logVars_.pop_back();
  for (size_t i = 0; i < nrSymbols; i++) {
    logVars_.push_back (LogVar (logVarSet_.back() + 1));
    newLvs.push_back   (LogVar (logVarSet_.back() + 1));
    logVarSet_.insert  (LogVar (logVarSet_.back() + 1));
  }
  logVarSet_ -= X;
  return newLvs;
}



ConstraintTrees
ConstraintTree::ground (LogVar X)
{
  moveToTop ({X});
  ConstraintTrees cts;
  const CTChilds& nodes = root_->childs();
  for (CTChilds::const_iterator it = nodes.begin();
       it != nodes.end(); ++ it) {
    CTNode* copy = CTNode::copySubtree (*it);
    copy->setSymbol ((*it)->symbol());
    ConstraintTree* newCt = new ConstraintTree (logVars_);
    newCt->root()->mergeSubtree (copy);
    cts.push_back (newCt);
  }
  return cts;
}



void
ConstraintTree::cloneLogVar (LogVar X_1, LogVar X_2)
{
  moveToBottom ({X_1});
  CTNodes leafs = getNodesAtLevel (logVars_.size());
  for (size_t i = 0; i < leafs.size(); i++) {
    leafs[i]->childs().insert_sorted (
        new CTNode (leafs[i]->symbol(), leafs[i]->level() + 1));
  }
  logVars_.push_back (X_2);
  logVarSet_.insert (X_2);
}



ConstraintTree&
ConstraintTree::operator= (const ConstraintTree& ct)
{
  if (this != &ct) {
    root_      = CTNode::copySubtree (ct.root_);
    logVars_   = ct.logVars_;
    logVarSet_ = ct.logVarSet_;
  }
  return *this;
}



unsigned
ConstraintTree::countTuples (const CTNode* n) const
{
  if (n->isLeaf()) {
    return 1;
  }
  unsigned sum = 0;
  const CTChilds& childs = n->childs();
  for (CTChilds::const_iterator chIt = childs.begin();
      chIt != childs.end(); ++ chIt) {
    sum += countTuples (*chIt);
  }
  return sum;
}



CTNodes
ConstraintTree::getNodesBelow (CTNode* fromHere) const
{
  CTNodes nodes;
  std::queue<CTNode*> queue;
  queue.push (fromHere);
  while (queue.empty() == false) {
    CTNode* node = queue.front();
    nodes.push_back (node);
    for (CTChilds::const_iterator chIt = node->childs().begin();
         chIt != node->childs().end(); ++ chIt) {
      queue.push (*chIt);
    }
    queue.pop();
  }
  return nodes;
}



CTNodes
ConstraintTree::getNodesAtLevel (unsigned level) const
{
  assert (level <= logVars_.size());
  if (level == 0) {
    return { root_ };
  }
  CTNodes stack;
  CTNodes nodes;
  stack.push_back (root_);
  while (stack.empty() == false) {
    CTNode* node = stack.back();
    stack.pop_back();
    if (node->level() + 1 == level) {
      nodes.insert (nodes.end(), node->childs().begin(),
          node->childs().end());
    } else {
      stack.insert (stack.end(), node->childs().begin(),
          node->childs().end());
    }
  }
  return nodes;
}



unsigned
ConstraintTree::nrNodes (const CTNode* n) const
{
  unsigned nr = 0;
  if (n->isLeaf() == false) {
    for (CTChilds::const_iterator chIt = n->childs().begin();
         chIt != n->childs().end(); ++ chIt) {
      nr += nrNodes (*chIt);
    }
  }
  return nr;
}



void
ConstraintTree::appendOnBottom (CTNode* n, const CTChilds& childs)
{
  if (childs.empty()) {
    return;
  }
  CTNodes stack { n };
  while (stack.empty() == false) {
    CTNode* node = stack.back();
    stack.pop_back();
    if (node->isLeaf()) {
      for (CTChilds::const_iterator chIt = childs.begin();
           chIt != childs.end(); ++ chIt) {
        node->mergeSubtree (CTNode::copySubtree (*chIt));
      }
    } else {
      stack.insert (stack.end(), node->childs().begin(),
          node->childs().end());
    }
  }
}



void
ConstraintTree::swapLogVar (LogVar X)
{
  size_t pos = Util::indexOf (logVars_, X);
  assert (pos != logVars_.size());
  CTNodes nodes = getNodesAtLevel (pos);
  for (CTNodes::const_iterator nodeIt = nodes.begin();
       nodeIt != nodes.end(); ++ nodeIt) {
    CTChilds childsCopy = (*nodeIt)->childs();
    (*nodeIt)->removeChilds();
    for (CTChilds::const_iterator ccIt = childsCopy.begin();
         ccIt != childsCopy.end(); ++ ccIt) {
       const CTChilds& grandsons = (*ccIt)->childs();
       for (CTChilds::const_iterator gsIt = grandsons.begin();
            gsIt != grandsons.end(); ++ gsIt) {
         CTNode* childCopy = new CTNode (
             (*ccIt)->symbol(), (*ccIt)->level() + 1, (*gsIt)->childs());
         (*gsIt)->removeChilds();
         (*gsIt)->childs().insert_sorted (childCopy);
         (*gsIt)->setLevel ((*gsIt)->level() - 1);
         (*nodeIt)->mergeSubtree ((*gsIt), false);
       }
       delete (*ccIt);
    }
  }
  std::swap (logVars_[pos], logVars_[pos + 1]);
}



bool
ConstraintTree::join (
    CTNode* currNode,
    const Tuple& tuple,
    size_t currIdx,
    CTNode* appendNode)
{
  bool tupleFounded = false;
  CTChilds::const_iterator it = currNode->findSymbol (tuple[currIdx]);
  if (it != currNode->childs().end()) {
    if (currIdx == tuple.size() - 1) {
      appendOnBottom (*it, appendNode->childs());
      return true;
    } else {
      tupleFounded = join (*it, tuple, currIdx + 1, appendNode);
    }
  }
  return tupleFounded;
}



void
ConstraintTree::getTuples (
    CTNode* n,
    Tuples currTuples,
    unsigned stopLevel,
    Tuples& tuplesCollected,
    CTNodes& continuationNodes) const
{
  if (n->isRoot() == false) {
    if (currTuples.empty()) {
        currTuples.push_back ({ n->symbol()});
    } else {
      for (size_t i = 0; i < currTuples.size(); i++) {
        currTuples[i].push_back (n->symbol());
      }
    }
    if (n->level() == stopLevel) {
      for (size_t i = 0; i < currTuples.size(); i++) {
        tuplesCollected.push_back (currTuples[i]);
        continuationNodes.push_back (n);
      }
      return;
    }
  }
  const CTChilds& childs = n->childs();
  for (CTChilds::const_iterator chIt = childs.begin();
      chIt != childs.end(); ++ chIt) {
    getTuples (*chIt, currTuples, stopLevel, tuplesCollected,
        continuationNodes);
  }
}



unsigned
ConstraintTree::size() const
{
  return countTuples (root_);
}



unsigned
ConstraintTree::nrSymbols (LogVar X)
{
  moveToTop ({X});
  return root_->childs().size();
}



std::vector<std::pair<CTNode*, unsigned>>
ConstraintTree::countNormalize (
     const CTNode* n,
     unsigned stopLevel)
{
  if (n->level() == stopLevel) {
    return std::vector<std::pair<CTNode*, unsigned>>() = {
      std::make_pair (CTNode::copySubtree (n), countTuples (n))
    };
  }
  std::vector<std::pair<CTNode*, unsigned>> res;
  const CTChilds& childs = n->childs();
  for (CTChilds::const_iterator chIt = childs.begin();
       chIt != childs.end(); ++ chIt) {
    const std::vector<std::pair<CTNode*, unsigned>>& lowerRes =
        countNormalize (*chIt, stopLevel);
    for (size_t j = 0; j < lowerRes.size(); j++) {
      CTNode* newNode = new CTNode (*n);
      newNode->mergeSubtree (lowerRes[j].first);
      res.push_back (std::make_pair (newNode, lowerRes[j].second));
    }
  }
  return res;
}



void
ConstraintTree::split (
    CTNode* n1,
    CTNode* n2,
    CTChilds& commChilds,
    CTChilds& exclChilds,
    unsigned stopLevel)
{
  CTChilds& childs1 = n1->childs();
  for (CTChilds::const_iterator chIt1 = childs1.begin();
       chIt1 != childs1.end(); ++ chIt1) {
    CTChilds::iterator chIt2 = n2->findSymbol ((*chIt1)->symbol());
    if (chIt2 == n2->childs().end()) {
      exclChilds.insert_sorted (CTNode::copySubtree (*chIt1));
    } else {
      if ((*chIt1)->level() == stopLevel) {
        commChilds.insert_sorted (CTNode::copySubtree (*chIt1));
      } else {
        CTChilds lowerCommChilds, lowerExclChilds;
        split (*chIt1, *chIt2, lowerCommChilds, lowerExclChilds, stopLevel);
        if (lowerCommChilds.empty() == false) {
          commChilds.insert_sorted (new CTNode (**chIt1, lowerCommChilds));
        }
        if (lowerExclChilds.empty() == false) {
          exclChilds.insert_sorted (new CTNode (**chIt1, lowerExclChilds));
        }
      }
    }
  }
}

}  // namespace Horus