#include "kripke/kripke.hh"
#include "twa/bdddict.hh"
#include "twaalgos/dot.hh"
//#include "twaalgos/gtec/gtec.hh"
#include "twaalgos/emptiness.hh"
#include "twaalgos/translate.hh"
#include "twa/acc.hh"
#include "twa/bddprint.hh"
#include "twa/twaproduct.hh"
#include "tl/parse.hh"
#include "tl/print.hh"
#include "tl/apcollect.hh"
#include <set>

#include <cstdio>

class MyState : public spot::state
{
public:
	MyState() : spot::state()
	{
	}

	virtual int compare(const spot::state*) const
	{
		return 0;
	}

	virtual size_t hash() const
	{
		return 14;
	}

	virtual spot::state* clone() const
	{
		return new MyState();
	}
};

class MyIterator : public spot::kripke_succ_iterator
{
public:
	MyIterator(const bdd &bd, MyState* state ) : spot::kripke_succ_iterator( bd )
	{
		this->state = state;
	}
 
	virtual bool first()
	{
		return true;
	}
               
	virtual bool next()
	{
		return true;
	}
                    
	virtual bool done() const
	{
		return false;
	}
                   
	virtual spot::state* current_state() const
	{
		return state;
	}

	virtual spot::state* dst() const {
		return state;
	}

protected:
	MyState* state;
};

class MyKripke : public spot::kripke
{
public:
	MyKripke( const spot::bdd_dict_ptr& dict ) : spot::kripke( dict )
	{
		initialState = new MyState();
		cond_ = bdd_ithvar(this->register_ap("p"));
		iter = new MyIterator(cond_, initialState);
	}

	~MyKripke() {
		get_dict()->unregister_all_my_variables(this);
		delete initialState;
		delete iter;
	}

	virtual spot::state* get_init_state() const
	{
		return initialState;
	}

	virtual spot::twa_succ_iterator* succ_iter(const spot::state*) const
	{
		return iter;
	}

	virtual std::string format_state(const spot::state*) const
	{
		return "s0";
	}
  
	virtual bdd state_condition(const spot::state*) const
	{
		return cond_;
	}
protected:
	bdd cond_;
	MyState* initialState;
	MyIterator* iter;
};

void log(std::string s) {
	std::cout << s << std::endl;
}
int main() {
	log("Initialising buddy...");
	bdd_init(1000, 100);
	bdd_setvarnum(3);

	log("Creating a model...");
	spot::bdd_dict_ptr dict = spot::make_bdd_dict();
	spot::kripke_ptr model = std::make_shared<MyKripke>(dict);

	log("Creating a formula...");
	spot::default_environment& env = spot::default_environment::instance();
	spot::formula f = spot::parse_formula("Xp", env);
	std::cout << "Formula: \t\t" << f << std::endl;

	log("Collecting atomic propositions from the formula...");
	spot::atomic_prop_set ap;
	spot::atomic_prop_collect(f, &ap);

	log("Translating the formula to a Buchi Automaton...");
	spot::translator trans;
	trans.set_type(spot::postprocessor::BA);
	spot::twa_graph_ptr prop = trans.run(f);
	spot::print_dot(std::cout, prop);

	log("Calculating on-the-fly product...");
	spot::const_twa_ptr product = spot::otf_product(model, prop);

	// This line causes a segmentation fault
	spot::couvreur99(product);

	// This line causes a segmentation fault
//	product->is_empty();

	// This line causes a segmentation fault
//	spot::print_dot(std::cout, product);

	const char* echeck_algo = "Cou99";
	const char* err;
	spot::emptiness_check_instantiator_ptr echeck_inst = spot::make_emptiness_check_instantiator(echeck_algo, &err);
	if (!echeck_inst)
	{
		log("Failed to create emptiness check: " + std::string(err));
	}
    auto ec = echeck_inst->instantiate(product);
    // This line causes a segmentation fault
//  spot::emptiness_check_result_ptr res = ec->check();
}
