#include <msp430g2553.h>
#include <stdint.h>

#include "hmi.h"
#include "engine.h"
#include "debug.h"



class SwitchPort {
public:
	enum e_switchResult { SWITCH_IDLE, SWITCH_SHORT, SWITCH_LONG };
	SwitchPort() : m_state(STATE_IDLE) {
	};
	virtual bool getSwitchState() { debugWrite(0x009); return false; };
	e_switchResult get() {
		e_switchResult result = SWITCH_IDLE;
		bool inValue = getSwitchState();
		uint32_t duration;
		switch (m_state) {
		case STATE_IDLE:
			if (inValue == false) {
				// debugWrite(0x001);
				m_state = STATE_BUTTON_PRESSED;
				m_timestamp = getMillis();
			}
			break;
		case STATE_BUTTON_PRESSED:
			if (inValue == true) {
				// debugWrite(0x002);
				m_state = STATE_BUTTON_RELEASED;
			}
			break;
		case STATE_BUTTON_RELEASED:
			duration = getMillis() - m_timestamp;
//			{
//				uint16_t d1 = (uint16_t) (duration & 0x0000ffff);
//				uint16_t d2 = (uint16_t) ((duration & 0xffff0000) >> 16);
//				debugWrite(d1);
//				debugWrite(d2);
//			}
			if ((duration >= LOWER_SHORT_TIME) && (duration <= UPPER_SHORT_TIME)) {
				// debugWrite(0x003);
				m_state = STATE_SHORT;
			} else if (duration > UPPER_SHORT_TIME) {
				// debugWrite(0x004);
				m_state = STATE_LONG;
			} else {
				// debugWrite(0x005);
				m_state = STATE_IDLE;
			}
			break;
		case STATE_SHORT:
			result = SWITCH_SHORT;
			m_state = STATE_IDLE;
			break;
		case STATE_LONG:
			result = SWITCH_LONG;
			m_state = STATE_IDLE;
			break;
		default:
			m_state = STATE_IDLE;
			break;
		}

		return result;
	};
private:
	static const uint32_t LOWER_SHORT_TIME = 100;
	static const uint32_t UPPER_SHORT_TIME = 300;
	enum e_state { STATE_IDLE, STATE_BUTTON_PRESSED, STATE_BUTTON_RELEASED, STATE_SHORT, STATE_LONG };
	e_state m_state;
	uint32_t m_timestamp;
};

class SwitchPort2 : public SwitchPort {
public:
	SwitchPort2(uint16_t bit) : SwitchPort() {
		m_bit = bit;
		P2REN |= bit;
		P2DIR &= ~bit;
		P2SEL &= ~bit;
	};
	virtual bool getSwitchState() {
		bool a = P2IN & m_bit;
		//		if (a)
		//			debugWrite(0x00A);
		//		else
		//			debugWrite(0x00B);
		return a;
	};
private:
	uint16_t m_bit;
};
class SwitchPort1 : public SwitchPort {
public:
	SwitchPort1(uint16_t bit) : SwitchPort() {
		m_bit = bit;
		P1REN |= bit;
		P1DIR &= ~bit;
		P1SEL &= ~bit;
	};
	virtual bool getSwitchState() {
		return P1IN & m_bit;
	};
private:
	uint16_t m_bit;
};

class Led {
public:
	enum e_flashType { FLASH_SHORT, FLASH_LONG };
	Led() : m_state(STATE_IDLE), m_timeout(0) {
	}
	void start(e_flashType ft) {
		m_state = STATE_START;
		if (FLASH_LONG == ft) {
			m_timeout = LED_WAIT_TIME_LONG;
		} else {
			m_timeout = LED_WAIT_TIME_SHORT;
		}
	}
	virtual void set(bool v) {};
	void exec() {
		switch (m_state) {
			case STATE_IDLE:
				break;
			case STATE_START:
				set(true);
				m_state = STATE_ON;
				break;
			case STATE_ON:
				if (m_timeout == 0) {
					m_state = STATE_OFF;
				}
				m_timeout--;
				break;
			case STATE_OFF:
				set(false);
				m_state = STATE_IDLE;
				break;
			default:
				m_state = STATE_IDLE;
				break;
		}
	}
private:
	static const uint32_t LED_WAIT_TIME_SHORT = 500;
	static const uint32_t LED_WAIT_TIME_LONG = 1000;
	enum e_state { STATE_IDLE, STATE_START, STATE_ON, STATE_OFF };
	e_state m_state;
	uint32_t m_timeout;
};
class Led1 : public Led {
public:
	Led1(uint16_t bit) : Led() {
		m_bit = bit;
		P1DIR |= bit;
		P1OUT &= ~bit;
	}
	virtual void set(bool v) {
		if (v) {
			P1OUT |= m_bit;
		} else {
			P1OUT &= ~m_bit;
		}
	}
private:
	uint16_t m_bit;
};
class Led2 : public Led {
public:
	Led2(uint16_t bit) : Led() {
		m_bit = bit;
		P2DIR |= bit;
		P2OUT &= ~bit;
	}
	virtual void set(bool v) {
		if (v) {
			P2OUT |= m_bit;
		} else {
			P2OUT &= ~m_bit;
		}
	}
private:
	uint16_t m_bit;
};


SwitchPort2 intensitySwitch = SwitchPort2(BIT1);
SwitchPort2 onTimeSwitch = SwitchPort2(BIT2);
SwitchPort2 offTimeSwitch = SwitchPort2(BIT3);
//SwitchPort modeSwitch = SwitchPort2(BIT4);

Led1 ledGreen = Led1(BIT5);
Led1 ledRed = Led1(BIT4);


void hmiInit() {
}

void hmiExec() {
	if (intensitySwitch.get() == SwitchPort::SWITCH_SHORT) {
		if (engineIncPwmValue()) {
			ledGreen.start(Led::FLASH_SHORT);
		} else {
			ledGreen.start(Led::FLASH_LONG);
		}
	} else if (intensitySwitch.get() == SwitchPort::SWITCH_LONG) {
		if (engineDecPwmValue()) {
			ledRed.start(Led::FLASH_SHORT);
		} else {
			ledRed.start(Led::FLASH_LONG);
		}
	}


	if (onTimeSwitch.get() == SwitchPort::SWITCH_SHORT) {
		if (engineIncOnTime()) {
			ledGreen.start(Led::FLASH_SHORT);
		} else {
			ledGreen.start(Led::FLASH_LONG);
		}
	} else if (onTimeSwitch.get() == SwitchPort::SWITCH_LONG) {
		if (engineDecOnTime()) {
			ledRed.start(Led::FLASH_SHORT);
		} else {
			ledRed.start(Led::FLASH_LONG);
		}
	}

	if (offTimeSwitch.get() == SwitchPort::SWITCH_SHORT) {
		if (engineIncOffTime()) {
			ledGreen.start(Led::FLASH_SHORT);
		} else {
			ledGreen.start(Led::FLASH_LONG);
		}
	} else if (onTimeSwitch.get() == SwitchPort::SWITCH_LONG) {
		if (engineDecOffTime()) {
			ledRed.start(Led::FLASH_SHORT);
		} else {
			ledRed.start(Led::FLASH_LONG);
		}
	}

	ledRed.exec();
	ledGreen.exec();
}