/**
 * Does the closure of the formula, by adding the variables to the list of
 * prefix sets
 *
 * @param prefix: list of second-order variables corresponding to the prefix
 * @param freeVars: list of free variables in formula
 * @param negationIsTopMost: whether the prefix had negation on left or no
 */
void closePrefix(PrefixListType & prefix, IdentList* freeVars, bool negationIsTopmost) {
	unsigned int quantifiedSize;
	unsigned value;
	unsigned int prefixSize = prefix.size();

	// phi = neg exists X ...
	// we will add new level of quantification
	if (negationIsTopmost) {
		VariableSet set;
		quantifiedSize = freeVars->size();
		for (unsigned i = 0; i < quantifiedSize; ++i) {
			value = freeVars->get(i);
			set.push_back(varMap[value]);
		}
		prefix.push_back(set);
	} else {
		int index = prefix.size() - 1;
		quantifiedSize = freeVars->size();
		for (unsigned i = 0; i < quantifiedSize; ++i) {
			value = freeVars->get(i);
			prefix[index].insert(prefix[index].begin()+i, varMap[value]);
		}
	}

}

void Variable::assignValue(std::string value) {
  VariableSet *vs = VariableSet::instance();
  vs->loadIfNeeded();
  m_imp->m_value = value;
  try {
    vs->commit();
  } catch (...) {
  }
}

VariableSet::VariableSet(const VariableSet &vs)
{
	for (int var = 0; var<vs.getNumVariables(); var++) {
		mVariables.push_back(new SearchVariable(vs.getVariable(var)));
	}
	for (int par=0; par<(int)vs.mParameters.size(); par++) {
		mParameters.push_back(SearchParameter(vs.mParameters[par]));
	}
	mHand = vs.mHand;
}

   void GeneralConstraint::stackVariables( VariableList& varList,
                                           const VariableSet& varSet )
   {
      for(VariableSet::const_iterator it= varSet.begin();
          it!=varSet.end();
          ++it)
      {
         varList.push_back(*it);
      }

   }  // End of method 'GeneralConstraint::stackVariables()'

/**
 * Takes formula, the prefix, and converts it to the set of sets of second
 * order variables, according to the variable map;
 *
 * @param formula: formula corresponding to the prefix
 * @return: list of lists of second-order variables
 */
PrefixListType convertPrefixFormulaToList(ASTForm* formula) {
	PrefixListType list;
	VariableSet set;
	unsigned int quantifiedSize;
	unsigned int value;
	bool isFirstNeg = true;

	// empty prefix is just one empty list
	if (formula->kind == aTrue) {
		list.push_front(set);
		return list;
	}

	ASTForm* iterator = formula;
	// while we are not at the end of the prefix
	while (iterator->kind != aTrue) {
		//iterator->dump();
		//std::cout << "\n";
		// Add to set
		if (iterator->kind == aEx2) {
			ASTForm_Ex2* exf = (ASTForm_Ex2*) iterator;

			quantifiedSize = (exf->vl)->size();
			for (unsigned i = 0; i < quantifiedSize; ++i) {
				value = (exf->vl)->get(i);
				//std::cout << value << " -> " << varMap[value] << "\n";
				set.push_back(varMap[value]);
			}
			iterator = exf->f;
			isFirstNeg = false;
		// Create new set
		} else if (iterator->kind == aNot) {
			if (!isFirstNeg) {
				list.push_front(set);
				set.clear();
			} else {
				isFirstNeg = false;
			}

			ASTForm_Not* notf = (ASTForm_Not*) iterator;
			iterator = notf->f;
		// Fail, should not happen
		} else {
			assert(false);
		}
	}

	if (set.size() != 0) {
		list.push_front(set);
	}

	return list;
}

   VariableSet GeneralConstraint::unionVariables( const VariableSet& vs1,
                                                  const VariableSet& vs2 )
   {
      VariableSet tempSet(vs1);
      for(VariableSet::const_iterator it=vs2.begin();
          it!=vs2.end();
          ++it)
      {
         tempSet.insert(*it);
      }

      return tempSet;

   }  // End of method 'GeneralConstraint::unionVariables()'

void TeXDisplay::printTeXVariableSet(const VariableSet & x) {
    d_sink.put(" $\\{$ ");
    Variable var;
    bool b = x.firstVariable(var);
    if(b) {
      d_sink.put(var);
      b = x.nextVariable(var);
      while(b) {
        d_sink.put(',');
        d_sink.put(var);
        b = x.nextVariable(var);
      };
    };
    d_sink.put(" $\\}$ ");
};

VariableSet AdmWithLevels::variablesInOrder() const {
  VariableSet result;
  typedef vector<vector<Variable> >::const_iterator VI;
  VI w = d_v.begin(), e = d_v.end();
  while(w!=e) {
    const vector<Variable> & V = *w;
    vector<Variable>::const_iterator ww = V.begin(), ee = V.end();
    while(ww!=ee) {
      result.insert(*ww);
      ++ww;
    };
    ++w;
  };
  return result;
};

   VariableSet GeneralConstraint::getVariables( const SatID& sat,
                                                const TypeID& type )
   {
      VariableSet vset;

      VariableSet varSet = getVariables(sat);
      for(VariableSet::iterator itv=varSet.begin();
         itv!=varSet.end();
         ++itv)
      {
         if( (itv->getType()==type) ) vset.insert(*itv);
      }

      return vset;

   }  // End of method 'GeneralConstraint::getVariables(const SatID& sat,...)'

 inline std::string asString(const VariableSet& vset)
 {
    std::ostringstream oss;
    for( VariableSet::const_iterator it = vset.begin();
         it != vset.end();
         ++it )
    {
       oss << it->getType() << "   "
           << it->getSource() << "   "
           << it->getSatellite() << "   "
           << it->getTypeIndexed() << " "
           << it->getSourceIndexed() << " "
           << it->getSatIndexed()<< std::endl;
    }
    
    return oss.str();
 }

