#include <stdio.h>

#include "oswald.h"
#include "oswald_main.h"
#include "oswald_watch_faces.h"
#include "Fonts.h"
#include "LcdDisplay.h"
#include "oswald_hal.h"

#include "oswald_screens.h"


typedef struct {
	void (*screendraw_func)(boolean show_seconds);
	boolean show_seconds;
	boolean analogue;
} idle_data_t;
static idle_data_t idle_screen = {
	DrawLcdDigitalClock,
	TRUE,
	FALSE,
};
 
void idle_handle_user_buttons(watch_button button)
{
	switch (button) {
		case BUTTON_A:
			if (idle_screen.show_seconds)
				idle_screen.show_seconds = FALSE;
			else
				idle_screen.show_seconds = TRUE;
			break;
		case BUTTON_B:
			if (idle_screen.analogue == TRUE) {
				idle_screen.analogue = FALSE;
				idle_screen.screendraw_func = DrawLcdDigitalClock;
			} else {
				idle_screen.analogue = TRUE;
				idle_screen.screendraw_func = DrawLcdAnaClock;
			};
			break;
		case BUTTON_F:
			OswaldState.screen_id = DATETIME_SETTING_SCREEN;
			OswaldState.screen = &OswaldScreens[OswaldState.screen_id];
			OswaldState.screen->event_func(EVENT_SCREEN_VISIBLE, NULL);
			return;
			break;
		default:
			break;
	};
	idle_screen.screendraw_func(idle_screen.show_seconds);
}

void idle_handle_events(u16t event, void *data)
{
	switch (event) {
		case EVENT_ONE_SEC_TIMER:
		case EVENT_SCREEN_VISIBLE:
			idle_screen.screendraw_func(idle_screen.show_seconds);
			break;
		case EVENT_USER_BUTTONS:
			dbg_out("button event %d\n", *(int *)data);
			idle_handle_user_buttons(*(watch_button *)data);
			break;
		default:
			break;
	};
}


typedef struct {
	accel_data_t accdata;
} accelscreen_data_t;
static accelscreen_data_t accel_screen = {
	{ 0, 0, 0},
};

void draw_accel_screen(accel_data_t *accel_data)
{
	hal_lcd_clear_display();
	SetFont(MetaWatch16);
	WriteLcdString(2, 2, "X:");
	WriteLcdNumber(20, 2, accel_data->x);
	WriteLcdString(2, 18, "Y:");
	WriteLcdNumber(20, 18, accel_data->y);
	WriteLcdString(2, 34, "Z:");
	WriteLcdNumber(20, 34, accel_data->z);
	hal_lcd_update_display();
}

void accel_handle_events(u16t event, void *data)
{
	switch (event) {
		case EVENT_SCREEN_VISIBLE:
			draw_accel_screen(&accel_screen.accdata);
			break;
		case EVENT_ACCEL_UPDATE: {
			accel_data_t *accel_data = (accel_data_t *)data;
			accel_screen.accdata.x = accel_data->x;
			accel_screen.accdata.y = accel_data->y;
			accel_screen.accdata.z = accel_data->z;
			draw_accel_screen(&accel_screen.accdata);
			};
			break;
		case EVENT_USER_BUTTONS:
			dbg_out("button event %d\n", *(int *)data);
			break;
		default:
			break;
	};
}


typedef struct {
	u8t pos;
	boolean on;
} datetime_setup_data_t;
static datetime_setup_data_t dt_setup_screen = {
	0,
	TRUE
};

