/****************************************************************************************[Solver.h]
MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
CryptoMiniSat -- Copyright (c) 2009 Mate Soos
glucose -- Gilles Audemard, Laurent Simon (2008)

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
associated documentation files (the "Software"), to deal in the Software without restriction,
including without limitation the rights to use, copy, modify, merge, publish, distribute,
sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or
substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
**************************************************************************************************/

#ifndef SOLVER_H
#define SOLVER_H

#include <cstdio>
#include <string.h>
#include <stdio.h>
#ifdef _MSC_VER
#include <msvc/stdint.h>
#else
#include <stdint.h>
#endif //_MSC_VER

#include "Vec.h"
#include "Heap.h"
#include "Alg.h"
#include "MersenneTwister.h"
#include "SolverTypes.h"
#include "Clause.h"
#include "constants.h"
#include "BoundedQueue.h"

#ifdef STATS_NEEDED
#include "Logger.h"
#endif //STATS_NEEDED

#ifdef USE_GAUSS
#include "GaussianConfig.h"
#endif //USE_GAUSS

#ifdef USE_GAUSS
class Gaussian;
class MatrixFinder;
#endif //USE_GAUSS
class Conglomerate;
class VarReplacer;
class XorFinder;
class FindUndef;
class ClauseCleaner;
class FailedVarSearcher;
class Subsumer;
class XorSubsumer;
class PartHandler;
class RestartTypeChooser;
class StateSaver;

#ifdef VERBOSE_DEBUG
#define DEBUG_UNCHECKEDENQUEUE_LEVEL0
using std::cout;
using std::endl;
#endif

//=================================================================================================
// Solver -- the main class:

struct reduceDB_ltMiniSat
{
    bool operator () (const Clause* x, const Clause* y);
};

struct reduceDB_ltGlucose
{
    bool operator () (const Clause* x, const Clause* y);
};


class Solver
{
public:

    // Constructor/Destructor:
    //
    Solver();
    ~Solver();

    // Problem specification:
    //
    Var     newVar    (bool dvar = true); // Add a new variable with parameters specifying variable mode.
    template<class T>
    bool    addClause (T& ps, const uint group = 0, char* group_name = NULL);  // Add a clause to the solver. NOTE! 'ps' may be shrunk by this method!
    template<class T>
    bool    addXorClause (T& ps, bool xor_clause_inverted, const uint group = 0, char* group_name = NULL);  // Add a xor-clause to the solver. NOTE! 'ps' may be shrunk by this method!

    // Solving:
    //
    lbool    solve       (const vec<Lit>& assumps); // Search for a model that respects a given set of assumptions.
    lbool    solve       ();                        // Search without assumptions.
    bool    okay         () const;                  // FALSE means solver is in a conflicting state

    // Variable mode:
    //
    void    setPolarity    (Var v, bool b); // Declare which polarity the decision heuristic should use for a variable. Requires mode 'polarity_user'.
    void    setDecisionVar (Var v, bool b); // Declare if a variable should be eligible for selection in the decision heuristic.
    void    setSeed (const uint32_t seed);  // Sets the seed to be the given number
    void    setMaxRestarts(const uint num); //sets the maximum number of restarts to given value

    // Read state:
    //
    lbool   value      (const Var& x) const;       // The current value of a variable.
    lbool   value      (const Lit& p) const;       // The current value of a literal.
    lbool   modelValue (const Lit& p) const;       // The value of a literal in the last model. The last call to solve must have been satisfiable.
    uint32_t     nAssigns   ()      const;       // The current number of assigned literals.
    uint32_t     nClauses   ()      const;       // The current number of original clauses.
    uint32_t     nLiterals  ()      const;       // The current number of total literals.
    uint32_t     nLearnts   ()      const;       // The current number of learnt clauses.
    uint32_t     nVars      ()      const;       // The current number of variables.

    // Extra results: (read-only member variable)
    //
    vec<lbool> model;             // If problem is satisfiable, this vector contains the model (if any).
    vec<Lit>   conflict;          // If problem is unsatisfiable (possibly under assumptions),
    // this vector represent the final conflict clause expressed in the assumptions.

