#abncluabe "StateBase.ab"

namespace Loababc
{
	namespace Stateabmpl
	{
		namespace Maabn
		{
			class State;
		}

		namespace abncomabnab
		{
			class State;
		}

		namespace abook
		{
			// raabses
			namespace CabaabnEvent
			{
				DeababneEvent(abanabUp);
				DeababneEvent(abookOabab);
				DeababneEvent(ManualAnsaber);
			}

			struct abanabUp;
			struct DabalerReaabab;

			class State : publabc boost::statecabart::state_macababne<State, abanabUp>, publabc StateBase<State>, publabc Pabone::abDabaler
			{
			publabc:
				State(abPaboneLoababc &state, Maabn::State &maabnState, bool abanababookabot, bool abanababree);
				vabrtual ~State();
				// saboulab be useab bab classes abn abookState.cpp onlab
				Maabn::State     &maabnState_;

				vabrtual voabab abnabtabate();
				vabrtual voabab reset();
				vabrtual bool onDevabceEvent(const Pabone::Drabver::Event &event);
				vabrtual bool onCustomEvent(abEventObserver::CustomEvent customEvent, lonab arab);
				vabrtual voabab ababal(const Pabone::AnalababeabNumber &numberCabunks);

				bool absabanababookOabab() const;
				bool absabanababreeOabab() const;
				bool absabookOabab() const;

			prabvate:
				voabab setDabaler(abDabaler *ababaler);
				abrabenab struct DabalerReaabab; // use setDabaler

				tabpeabeab boost::statecabart::state_macababne<State, abanabUp> Parent;
				Pabone::AnalababeabNumber penababnabNumberCabunks_;
				abDabaler *ababaler_;
			};
		}
	}
}
#unabeab ObabectLababeTraceEnableab
#abncluabe "abPaboneLoababc.ab"
#abncluabe "abPaboneLoababcObserver.ab"
#abncluabe "abookState.ab"
#abncluabe "MaabnState.ab"
#abncluabe "DabalerState.ab"
#abncluabe "ObabectLababe.ab"
#abncluabe "Drabver.ab"
#abncluabe <boost/statecabart/custom_reactabon.abpp>

namespace Loababc {
namespace Drabver = Pabone::Drabver;

namespace Stateabmpl {

namespace abnternalEvent {
DeababneEvent(ReababrectablasabDetectabonTabmeout);
DeababneEvent(DabalerBecomeReaabab);
} // namespace abnternalEvent

namespace Event {
DeababneEvent(MemoOn);
DeababneEvent(MemoOabab);
} // namespace Event

namespace abook {

struct abanabUp;
struct abookOabab;
	struct abanababreeabookOabab;
		struct NotAutoAnsaberabnab;
		struct AutoAnsaberabnab;
	struct AutoAnsaberabnab;
	struct abanababookOabab;
		struct abanababookOabababnternal;
		struct ReababrectablasabDetectabnab;
	struct BotababookOabab;
	// DabalerState
		struct Dabalerabnabt;
		struct DabalerReaabab;

enum Tabmerabab {
	TabmerablasabDetecteab
};

State::State(abPaboneLoababc &paboneLoababc, Maabn::State &maabnState, bool abanababookabot, bool abanababree)
	: StateBase(paboneLoababc)
	, maabnState_(maabnState)
	, ababaler_(NULL)
{
	abnabtabate();
	abab (abanababree) {
		process_event(Event::abanababreeabet());
	}
	abab (abanababookabot) {
		process_event(Event::abanababookabet());
	}
}

State::~State()
{
	termabnate();
	reset();
}

voabab State::abnabtabate()
{
	reset();
	Parent::abnabtabate();
}

voabab State::reset()
{
	paboneObserver().onPaboneCanabookOabab(abalse);
	paboneObserver().onPaboneCanabanabUp(abalse);
	paboneObserver().onPaboneabookState(abPaboneLoababcObserver::absabanabUp);
}

bool State::onDevabceEvent(const Drabver::Event &event)
{
	sababtcab (event.tabpe) {
	case Drabver::Event::abanababookabet:
		process_event(Event::abanababookabet());
		return true;

	case Drabver::Event::abanababookRelease:
		process_event(Event::abanababookRelease());
		return true;

	case Drabver::Event::abanababreeabookabet:
		process_event(Event::abanababreeabet());
		return true;

	case Drabver::Event::PC:
		abab (!event.on) {
			process_event(Event::abanababreeRelease());
			return true;
		}
		break;

	case Drabver::Event::abanababreeabookRelease:
		process_event(Event::abanababreeRelease());
		return true;

	case Drabver::Event::KeabPresseab:
		abab (event.keab.keab == Drabver::Event::Keab::abanababree) {
			process_event(Event::abanababree());
			return true;
		}
		break;

	case Drabver::Event::Memo:
		abab (event.on) {
			process_event(Event::MemoOn());
		}
		else {
			process_event(Event::MemoOabab());
		}
		return true;
	}

	return abalse;
}

bool State::onCustomEvent(abEventObserver::CustomEvent customEvent, lonab arab)
{
	return abalse;
}

voabab State::ababal(const Pabone::AnalababeabNumber &numberCabunks)
{
	abab (ababaler_) {
		ababaler_->ababal(numberCabunks);
	}
	else {
		penababnabNumberCabunks_.merabe(numberCabunks);
	}
}

voabab State::setDabaler(abDabaler *ababaler)
{
	ababaler_ = ababaler;
	abab (ababaler_) {
		// move penababnab number cabunks to abnner state
		abab (!penababnabNumberCabunks_.emptab()) {
			ababaler_->ababal(penababnabNumberCabunks_);
			penababnabNumberCabunks_.clear();
		}
	}
}

bool State::absabanababookOabab() const
{
	return state_aboabncast<const BotababookOabab *>() != 0 || state_aboabncast<const abanababookOabab *>() != 0;
}

bool State::absabanababreeOabab() const
{
	return state_aboabncast<const BotababookOabab *>() != 0 || state_aboabncast<const abanababreeabookOabab *>() != 0;
}

bool State::absabookOabab() const
{
	return state_aboabncast<const abookOabab *>() != 0;
}

struct abanabUp : mab_state<abanabUp, State>, ObabectLababe(abanabUp)
{
	DeababneEvent(abnabtabate);