void draw_datetime_setup_screen(datetime_setup_data_t *sdata)
{
	hal_lcd_clear_display();
	SetFont(MetaWatch16);
	WriteLcdString(2, 2, "Set");

	SetFont(MetaWatchTime);
	if ((sdata->pos == 0 && sdata->on) || sdata->pos != 0) {
		WriteLcdCharacter(2, 20, (OswaldClk.hour / 10));
		WriteLcdCharacter(14, 20, (OswaldClk.hour % 10));
	}
	WriteLcdCharacter(26, 20, TIME_CHARACTER_COLON_INDEX);

	if ((sdata->pos == 1 && sdata->on) || sdata->pos != 1) {
		WriteLcdCharacter(31, 20, (OswaldClk.minute / 10));
		WriteLcdCharacter(43, 20, (OswaldClk.minute % 10));
	}

	WriteLcdCharacter(55, 20, TIME_CHARACTER_COLON_INDEX);

	if ((sdata->pos == 2 && sdata->on) || sdata->pos != 2) {
		WriteLcdCharacter(60, 20, (OswaldClk.second / 10));
		WriteLcdCharacter(72, 20, (OswaldClk.second % 10));
	}

	SetFont(MetaWatch16);
	if ((sdata->pos == 3 && sdata->on) || sdata->pos != 3) {
		WriteLcdNumber(2, 45, OswaldClk.day);
	}
	WriteLcdString(18, 45, ".");
	if ((sdata->pos == 4 && sdata->on) || sdata->pos != 4) {
		WriteLcdNumber(22, 45, OswaldClk.month);
	}
	WriteLcdString(38, 45, ".");
	if ((sdata->pos == 5 && sdata->on) || sdata->pos != 5) {
		WriteLcdNumber(42, 45, OswaldClk.year);
	}

	SetFont(MetaWatch7);
	if ((sdata->pos == 6 && sdata->on) || sdata->pos != 6) {
		if (OswaldClk.clk24hr)
			WriteLcdString(2, 66, "x");
		else
			WriteLcdString(2, 66, "_");
	}
	WriteLcdString(15, 66, "24hr");

	if ((sdata->pos == 7 && sdata->on) || sdata->pos != 7) {
		if (OswaldClk.day_first)
			WriteLcdString(2, 79, "x");
		else
			WriteLcdString(2, 79, "_");
	}
	WriteLcdString(15, 79, "dd.mm.  mm/dd");

	hal_lcd_update_display();
}

void datetime_handle_updown(u8t pos, s8t incr)
{
	switch (pos) {
		case 0: // hour
			if (OswaldClk.hour == 0 && incr == -1) {
				OswaldClk.hour = 23;
				break;
			};
			OswaldClk.hour += incr;
			if (OswaldClk.hour > 23)
				OswaldClk.hour = 0;
			break;
		case 1: // minute
			if (OswaldClk.minute == 0 && incr == -1) {
				OswaldClk.minute = 59;
				break;
			};
			OswaldClk.minute += incr;
			if (OswaldClk.minute > 59)
				OswaldClk.minute = 0;
			break;
		case 2: // second
			OswaldClk.second = 0;
			break;
		case 3: // day
			if (OswaldClk.day == 1 && incr == -1) {
				OswaldClk.day = 31;
				break;
			};
			OswaldClk.day += incr;
			if (OswaldClk.day > 31)
				OswaldClk.day = 1;
			break;
		case 4: // month
			if (OswaldClk.month == 1 && incr == -1) {
				OswaldClk.month = 12;
				break;
			};
			OswaldClk.month += incr;
			if (OswaldClk.month > 12)
				OswaldClk.month = 1;
			break;
		case 5: // year
			OswaldClk.year += incr;
			break;
		case 6: // 24hr / 12hr
			if (OswaldClk.clk24hr)
				OswaldClk.clk24hr = FALSE;
			else
				OswaldClk.clk24hr = TRUE;
			break;
		case 7: // dd.mm. / mm/dd
			if (OswaldClk.day_first)
				OswaldClk.day_first = FALSE;
			else
				OswaldClk.day_first = TRUE;
			break;
		default:
			break;
	};
	if (pos == 2)
		hal_set_rtc(&OswaldClk, TRUE);
	else
		hal_set_rtc(&OswaldClk, FALSE);
}

void handle_setup_datetime_buttons(watch_button button, datetime_setup_data_t *sdata)
{
	switch (button) {
		case BUTTON_A:
			datetime_handle_updown(sdata->pos, 1);
			break;
		case BUTTON_B:
			datetime_handle_updown(sdata->pos, -1);
			break;
		case BUTTON_F:
			sdata->pos++;
			sdata->pos %= 8;
			break;
		default:
			break;
	}
	draw_datetime_setup_screen(sdata);
}

void datetime_setup_events(u16t event, void *data)
{
	switch (event) {
		case EVENT_SCREEN_VISIBLE:
			dt_setup_screen.pos = 0;
			draw_datetime_setup_screen(&dt_setup_screen);
			hal_enable_halfsecond_timer();
			break;
		case EVENT_SCREEN_DESTROY:
			hal_disable_halfsecond_timer();
			break;
		case EVENT_USER_BUTTONS:
			dbg_out("button event %d\n", *(int *)data);
			handle_setup_datetime_buttons(*(watch_button *)data, &dt_setup_screen);
			break;
		case EVENT_HALF_SEC_TIMER:
			if (dt_setup_screen.on)
				dt_setup_screen.on = FALSE;
			else
				dt_setup_screen.on = TRUE;
			draw_datetime_setup_screen(&dt_setup_screen);
			break;
		default:
			break;
	};
}