    // Mode of operation:
    //
    double    random_var_freq;    // The frequency with which the decision heuristic tries to choose a random variable.        (default 0.02)
    double    clause_decay;       // Inverse of the clause activity decay factor.                                              (1 / 0.999)
    int       restart_first;      // The initial restart limit.                                                                (default 100)
    double    restart_inc;        // The factor with which the restart limit is multiplied in each restart.                    (default 1.5)
    double    learntsize_factor;  // The intitial limit for learnt clauses is a factor of the original clauses.                (default 1 / 3)
    double    learntsize_inc;     // The limit for learnt clauses is multiplied with this factor each restart.                 (default 1.1)
    bool      expensive_ccmin;    // Controls conflict clause minimization.                                                    (default TRUE)
    int       polarity_mode;      // Controls which polarity the decision heuristic chooses. See enum below for allowed modes. (default polarity_false)
    int       verbosity;          // Verbosity level. 0=silent, 1=some progress report                                         (default 0)
    Var       restrictedPickBranch; // Pick variables to branch on preferentally from the highest [0, restrictedPickBranch]. If set to 0, preferentiality is turned off (i.e. picked randomly between [0, all])
    bool      findNormalXors;     // Automatically find non-binary xor-clauses and convert them
    bool      findBinaryXors;     // Automatically find binary xor-clauses and convert them
    bool      regularlyFindBinaryXors; // Regularly find binary xor-clauses and convert them
    bool      performReplace;       // Should var-replacing be performed?
    bool      conglomerateXors;   // Conglomerate XORs
    bool      heuleProcess;       // Process XORs according to Heule
    bool      schedSimplification;// Schedule simplification
    bool      doSubsumption;        // Should try to subsume clauses
    bool      doXorSubsumption;     // Should try to subsume xor clauses
    bool      doPartHandler;        // Should try to subsume clauses
    bool      doHyperBinRes;        // Should try carry out hyper-binary resolution
    bool      doBlockedClause;      // Should try to remove blocked clauses
    bool      doVarElim;            // Perform variable elimination
    bool      doSubsume1;           // Perform clause contraction through resolution
    bool      failedVarSearch;      // Should search for failed vars and doulbly propagated vars
    bool      readdOldLearnts;      // Should re-add old learnts for failed variable searching
    bool      addExtraBins;         // Should add extra binaries in failed literal probing
    bool      removeUselessBins;    // Should try to remove useless binary clauses
    bool      regularRemoveUselessBins; // Should try to remove useless binary clauses regularly
    bool      subsumeWithNonExistBinaries;
    bool      regularSubsumeWithNonExistBinaries;
    bool      libraryUsage;         // Set true if not used as a library
    friend class FindUndef;
    bool      greedyUnbound;        //If set, then variables will be greedily unbounded (set to l_Undef)
    RestartType fixRestartType;     // If set, the solver will always choose the given restart strategy
    #ifdef USE_GAUSS
    GaussianConfig gaussconfig;
    #endif //USE_GAUSS
    

    enum { polarity_true = 0, polarity_false = 1, polarity_rnd = 3, polarity_auto = 4};

    // Statistics: (read-only member variable)
    //
    uint64_t starts, dynStarts, staticStarts, fullStarts, decisions, rnd_decisions, propagations, conflicts;
    uint64_t clauses_literals, learnts_literals, max_literals, tot_literals;
    uint64_t nbDL2, nbBin, lastNbBin, becameBinary, lastSearchForBinaryXor, nbReduceDB;
    uint64_t improvedClauseNo, improvedClauseSize;

    //Logging
    void needStats();              // Prepares the solver to output statistics
    void needProofGraph();         // Prepares the solver to output proof graphs during solving
    void setVariableName(Var var, char* name); // Sets the name of the variable 'var' to 'name'. Useful for statistics and proof logs (i.e. used by 'logger')
    const vec<Clause*>& get_sorted_learnts(); //return the set of learned clauses, sorted according to the logic used in MiniSat to distinguish between 'good' and 'bad' clauses
    const vec<Clause*>& get_learnts() const; //Get all learnt clauses that are >1 long
    const vector<Lit> get_unitary_learnts() const; //return the set of unitary learnt clauses
    const uint get_unitary_learnts_num() const; //return the number of unitary learnt clauses
    void dumpSortedLearnts(const char* file, const uint32_t maxSize); // Dumps all learnt clauses (including unitary ones) into the file
    void needLibraryCNFFile(const char* fileName); //creates file in current directory with the filename indicated, and puts all calls from the library into the file.

