#include <iostream>
#include <string>
#include <mutex>

#include "example.h"

using namespace L87;

class S1 : public State {
public:
	S1(StateDiagram* parent) : State(parent) { auto_register(); }
	const char* name() override { return "S1"; }
	virtual State* next(char input) override {
		if (input == 'a') {
			return states["S2"];
		}
		if (input == 'b') {
			return this; // states["S1"];
		}
		return states["E"];
	}
};

class S2 : public State {
public:
	S2(StateDiagram* parent) : State(parent) { auto_register(); }
	virtual const char* name() override { return "S2"; }
	virtual State* next(char input) override {
		if (input == 'a') {
			return states["S3"];
		}
		if (input == 'b') {
			return this; // states["S2"];
		}
		if (input == 'c') {
			return states["T"];
		}
		return states["E"];
	}
};

class S3 : public State {
public:
	S3(StateDiagram* parent) : State(parent) { auto_register(); }
	virtual const char* name() override { return "S3"; }
	virtual State* next(char input) override {
		if (input == 'a') {
			return states["S1"];
		}
		if (input == 'b') {
			return this; // states["S3"];
		}
		return states["E"];
	}
};

class T : public State {
public:
	T(StateDiagram* parent) : State(parent) { auto_register(); }
	virtual const char* name() override { return "T"; }
	virtual State* next(char input) override {
		return this; // states["T"];
	}
	virtual bool done() override { return true; }
};

class E : public State {
public:
	E(StateDiagram* parent) : State(parent) { auto_register(); }
	virtual const char* name() override { return "E"; }
	virtual State* next(char input) override {
		return this; // states["E"];
	}
	virtual bool done() override { return true; }
	virtual bool bad() override { return true; }
};

class TestStateDiagram : public StateDiagram {
private:
	static TestStateDiagram* instance;
	static std::mutex mtx;
private:
	TestStateDiagram() {
		initial = new S1(this);
		new S2(this);
		new S3(this);
		new T(this);
		new E(this);
	}
public:
	static TestStateDiagram& Instance() {
		if (instance == nullptr) {
			mtx.lock();
			if (instance == nullptr) {
				instance = new TestStateDiagram();
			}
			mtx.unlock();
		}
		return *instance;
	}
	static void Destory() {
		if (instance != nullptr) {
			mtx.lock();
			if (instance != nullptr) {
				TestStateDiagram* to_del = instance;
				instance = nullptr;
				delete to_del;
			}
			mtx.unlock();
		}
	}
};

TestStateDiagram* TestStateDiagram::instance = nullptr;
std::mutex TestStateDiagram::mtx;

void test1() {
	// TestStateDiagram 状态图包含 5 个状态: S1, S2, S3, T, E
	// s	a	b	c	oth
	// S1	S2	S1	E	E
	// S2	S3	S2	T	E
	// S3	S1	S3	E	E
	// T	T	T	T	T
	// E	E	E	E	E

	L87::Automata automata(TestStateDiagram::Instance());
	{
		std::string input = "ab?!ababac";
		L87::Automata::Result result = automata.Run(input);
		std::cout << input << ": " << result.value << std::endl;
	}
	{
		std::string input = "abababaabccasvsddb";
		L87::Automata::Result result = automata.Run(input);
		std::cout << input << ": " << result.value << std::endl;
	}
	{
		std::string input = "abaabbbaaaac";
		L87::Automata::Result result = automata.Run(input);
		std::cout << input << ": " << result.value << std::endl;
	}
	TestStateDiagram::Destory();
}