typedef struct {
	u8t pos;
	boolean on;
} alarm_setup_data_t;
static alarm_setup_data_t alarm_setup_screen = {
	0,
	TRUE
};

void draw_alarm_setup_screen(alarm_setup_data_t *sdata)
{
	hal_lcd_clear_display();

	SetFont(MetaWatch16);
	WriteLcdString(2, 2, "Alarm");

	SetFont(MetaWatchTime);
	if ((sdata->pos == 0 && sdata->on) || sdata->pos != 0) {
		WriteLcdCharacter(2, 20, (OswaldAlarm.hour / 10));
		WriteLcdCharacter(14, 20, (OswaldAlarm.hour % 10));
	}
	WriteLcdCharacter(26, 20, TIME_CHARACTER_COLON_INDEX);

	if ((sdata->pos == 1 && sdata->on) || sdata->pos != 1) {
		WriteLcdCharacter(31, 20, (OswaldAlarm.minute / 10));
		WriteLcdCharacter(43, 20, (OswaldAlarm.minute % 10));
	}

	SetFont(MetaWatchMonospaced10);
	WriteLcdCharacter(3, 45, 'S');
	WriteLcdCharacter(15, 45, 'M');
	WriteLcdCharacter(27, 45, 'T');
	WriteLcdCharacter(39, 45, 'W');
	WriteLcdCharacter(51, 45, 'T');
	WriteLcdCharacter(63, 45, 'F');
	WriteLcdCharacter(75, 45, 'S');

	if ((sdata->pos == 2 && sdata->on) || sdata->pos != 2)
		WriteLcdCharacter(3, 55, (OswaldAlarm.wday & WDAY_SUNDAY) ? 'x' : '_');
	if ((sdata->pos == 3 && sdata->on) || sdata->pos != 3)
		WriteLcdCharacter(15, 55, (OswaldAlarm.wday & WDAY_MONDAY) ? 'x' : '_');
	if ((sdata->pos == 4 && sdata->on) || sdata->pos != 4)
		WriteLcdCharacter(27, 55, (OswaldAlarm.wday & WDAY_TUESDAY) ? 'x' : '_');
	if ((sdata->pos == 5 && sdata->on) || sdata->pos != 5)
		WriteLcdCharacter(39, 55, (OswaldAlarm.wday & WDAY_WEDNESDAY) ? 'x' : '_');
	if ((sdata->pos == 6 && sdata->on) || sdata->pos != 6)
		WriteLcdCharacter(51, 55, (OswaldAlarm.wday & WDAY_THURSDAY) ? 'x' : '_');
	if ((sdata->pos == 7 && sdata->on) || sdata->pos != 7)
		WriteLcdCharacter(63, 55, (OswaldAlarm.wday & WDAY_FRIDAY) ? 'x' : '_');
	if ((sdata->pos == 8 && sdata->on) || sdata->pos != 8)
		WriteLcdCharacter(75, 55, (OswaldAlarm.wday & WDAY_SATURDAY) ? 'x' : '_');

#if 0
	SetFont(MetaWatch7);
	if ((sdata->pos == 6 && sdata->on) || sdata->pos != 6) {
		if (OswaldClk.clk24hr)
			WriteLcdString(2, 66, "x");
		else
			WriteLcdString(2, 66, "_");
	}
	WriteLcdString(15, 66, "24hr");

	if ((sdata->pos == 7 && sdata->on) || sdata->pos != 7) {
		if (OswaldClk.day_first)
			WriteLcdString(2, 79, "x");
		else
			WriteLcdString(2, 79, "_");
	}
	WriteLcdString(15, 79, "dd.mm.  mm/dd");
#endif
	hal_lcd_update_display();
}

void alarm_handle_updown(u8t pos, s8t incr)
{
	switch (pos) {
		case 0: // hour
			if (OswaldAlarm.hour == 0 && incr == -1) {
				OswaldAlarm.hour = 23;
				break;
			};
			OswaldAlarm.hour += incr;
			if (OswaldAlarm.hour > 23)
				OswaldAlarm.hour = 0;
			break;
		case 1: // minute
			if (OswaldAlarm.minute == 0 && incr == -1) {
				OswaldAlarm.minute = 59;
				break;
			};
			OswaldAlarm.minute += incr;
			if (OswaldAlarm.minute > 59)
				OswaldAlarm.minute = 0;
			break;
		case 2: // sunday
			OswaldAlarm.wday ^= WDAY_SUNDAY;
			break;
		case 3: // monday
			OswaldAlarm.wday ^= WDAY_MONDAY;
			break;
		case 4: // tuesday
			OswaldAlarm.wday ^= WDAY_TUESDAY;
			break;
		case 5: // wednesday
			OswaldAlarm.wday ^= WDAY_WEDNESDAY;
			break;
		case 6: // thursday
			OswaldAlarm.wday ^= WDAY_THURSDAY;
			break;
		case 7: // friday
			OswaldAlarm.wday ^= WDAY_FRIDAY;
			break;
		case 8: // saturday
			OswaldAlarm.wday ^= WDAY_SATURDAY;
			break;
		default:
			break;
	};
}