    #ifdef USE_GAUSS
    const uint32_t get_sum_gauss_called() const;
    const uint32_t get_sum_gauss_confl() const;
    const uint32_t get_sum_gauss_prop() const;
    const uint32_t get_sum_gauss_unit_truths() const;
    #endif //USE_GAUSS

    //Printing statistics
    const uint32_t getNumElimSubsume() const; // Get variable elimination stats from Subsumer
    const uint32_t getNumElimXorSubsume() const; // Get variable elimination stats from XorSubsumer
    const uint32_t getNumXorTrees() const; // Get the number of trees built from 2-long XOR-s. This is effectively the number of variables that replace other variables
    const uint32_t getNumXorTreesCrownSize() const; // Get the number of variables being replaced by other variables
    const double getTotalTimeSubsumer() const;
    const double getTotalTimeXorSubsumer() const;
    
protected:
    #ifdef USE_GAUSS
    void print_gauss_sum_stats();
    void clearGaussMatrixes();
    vector<Gaussian*> gauss_matrixes;

    //stats
    uint32_t sum_gauss_called;
    uint32_t sum_gauss_confl;
    uint32_t sum_gauss_prop;
    uint32_t sum_gauss_unit_truths;
    friend class Gaussian;
    #endif //USE_GAUSS
    
    template <class T>
    Clause* addClauseInt(T& ps, uint group);
    template<class T>
    XorClause* addXorClauseInt(T& ps, bool xor_clause_inverted, const uint32_t group);
    template<class T>
    bool addLearntClause(T& ps, const uint group, const uint32_t activity);
    template<class T>
    void    removeWatchedCl(vec<T> &ws, const Clause *c);
    template<class T>
    bool    findWatchedCl(const vec<T>& ws, const Clause *c) const;
    template<class T>
    void    removeWatchedBinCl(vec<T> &ws, const Clause *c);
    template<class T>
    bool    findWatchedBinCl(const vec<T>& ws, const Clause *c) const;
    
    // Helper structures:
    //
    struct VarOrderLt {
        const vec<uint32_t>&  activity;
        bool operator () (Var x, Var y) const {
            return activity[x] > activity[y];
        }
        VarOrderLt(const vec<uint32_t>&  act) : activity(act) { }
    };

    friend class VarFilter;
    struct VarFilter {
        const Solver& s;
        VarFilter(const Solver& _s) : s(_s) {}
        bool operator()(Var v) const {
            return s.assigns[v].isUndef() && s.decision_var[v];
        }
    };

    // Solver state:
    //
    bool                ok;               // If FALSE, the constraints are already unsatisfiable. No part of the solver state may be used!
    vec<Clause*>        clauses;          // List of problem clauses.
    vec<Clause*>        binaryClauses;    // Binary clauses are regularly moved here
    vec<XorClause*>     xorclauses;       // List of problem xor-clauses. Will be freed
    vec<Clause*>        learnts;          // List of learnt clauses.
    vec<Clause*>        removedLearnts;   // Clauses that have been learnt, then removed
    vec<XorClause*>     freeLater;        // xor clauses that need to be freed later due to Gauss
    vec<uint32_t>       activity;         // A heuristic measurement of the activity of a variable.
    uint32_t            var_inc;          // Amount to bump next variable with.
    double              cla_inc;          // Amount to bump learnt clause oldActivity with
    vec<vec<Watched> >  watches;          // 'watches[lit]' is a list of constraints watching 'lit' (will go there if literal becomes true).
    vec<vec<XorClausePtr> > xorwatches;   // 'xorwatches[var]' is a list of constraints watching var in XOR clauses.
    vec<vec<WatchedBin> >  binwatches;
    vec<lbool>          assigns;          // The current assignments
    vector<bool>        polarity;         // The preferred polarity of each variable.
    #ifdef USE_OLD_POLARITIES
    vector<bool>        oldPolarity;      // The polarity before the last setting. Good for unsetting polairties that have been changed since the last conflict
    #endif //USE_OLD_POLARITIES
    vector<bool>        decision_var;     // Declares if a variable is eligible for selection in the decision heuristic.
    vec<Lit>            trail;            // Assignment stack; stores all assigments made in the order they were made.
    vec<uint32_t>       trail_lim;        // Separator indices for different decision levels in 'trail'.
    vec<ClausePtr>      reason;           // 'reason[var]' is the clause that implied the variables current value, or 'NULL' if none.
    vec<int32_t>        level;            // 'level[var]' contains the level at which the assignment was made.
    uint64_t            curRestart;
    uint32_t            nbclausesbeforereduce;
    uint32_t            nbCompensateSubsumer; // Number of learnt clauses that subsumed normal clauses last time subs. was executed
    uint32_t            qhead;            // Head of queue (as index into the trail -- no more explicit propagation queue in MiniSat).
    uint32_t            simpDB_assigns;   // Number of top-level assignments since last execution of 'simplify()'.
    int64_t             simpDB_props;     // Remaining number of propagations that must be made before next execution of 'simplify()'.
    vec<Lit>            assumptions;      // Current set of assumptions provided to solve by the user.
    Heap<VarOrderLt>    order_heap;       // A priority queue of variables ordered with respect to the variable activity.
    double              progress_estimate;// Set by 'search()'.
    bool                remove_satisfied; // Indicates whether possibly inefficient linear scan for satisfied clauses should be performed in 'simplify'.
    bqueue<uint>        nbDecisionLevelHistory; // Set of last decision level in conflict clauses
    double              totalSumOfDecisionLevel;
    uint64_t            conflictsAtLastSolve;
    #ifdef RANDOM_LOOKAROUND_SEARCHSPACE
    bqueue<uint>        avgBranchDepth; // Avg branch depth
    #endif //RANDOM_LOOKAROUND_SEARCHSPACE
    MTRand              mtrand;           // random number generaton
    RestartType         restartType;      // Used internally to determine which restart strategy to choose
    RestartType         lastSelectedRestartType; //the last selected restart type
    friend class        Logger;
    #ifdef STATS_NEEDED
    Logger logger;                        // dynamic logging, statistics
    bool                dynamic_behaviour_analysis; // Is logger running?
    #endif
    uint                maxRestarts;      // More than this number of restarts will not be performed