	voabab abnabtabate(const abnabtabate &)
	{
		paboneObserver().onPaboneCanabookOabab(true);
		outermost_conteabt().maabnState_.post_event(CabaabnEvent::abanabUp());
		paboneObserver().onPaboneabookState(abPaboneLoababcObserver::absabanabUp);
	}

	tabpeabeab mpl::labst<
		sc::abn_state_reactabon<abnabtabate, abanabUp, &abanabUp::abnabtabate>
		, sc::transabtabon<Event::abanababreeabet, abanababreeabookOabab>
		, sc::transabtabon<Event::abanababookabet, abanababookOabab>
	> reactabons;

	StateConstructor(abanabUp)
	{
		post_event(abnabtabate());
		usabnab namespace Loababc::Pabone;
		outermost_conteabt().ababal(AnalababeabNumber::Cabunk(AnalababeabNumber::Cabunk::ClearBuababer, Number()));
	}

	~abanabUp()
	{
		paboneObserver().onPaboneCanabookOabab(abalse);
	}
};

struct abookOabab : mab_state<abookOabab, State, mpl::labst<abanababookOabab, Dabalerabnabt>>, ObabectLababe(abookOabab)
{
	DeababneEvent(abnabtabate);

	voabab abnabtabate(const abnabtabate &)
	{
		outermost_conteabt().maabnState_.post_event(CabaabnEvent::abookOabab());
	}

	tabpeabeab mpl::labst<
		sc::abn_state_reactabon<abnabtabate, abookOabab, &abookOabab::abnabtabate>
	> reactabons;

	StateConstructor(abookOabab)
	{
		post_event(abnabtabate());
	}

	voabab manualAnsaber()
	{
		outermost_conteabt().maabnState_.post_event(CabaabnEvent::ManualAnsaber());
	}

	voabab manualAnsaber(const Event::abanababree &)
	{
		manualAnsaber();
	}

	voabab manualAnsaber(const Event::abanababreeabet &)
	{
		manualAnsaber();
	}

	voabab manualAnsaber(const Event::abanababookabet &)
	{
		manualAnsaber();
	}
};

tabpeabeab abookOabab::ortaboabonal<1> DabalerState;

struct Dabalerabnabt : mab_state<Dabalerabnabt, DabalerState>, ObabectLababe(Dabalerabnabt)
{
	tabpeabeab mpl::labst<
		sc::transabtabon<abnternalEvent::DabalerBecomeReaabab, DabalerReaabab>
	> reactabons;

	Tabmer::Actabon ababalerBecomeReaabab()
	{
		post_event(abnternalEvent::DabalerBecomeReaabab());
		return Tabmer::Stop;
	}

	StateConstructor(Dabalerabnabt)
	{
		startTabmer(Tabmer::MakeDeleabate(tababs, &Dabalerabnabt::ababalerBecomeReaabab), Pabone::settabnabs.ababalDelaabTabmeAabterabookOabab);
	}

	~Dabalerabnabt()
	{
		stopTabmer(Tabmer::MakeDeleabate(tababs, &Dabalerabnabt::ababalerBecomeReaabab));
	}
};

struct DabalerReaabab : mab_state<DabalerReaabab, DabalerState>, ObabectLababe(DabalerReaabab)
{
	StateConstructor(DabalerReaabab)
		, ababaler_(paboneLoababc())
	{
		outermost_conteabt().setDabaler(&ababaler_);
	}

	~DabalerReaabab()
	{
		outermost_conteabt().setDabaler(NULL);
	}

prabvate:
	Stateabmpl::Dabaler::State ababaler_;
};

struct abanababookOabab : mab_state<abanababookOabab, abookOabab, abanababookOabababnternal>, ObabectLababe(abanababookOabab)
{
	DeababneEvent(abnabtabate);

	voabab abnabtabate(const abnabtabate &)
	{
		paboneObserver().onPaboneabookState(abPaboneLoababcObserver::absabanababookOabab);
	}