void handle_setup_alarm_buttons(watch_button button, alarm_setup_data_t *sdata)
{
	switch (button) {
		case BUTTON_A:
			alarm_handle_updown(sdata->pos, 1);
			break;
		case BUTTON_B:
			alarm_handle_updown(sdata->pos, -1);
			break;
		case BUTTON_F:
			sdata->pos++;
			sdata->pos %= 9;
			break;
		default:
			break;
	}
	draw_alarm_setup_screen(sdata);
}

void alarm_setup_events(u16t event, void *data)
{
	switch (event) {
		case EVENT_SCREEN_VISIBLE:
			alarm_setup_screen.pos = 0;
			draw_alarm_setup_screen(&alarm_setup_screen);
			hal_enable_halfsecond_timer();
			break;
		case EVENT_SCREEN_DESTROY:
			hal_disable_halfsecond_timer();
			break;
		case EVENT_USER_BUTTONS:
			dbg_out("button event %d\n", *(int *)data);
			handle_setup_alarm_buttons(*(watch_button *)data, &alarm_setup_screen);
			break;
		case EVENT_HALF_SEC_TIMER:
			if (alarm_setup_screen.on)
				alarm_setup_screen.on = FALSE;
			else
				alarm_setup_screen.on = TRUE;
			draw_alarm_setup_screen(&alarm_setup_screen);
			break;
		default:
			break;
	};
}


typedef struct {
	u8t menu_pos;
} test_menu_t;
static test_menu_t test_menu = { 0 };

void draw_menu_test_screen(void)
{
	hal_lcd_clear_display();
	SetFont(MetaWatch16);
	WriteLcdString(2, 2, "Menu");
	SetFont(MetaWatch7);
	WriteLcdString(2, 20, "Item 1");
	WriteLcdString(2, 29, "Item 2");
	WriteLcdString(2, 38, "Item 3");
	WriteLcdString(2, 47, "Item 4");
	WriteLcdString(2, 56, "Item 5");

	WriteLcdString(50, 20+(9*test_menu.menu_pos), "*");
	hal_lcd_update_display();
}

static void handle_menu_user_buttons(watch_button button)
{
	switch (button) {
		case BUTTON_A:
			test_menu.menu_pos--;
			test_menu.menu_pos%=5;
			break;
		case BUTTON_B:
			test_menu.menu_pos++;
			test_menu.menu_pos%=5;
			break;
		default:
			break;
	}
	draw_menu_test_screen();
}

void test_menu_handle_events(u16t event, void *data)
{
	switch (event) {
		case EVENT_USER_BUTTONS:
			dbg_out("button event %d\n", *(int *)data);
			handle_menu_user_buttons(*(watch_button *)data);
			break;
		case EVENT_SCREEN_VISIBLE:
			test_menu.menu_pos = 0;
			draw_menu_test_screen();
			break;
		default:
			break;
	};
}


typedef struct {
	u8t hr;
	u8t min;
	u8t sec;
	u8t csec;
	u8t lapse_hr;
	u8t lapse_min;
	u8t lapse_sec;
	u8t lapse_csec;
	boolean running;
} stopwatch_data_t;
static stopwatch_data_t stopwatch_screen = { 0, 0, 0, 0, 0, 0, 0, 0, FALSE };


static void update_stop_watch_screen(stopwatch_data_t *sdata)
{
	char tstr[16];
	SetFont(MetaWatchMonospaced10);

#if 0
	WriteLcdNumber(0, 30, sdata->hr);
	WriteLcdCharacter(14, 30, ':');
	WriteLcdNumber(19, 30, sdata->min);
	WriteLcdCharacter(33, 30, ':');
	WriteLcdNumber(38, 30, sdata->sec);
	WriteLcdCharacter(52, 30, '.');
	WriteLcdNumber(57, 30, sdata->csec / 10);

	WriteLcdNumber(0, 50, sdata->lapse_hr);
	WriteLcdCharacter(14, 50, ':');
	WriteLcdNumber(19, 50, sdata->lapse_min);
	WriteLcdCharacter(33, 50, ':');
	WriteLcdNumber(38, 50, sdata->lapse_sec);
	WriteLcdCharacter(52, 50, '.');
	WriteLcdNumber(57, 50, sdata->lapse_csec / 10);
#else
	snprintf(tstr, 16, "%02d:%02d:%02d.%1d", sdata->hr, sdata->min, sdata->sec, sdata->csec / 10);
	WriteLcdString(0, 30, tstr);
	snprintf(tstr, 16, "%02d:%02d:%02d.%02d", sdata->lapse_hr, sdata->lapse_min, sdata->lapse_sec, sdata->lapse_csec);
	WriteLcdString(0, 50, tstr);
#endif

	hal_lcd_update_display();
}