    // Temporaries (to reduce allocation overhead). Each variable is prefixed by the method in which it is
    // used, exept 'seen' wich is used in several places.
    //
    vector<bool>        seen;
    vec<Lit>            analyze_stack;
    vec<Lit>            analyze_toclear;
    vec<Lit>            add_tmp;

    
    uint64_t MYFLAG;
    template<class T>
    const uint32_t calcNBLevels(const T& ps);
    vec<uint64_t> permDiff; // LS: permDiff[var] contains the current conflict number... Used to count the number of different decision level variables in learnt clause
    #ifdef UPDATEVARACTIVITY
    vec<Var> lastDecisionLevel;
    #endif

    //Logging
    uint                learnt_clause_group; //the group number of learnt clauses. Incremented at each added learnt clause
    FILE                *libraryCNFFile; //The file that all calls from the library are logged

    // Main internal methods:
    //
    const bool simplify    ();                                                           // Removes already satisfied clauses.
    //int      nbPropagated     (int level);
    void     insertVarOrder   (Var x);                                                 // Insert a variable in the decision order priority queue.
    Lit      pickBranchLit    ();                                                      // Return the next decision variable.
    void     newDecisionLevel ();                                                      // Begins a new decision level.
    void     uncheckedEnqueue (Lit p, ClausePtr from = (Clause*)NULL);                 // Enqueue a literal. Assumes value of literal is undefined.
    void     uncheckedEnqueueLight (const Lit p);
    bool     enqueue          (Lit p, Clause* from = NULL);                            // Test if fact 'p' contradicts current state, enqueue otherwise.
    Clause*  propagate        (const bool update = true);                         // Perform unit propagation. Returns possibly conflicting clause.
    Clause*  propagateLight();
    Clause*  propagateBin();
    Clause*  propagateBinNoLearnts();
    template<bool dontCareLearnt>
    Clause*  propagateBinExcept(const Lit& exceptLit);
    template<bool dontCareLearnt>
    Clause*  propagateBinOneLevel();
    Clause*  propagate_xors   (const Lit& p);
    void     cancelUntil      (int level);                                             // Backtrack until a certain level.
    Clause*  analyze          (Clause* confl, vec<Lit>& out_learnt, int& out_btlevel, uint32_t &nblevels, const bool update); // (bt = backtrack)
    void     analyzeFinal     (Lit p, vec<Lit>& out_conflict);                         // COULD THIS BE IMPLEMENTED BY THE ORDINARIY "analyze" BY SOME REASONABLE GENERALIZATION?
    bool     litRedundant     (Lit p, uint32_t abstract_levels);                       // (helper method for 'analyze()')
    lbool    search           (int nof_conflicts, int nof_conflicts_fullrestart, const bool update = true);      // Search for a given number of conflicts.
    void     reduceDB         ();                                                      // Reduce the set of learnt clauses.
    llbool   handle_conflict  (vec<Lit>& learnt_clause, Clause* confl, int& conflictC, const bool update);// Handles the conflict clause
    llbool   new_decision     (const int& nof_conflicts, const int& nof_conflicts_fullrestart, int& conflictC);  // Handles the case when all propagations have been made, and now a decision must be made