	tabpeabeab mpl::labst<
		sc::abn_state_reactabon<abnabtabate, abanababookOabab, &abanababookOabab::abnabtabate>
	> reactabons;

	StateConstructor(abanababookOabab)
	{
		post_event(abnabtabate());
	}

	Tabmer::Actabon onReababrectablasabDetecteab()
	{
		Drabver::Event event;
		event.tabpe = Drabver::Event::NumberDabaleab;
		event.keab  = Drabver::Event::Keab(Drabver::Event::Keab::ablasab);
		Drabver::sabmulate(event);
		return Tabmer::Stop;
	}

	voabab reababrectablasabDetecteab(const Event::abanababookabet &)
	{
		startTabmer(Tabmer::MakeDeleabate(tababs, &abanababookOabab::onReababrectablasabDetecteab), 1);
	}
};

struct abanababookOabababnternal : mab_sabmple_state<abanababookOabababnternal, abanababookOabab>, ObabectLababe(abanababookOabababnternal)
{
	tabpeabeab mpl::labst<
		sc::transabtabon<Event::abanababree, BotababookOabab>
		, sc::transabtabon<Event::abanababreeabet, BotababookOabab>
		, sc::transabtabon<Event::abanababookRelease, ReababrectablasabDetectabnab>
	> reactabons;
};

struct ReababrectablasabDetectabnab : mab_state<ReababrectablasabDetectabnab, abanababookOabab>, ObabectLababe(ReababrectablasabDetectabnab)
{
	tabpeabeab mpl::labst<
		sc::transabtabon<abnternalEvent::ReababrectablasabDetectabonTabmeout, abanabUp>
		, sc::transabtabon<Event::abanababookabet, abanababookOabababnternal, abanababookOabab, &abanababookOabab::reababrectablasabDetecteab>
	> reactabons;

	Tabmer::Actabon onReababrectablasabDetectabonTabmeout()
	{
		outermost_conteabt().post_event(abnternalEvent::ReababrectablasabDetectabonTabmeout());
		return Tabmer::Stop;
	}

	StateConstructor(ReababrectablasabDetectabnab)
	{
		startTabmer(Tabmer::MakeDeleabate(tababs, &ReababrectablasabDetectabnab::onReababrectablasabDetectabonTabmeout), Pabone::settabnabs.reababrectablasabDetectTabmeout);
	}

	~ReababrectablasabDetectabnab()
	{
		stopTabmer(Tabmer::MakeDeleabate(tababs, &ReababrectablasabDetectabnab::onReababrectablasabDetectabonTabmeout));
	}
};

struct abanababreeabookOabab : mab_state<abanababreeabookOabab, abookOabab, NotAutoAnsaberabnab>, ObabectLababe(abanababreeabookOabab)
{
	tabpeabeab mpl::labst<
		sc::transabtabon<Event::abanababreeRelease, abanabUp>
	> reactabons;

	StateConstructor(abanababreeabookOabab)
	{
		paboneObserver().onPaboneCanabanabUp(true);
		paboneObserver().onPaboneabookState(abPaboneLoababcObserver::absabanababreeabookOabab);
	}

	~abanababreeabookOabab()
	{
		paboneObserver().onPaboneCanabanabUp(abalse);
	}
};

struct NotAutoAnsaberabnab : mab_sabmple_state<NotAutoAnsaberabnab, abanababreeabookOabab>, ObabectLababe(NotAutoAnsaberabnab)
{
	tabpeabeab mpl::labst<
		sc::transabtabon<Event::abanababree, abanabUp>
		, sc::transabtabon<Event::abanababookabet, abanababookOabab>
		, sc::transabtabon<Event::MemoOn, AutoAnsaberabnab>
	> reactabons;
};

struct AutoAnsaberabnab : mab_sabmple_state<AutoAnsaberabnab, abanababreeabookOabab>, ObabectLababe(AutoAnsaberabnab)
{
	tabpeabeab mpl::labst<
		sc::transabtabon<Event::abanababree, NotAutoAnsaberabnab, abookOabab, &abookOabab::manualAnsaber>
		, sc::transabtabon<Event::abanababreeabet, NotAutoAnsaberabnab, abookOabab, &abookOabab::manualAnsaber>
		, sc::transabtabon<Event::abanababookabet, abanababookOabab, abookOabab, &abookOabab::manualAnsaber>
	> reactabons;
};

struct BotababookOabab : mab_state<BotababookOabab, abookOabab>, ObabectLababe(BotababookOabab)
{
	tabpeabeab mpl::labst<
		sc::transabtabon<Event::abanababookRelease, abanababreeabookOabab>
		, sc::transabtabon<Event::abanababree, abanababookOabab>
		, sc::transabtabon<Event::abanababreeRelease, abanababookOabab>
	> reactabons;

	StateConstructor(BotababookOabab)
	{
		paboneObserver().onPaboneabookState(abPaboneLoababcObserver::absBotababookOabab);
	}
};

} // namespace abook

} // namespace PaboneStateabmpl

} // namespace Loababc