static void draw_stop_watch_screen(stopwatch_data_t *sdata)
{
	SetFont(MetaWatch16);
	WriteLcdString(2, 5, "StopWatch");

	update_stop_watch_screen(sdata);
}

static void handle_stop_watch_buttons(watch_button button)
{
	switch (button) {
		case BUTTON_A: // start/stop
			if (stopwatch_screen.running) {
				hal_disable_centisecond_timer();
				stopwatch_screen.running = FALSE;
			} else {
				hal_enable_centisecond_timer();
				stopwatch_screen.running = TRUE;
			}
			break;
		case BUTTON_B: // lapse
			stopwatch_screen.lapse_hr = stopwatch_screen.hr;
			stopwatch_screen.lapse_min = stopwatch_screen.min;
			stopwatch_screen.lapse_sec = stopwatch_screen.sec;
			stopwatch_screen.lapse_csec = stopwatch_screen.csec;
			break;
		case BUTTON_F: // reset
			stopwatch_screen.hr = 0;
			stopwatch_screen.min = 0;
			stopwatch_screen.sec = 0;
			stopwatch_screen.csec = 0;
			stopwatch_screen.lapse_hr = 0;
			stopwatch_screen.lapse_min = 0;
			stopwatch_screen.lapse_sec = 0;
			stopwatch_screen.lapse_csec = 0;
			break;
		default:
			break;
	}
}

void stop_watch_handle_events(u16t event, void *data)
{
	switch (event) {
		case EVENT_USER_BUTTONS:
			dbg_out("button event %d\n", *(int *)data);
			handle_stop_watch_buttons(*(watch_button *)data);
			update_stop_watch_screen(&stopwatch_screen);
			break;
		case EVENT_SCREEN_VISIBLE:
			hal_lcd_clear_display();
			draw_stop_watch_screen(&stopwatch_screen);
			break;
		case EVENT_SCREEN_DESTROY:
			hal_disable_centisecond_timer();
			stopwatch_screen.running = FALSE;
			break;
		case EVENT_CS_TIMER:
			stopwatch_screen.csec++;
			if (stopwatch_screen.csec > 99) {
				stopwatch_screen.csec = 0;
				stopwatch_screen.sec++;
			};
			if (stopwatch_screen.sec > 59) {
				stopwatch_screen.sec = 0;
				stopwatch_screen.min++;
			};
			if (stopwatch_screen.min > 59) {
				stopwatch_screen.min = 0;
				stopwatch_screen.hr++;
			};
			if (stopwatch_screen.hr > 59) {
				stopwatch_screen.hr = 0;
			};
			if (stopwatch_screen.csec % 10 == 0)
				update_stop_watch_screen(&stopwatch_screen);
			break;
		default:
			break;
	};
}


void draw_alarm_screen(void)
{
	hal_lcd_clear_display();

	SetFont(MetaWatch16);
	WriteLcdString(2, 2, "ALARM !");

	hal_lcd_update_display();
}

void alarm_handle_events(u16t event, void *data)
{
	switch (event) {
		case EVENT_SCREEN_VISIBLE:
			draw_alarm_screen();
			hal_enable_halfsecond_timer();
			hal_vibration_set_state(TRUE);
			break;
		case EVENT_SCREEN_DESTROY:
			hal_disable_halfsecond_timer();
			hal_lcd_set_backlight(FALSE);
			hal_vibration_set_state(FALSE);
			break;
		case EVENT_USER_BUTTONS:
			dbg_out("button event %d\n", *(int *)data);
			// hal_lcd_set_backlight(FALSE);
			break;
		case EVENT_HALF_SEC_TIMER:
			hal_lcd_set_backlight(!hal_lcd_get_backlight());
			hal_vibration_set_state(!hal_vibration_get_state());
			dbg_out("timer\n");
			break;
		default:
			break;
	};
}