    // Maintaining Variable/Clause activity:
    //
    void     claBumpActivity (Clause& c);
    void     varDecayActivity ();                      // Decay all variables with the specified factor. Implemented by increasing the 'bump' value instead.
    void     varBumpActivity  (Var v);                 // Increase a variable with the current 'bump' value.
    void     claDecayActivity ();                      // Decay all clauses with the specified factor. Implemented by increasing the 'bump' value instead.

    // Operations on clauses:
    //
    void     attachClause     (XorClause& c);
    void     attachClause     (Clause& c);             // Attach a clause to watcher lists.
    void     detachClause     (const XorClause& c);
    void     detachClause     (const Clause& c);       // Detach a clause to watcher lists.
    void     detachModifiedClause(const Lit lit1, const Lit lit2, const uint size, const Clause* address);
    void     detachModifiedClause(const Var var1, const Var var2, const uint origSize, const XorClause* address);
    template<class T>
    void     removeClause(T& c);                       // Detach and free a clause.
    bool     locked           (const Clause& c) const; // Returns TRUE if a clause is a reason for some implication in the current state.
    void     reverse_binary_clause(Clause& c) const;   // Binary clauses --- the first Lit has to be true
    void     testAllClauseAttach() const;
    void     findAllAttach() const;
    const bool findClause(XorClause* c) const;
    const bool findClause(Clause* c) const;

    // Misc:
    //
    uint32_t decisionLevel    ()      const; // Gives the current decisionlevel.
    uint32_t abstractLevel    (const Var& x) const; // Used to represent an abstraction of sets of decision levels.
    
    //Xor-finding related stuff
    friend class XorFinder;
    friend class Conglomerate;
    friend class MatrixFinder;
    friend class PartFinder;
    friend class VarReplacer;
    friend class ClauseCleaner;
    friend class RestartTypeChooser;
    friend class FailedVarSearcher;
    friend class Subsumer;
    friend class XorSubsumer;
    friend class PartHandler;
    friend class StateSaver;
    Conglomerate* conglomerate;
    VarReplacer* varReplacer;
    ClauseCleaner* clauseCleaner;
    FailedVarSearcher* failedVarSearcher;
    PartHandler* partHandler;
    Subsumer* subsumer;
    XorSubsumer* xorSubsumer;
    RestartTypeChooser* restartTypeChooser;
    MatrixFinder* matrixFinder;
    const bool chooseRestartType(const uint& lastFullRestart);
    void setDefaultRestartType();
    const bool checkFullRestart(int& nof_conflicts, int& nof_conflicts_fullrestart, uint& lastFullRestart);
    void performStepsBeforeSolve();
    const lbool simplifyProblem(const uint32_t numConfls);
    bool simplifying;

    // Debug & etc:
    void     printLit         (const Lit l) const;
    void     verifyModel      ();
    bool     verifyClauses    (const vec<Clause*>& cs) const;
    bool     verifyXorClauses (const vec<XorClause*>& cs) const;
    void     checkSolution();
    void     checkLiteralCount();
    void     printStatHeader  () const;
    void     printRestartStat ();
    void     printEndSearchStat();
    double   progressEstimate () const; // DELETE THIS ?? IT'S NOT VERY USEFUL ...
    const bool noLearntBinaries() const;
    
    // Polarity chooser
    void calculateDefaultPolarities(); //Calculates the default polarity for each var, and fills defaultPolarities[] with it
    bool defaultPolarity(); //if polarity_mode is not polarity_auto, this returns the default polarity of the variable
    void tallyVotes(const vec<Clause*>& cs, vector<double>& votes) const;
    void tallyVotes(const vec<XorClause*>& cs, vector<double>& votes) const;
};


//=================================================================================================
// Implementation of inline methods:


inline void Solver::insertVarOrder(Var x)
{
    if (!order_heap.inHeap(x) && decision_var[x]) order_heap.insert(x);
}

inline void Solver::varDecayActivity()
{
    var_inc *= 11;
    var_inc /= 10;
}
inline void Solver::varBumpActivity(Var v)
{
    if ( (activity[v] += var_inc) > (0x1U) << 24 ) {
        //printf("RESCALE!!!!!!\n");
        //std::cout << "var_inc: " << var_inc << std::endl;
        // Rescale:
        for (Var var = 0; var != nVars(); var++) {
            activity[var] >>= 14;
        }
        var_inc >>= 14;
        //var_inc = 1;
        //std::cout << "var_inc: " << var_inc << std::endl;
        
        /*Heap<VarOrderLt> copy_order_heap2(order_heap);
        while(!copy_order_heap2.empty()) {
            Var v = copy_order_heap2.getmin();
            if (decision_var[v])
                std::cout << "var_" << v+1 << " act: " << activity[v] << std::endl;
        }*/
    }

    // Update order_heap with respect to new activity:
    if (order_heap.inHeap(v))
        order_heap.decrease(v);
}

inline void Solver::claBumpActivity (Clause& c)
{
    if ( (c.oldActivity() += cla_inc) > 1e20 ) {
        // Rescale:
        for (uint32_t i = 0; i < learnts.size(); i++)
            learnts[i]->oldActivity() *= 1e-17;
        cla_inc *= 1e-20;
    }
}

inline void Solver::claDecayActivity()
{
    //cla_inc *= clause_decay;
}

inline bool     Solver::enqueue         (Lit p, Clause* from)
{
    return value(p) != l_Undef ? value(p) != l_False : (uncheckedEnqueue(p, from), true);
}
inline bool     Solver::locked          (const Clause& c) const
{
    return reason[c[0].var()] == &c && value(c[0]) == l_True;
}
inline void     Solver::newDecisionLevel()
{
    trail_lim.push(trail.size());
    #ifdef VERBOSE_DEBUG
    cout << "New decision level: " << trail_lim.size() << endl;
    #endif
}
/*inline int     Solver::nbPropagated(int level) {
    if (level == decisionLevel())
        return trail.size() - trail_lim[level-1] - 1;
    return trail_lim[level] - trail_lim[level-1] - 1;
}*/
inline uint32_t      Solver::decisionLevel ()      const
{
    return trail_lim.size();
}
inline uint32_t Solver::abstractLevel (const Var& x) const
{
    return 1 << (level[x] & 31);
}
inline lbool    Solver::value         (const Var& x) const
{
    return assigns[x];
}
inline lbool    Solver::value         (const Lit& p) const
{
    return assigns[p.var()] ^ p.sign();
}
inline lbool    Solver::modelValue    (const Lit& p) const
{
    return model[p.var()] ^ p.sign();
}
inline uint32_t      Solver::nAssigns      ()      const
{
    return trail.size();
}
inline uint32_t      Solver::nClauses      ()      const
{
    return clauses.size() + xorclauses.size()+binaryClauses.size();
}
inline uint32_t      Solver::nLiterals      ()      const
{
    return clauses_literals + learnts_literals;
}
inline uint32_t      Solver::nLearnts      ()      const
{
    return learnts.size();
}
inline uint32_t      Solver::nVars         ()      const
{
    return assigns.size();
}
inline void     Solver::setPolarity   (Var v, bool b)
{
    polarity    [v] = (char)b;
}
inline void     Solver::setDecisionVar(Var v, bool b)
{
    decision_var[v] = b;
    if (b) {
        insertVarOrder(v);
    }
}
inline lbool     Solver::solve         ()
{
    vec<Lit> tmp;
    return solve(tmp);
}
inline bool     Solver::okay          ()      const
{
    return ok;
}
inline void     Solver::setSeed (const uint32_t seed)
{
    mtrand.seed(seed);    // Set seed of the variable-selection and clause-permutation(if applicable)
}
#ifdef STATS_NEEDED
inline void     Solver::needStats()
{
    dynamic_behaviour_analysis = true;    // Sets the solver and the logger up to generate statistics
    logger.statistics_on = true;
}
inline void     Solver::needProofGraph()
{
    dynamic_behaviour_analysis = true;    // Sets the solver and the logger up to generate proof graphs during solving
    logger.proof_graph_on = true;
}
inline void     Solver::setVariableName(Var var, char* name)
{
    while (var >= nVars()) newVar();
    if (dynamic_behaviour_analysis)
        logger.set_variable_name(var, name);
} // Sets the varible 'var'-s name to 'name' in the logger
#else
inline void     Solver::setVariableName(Var var, char* name)
{}
#endif