VariableSet VariableSet::operator*(const VariableSet& o) const {
    VariableSet result(capacity_);
    for(unsigned i = 0; i < size_; i++) {
        if(o.contains(vars_[i]))
            result += vars_[i];
    }
    return result;
}

   VariableSet GeneralConstraint::getVariables( const SourceIDSet& sourceSet )
   {
      VariableSet vset;

      VariableSet unkSet( getVariables() );

      for( VariableSet::const_iterator itv = unkSet.begin();
         itv != unkSet.end();
         ++itv )
      {
         SourceIDSet::const_iterator it = sourceSet.find( (*itv).getSource() );
         if( it!=sourceSet.end() ) vset.insert( *itv );
      }

      return vset;

   }  // End of method 'GeneralConstraint::getVariables(...'

void Polynomial::variablesIn(VariableSet & result) const {
  const int len = numberOfTerms();
  // Bypass the reordering of the polynomial
  PolynomialIterator j = _terms.begin();
  for(int i=1;i<=len&&!result.full();++i,++j) {
    (*j).MonomialPart().variablesIn(result);
  }
};

   Vector<double> GeneralConstraint::getSolution( const VariableSet& varSet )
   {
      Vector<double> solution(varSet.size(),0.0);
      
      int i(0);
      for(VariableSet::const_iterator it=varSet.begin();
         it!=varSet.end();
         ++it)
      {
         solution[i] = solver.getSolution(*it);

         i++;
      }

      return solution;

   }  // End of method 'GeneralConstraint::getSolution(...'

OptionalMessageList UndeclaredVariableCheck::visitLambdaDefinition(const LambdaDefinitionAddress& lambdaDef) {

	OptionalMessageList res;

	VariableSet recFunctions;
	for_each(lambdaDef.getAddressedNode()->getDefinitions(), [&recFunctions](const LambdaBindingPtr& cur) {
		recFunctions.insert(cur->getVariable());
	});

	for_each(lambdaDef->getDefinitions(), [&](const LambdaBindingAddress& cur) {

		// assemble set of defined variables
		VariableSet declared;

		// add recursive function variables
		declared.insert(recFunctions.begin(), recFunctions.end());

		// add parameters
		auto paramList = cur.getAddressedNode()->getLambda()->getParameterList();
		declared.insert(paramList.begin(), paramList.end());

		// run check on body ...
		VarDeclarationCheck check(declared);

		// trigger check
		addAll(res, conductCheck(check, cur->getLambda()));
	});

	return res;
}

void merge( VariableSet &vs, const VariableSet &other )
{
	if ( vs.empty() )
		vs = other;
	else
	{
		for ( auto i: other )
		{
			auto cur = vs.find( i.first );
			if ( cur == vs.end() )
			{
				vs.emplace( std::make_pair( i.first, i.second ) );
			}
			else
				cur->second.merge( i.second );
		}
	}
}

void
Item::extractVariables( VariableSet &vs ) const
{
	ItemPtr i = getParent();
	if ( i )
		i->extractVariables( vs );
	for ( auto x = myVariables.begin(); x != myVariables.end(); ++x )
		vs.emplace( std::make_pair( x->first, x->second ) );
}

 bool operator()(const VariableSet & m,const VariableSet & n) const {
   bool result = false;
   int msz = m.size();
   int nsz = n.size();
   if(msz!=nsz) {
     result = msz< nsz;
   } else if(msz>0) {
     result = false; // perhaps they are equal
     Variable v1,v2;
     bool b1 = m.firstVariable(v1);
     bool b2 = n.firstVariable(v2);
     if(v1==v2) {
       while(b1&&b2) {
         b1 = m.nextVariable(v1);
         b2 = n.nextVariable(v2);
         if(b1) {
           if(v1!=v2) {
            result = operator()(v1,v2);
           }; 
         } else break; 
      };
     } else {
       result = operator()(v1,v2);
     };
     if(b1!=b2) errorh(__LINE__);
   };
   return result;
 };

   Matrix<double> GeneralConstraint::getCovariance( const VariableSet& varSet )
   {
      Matrix<double> covariance(varSet.size(),varSet.size(),0.0);
      
      int i(0);
      for(VariableSet::const_iterator iti=varSet.begin();
         iti!=varSet.end();
         ++iti)
      {
         int j(0);
         
         for(VariableSet::const_iterator itj=varSet.begin();
            itj!=varSet.end();
            ++itj)
         {
            covariance[i][j] = solver.getCovariance(*iti,*itj);
            j++;
         }

         i++;
      }

      return covariance;

   }  // End of method 'GeneralConstraint::getCovariance(...'

   VariableSet GeneralConstraint::intersectionVariables(const VariableSet& vs1,
                                                        const VariableSet& vs2 )
   {
      VariableSet tempSet;
      for(VariableSet::const_iterator it=vs1.begin();
         it!=vs1.end();
         ++it)
      {
         VariableSet::const_iterator it2 = vs2.find(*it);
         if(it2!=vs2.end()) tempSet.insert(*it);
      }

      return tempSet;

   }  // End of method 'GeneralConstraint::intersectionVariables()'