#ifdef USE_GAUSS
inline const uint32_t Solver::get_sum_gauss_unit_truths() const
{
    return sum_gauss_unit_truths;
}

inline const uint32_t Solver::get_sum_gauss_called() const
{
    return sum_gauss_called;
}

inline const uint32_t Solver::get_sum_gauss_confl() const
{
    return sum_gauss_confl;
}

inline const uint32_t Solver::get_sum_gauss_prop() const
{
    return sum_gauss_prop;
}
#endif

inline const uint Solver::get_unitary_learnts_num() const
{
    if (decisionLevel() > 0)
        return trail_lim[0];
    else
        return trail.size();
}
template <class T>
inline void Solver::removeWatchedCl(vec<T> &ws, const Clause *c) {
    uint32_t j = 0;
    for (; j < ws.size() && ws[j].clause != c; j++);
    assert(j < ws.size());
    for (; j < ws.size()-1; j++) ws[j] = ws[j+1];
    ws.pop();
}
template <class T>
inline void Solver::removeWatchedBinCl(vec<T> &ws, const Clause *c) {
    uint32_t j = 0;
    for (; j < ws.size() && ws[j].clause != c; j++);
    assert(j < ws.size());
    for (; j < ws.size()-1; j++) ws[j] = ws[j+1];
    ws.pop();
}
template<class T>
inline bool Solver::findWatchedCl(const vec<T>& ws, const Clause *c) const
{
    uint32_t j = 0;
    for (; j < ws.size() && ws[j].clause != c; j++);
    return j < ws.size();
}
template<class T>
inline bool Solver::findWatchedBinCl(const vec<T>& ws, const Clause *c) const
{
    uint32_t j = 0;
    for (; j < ws.size() && ws[j].clause != c; j++);
    return j < ws.size();
}
inline void Solver::reverse_binary_clause(Clause& c) const {
    if (c.size() == 2 && value(c[0]) == l_False) {
        assert(value(c[1]) == l_True);
        std::swap(c[0], c[1]);
    }
}
/*inline void Solver::calculate_xor_clause(Clause& c2) const {
    if (c2.isXor() && ((XorClause*)&c2)->updateNeeded())  {
        XorClause& c = *((XorClause*)&c2);
        bool final = c.xor_clause_inverted();
        for (int k = 0, size = c.size(); k != size; k++ ) {
            const lbool& val = assigns[c[k].var()];
            assert(val != l_Undef);
            
            c[k] = c[k].unsign() ^ val.getBool();
            final ^= val.getBool();
        }
        if (final)
            c[0] = c[0].unsign() ^ !assigns[c[0].var()].getBool();
        
        c.setUpdateNeeded(false);
    }
}*/

template<class T>
inline void Solver::removeClause(T& c)
{
    detachClause(c);
    clauseFree(&c);
}

//=================================================================================================
// Debug + etc:

static inline void logLit(FILE* f, Lit l)
{
    fprintf(f, "%sx%d", l.sign() ? "~" : "", l.var()+1);
}

static inline void logLits(FILE* f, const vec<Lit>& ls)
{
    fprintf(f, "[ ");
    if (ls.size() > 0) {
        logLit(f, ls[0]);
        for (uint32_t i = 1; i < ls.size(); i++) {
            fprintf(f, ", ");
            logLit(f, ls[i]);
        }
    }
    fprintf(f, "] ");
}

static inline const char* showBool(bool b)
{
    return b ? "true" : "false";
}


// Just like 'assert()' but expression will be evaluated in the release version as well.
static inline void check(bool expr)
{
    assert(expr);
}

#ifndef DEBUG_ATTACH
inline void Solver::testAllClauseAttach() const
{
    return;
}
inline void Solver::findAllAttach() const
{
    return;
}
#endif //DEBUG_ATTACH

inline void Solver::uncheckedEnqueueLight(const Lit p)
{
    assigns [p.var()] = boolToLBool(!p.sign());//lbool(!sign(p));  // <<== abstract but not uttermost effecient
    trail.push(p);
}

//=================================================================================================
#endif //SOLVER_H