#include "TZ_Vendor_debug_tl.h"
#include "Vendor_Interface.h"
#include "tl_tui_bc_error_msg.h"

#include "TuiButton.h"
#include "TuiTextBox.h"
#include "TuiBackupScreenController.h"
#include "TuiScreenResource.h"
#include "TuiLayout.h"
#include "TuiImageView.h"

#if defined(W1536)
#include "TuiLayout_w1536.h"
#elif defined(DPI640)
#include "TuiLayout_w1440.h"
#elif defined(DPI480)
#include "TuiLayout_w1080.h"
#elif defined(DPI320)
#include "TuiLayout_w720.h"
#else
#include "TuiLayout_w1080.h"
#endif

#define MAX_MNEMONIC_WORD_COUNT			24
#define MAX_MENMONIC_WORD_LENGTH		8
#define MAX_MNEMONIC_ARRAY_SIZE			240
#define QUIZ_WORD_COUNT					3

uint8_t listNum[MAX_MNEMONIC_WORD_COUNT][3 + 1] = { '\0', };
uint8_t mnemonicList[MAX_MNEMONIC_WORD_COUNT][MAX_MENMONIC_WORD_LENGTH + 1] = { '\0', };

Node gBackupScreenControlNode[MAX_CONTROL];
Node gBackupScreenQuizControlNode[MAX_CONTROL];
uint32_t gBackupQuizOrderArray[QUIZ_WORD_COUNT] = { 0, };

ControlGroup gGroupBackupList;
ControlGroup gGroupQuizTextEdit;
ControlGroup gGroupQuizEnterButton;
ControlGroup gGroupQuizTextEditImage;

static uint8_t emptyString[1] = { '\0' };

uint32_t initBackupScreenController() {
	initLayout();
	initTextBuffer();

	return TIMA_SUCCESS;
}

void deleteAllBackupScreenQuizControl() {
	for (uint32_t i = 0; i < MAX_CONTROL; ++i) {
		clearNode(&gBackupScreenQuizControlNode[i]);
	}
}

Node* getBackupScreenControlNode(ScreenState state) {
	if (state == BACKUP_SCREEN_QUIZ_STATE) {
		deleteAllBackupScreenQuizControl();
		return gBackupScreenQuizControlNode;
	} else {
		return gBackupScreenControlNode;
	}
}

uint32_t* getBackupQuizOrderArray() {
	return gBackupQuizOrderArray;
}

void parseMnemonicData(uint8_t* mnemonicData, uint32_t *count) {
	uint32_t index = 0;
	uint32_t i = 0, j = 0;
	do {
		if (mnemonicData[i] == ' ' || mnemonicData[i] == '\0') {
			memcpy(mnemonicList[index++], mnemonicData + j, i - j);
			DBG_LOG("mnemonicList :  %s", mnemonicList[index - 1]);
			if (mnemonicData[i] == '\0') {
				break;
			}
			j = i + 1;
		}
		i++;
	} while (i < 240);

	*count = index;
}

uint32_t drawBackupScreen(uint8_t* mnemonicData) {
	DBG_LOG("mnemonicData : %s", mnemonicData);
	
	uint32_t listSize = 0;
	parseMnemonicData(mnemonicData, &listSize);

	TTY_LOG("listSize : %d", listSize);

	Control control;
	Location loc;
	uint32_t controlId = 1;

	uint32_t listLine = 0;
	uint32_t listColumn = 0;;
	uint32_t listWidth = SCREEN_WIDTH - (BACKUP_MNEMONIC_LIST_SIDE_MARGIN * 2);
	uint32_t textBoxWidth = (listWidth - (BACKUP_MNEMONIC_LIST_TEXTBOX_DISTANCE * (BACKUP_MNEMONIC_LIST_COLUMN_COUNT - 1))) / BACKUP_MNEMONIC_LIST_COLUMN_COUNT;
	uint32_t mnemonicWidth = textBoxWidth - (BACKUP_MNEMONIC_LIST_NUMBER_WIDTH + BACKUP_MNEMONIC_LIST_NUMBER_DISTANCE);
	TextInfo textInfo;
	uint8_t number[4] = { '\0', };
	uint32_t numSize;
	uint32_t textBoxX = 0;

	gGroupBackupList.startId = controlId;
	gGroupBackupList.groupSize = listSize * 2;
	for (uint32_t i = 0; i < listSize; i++) {
		if (i != 0) {
			listLine = i / BACKUP_MNEMONIC_LIST_COLUMN_COUNT;
			listColumn = i % BACKUP_MNEMONIC_LIST_COLUMN_COUNT;
		}
		DBG_LOG("listLine : %d", listLine);
		DBG_LOG("listColumn : %d", listColumn);

		if (listColumn == 0) {
			loc.x1 = BACKUP_MNEMONIC_LIST_SIDE_MARGIN;
		} else {
			loc.x1 = BACKUP_MNEMONIC_LIST_SIDE_MARGIN + ((textBoxWidth + BACKUP_MNEMONIC_LIST_TEXTBOX_DISTANCE) * listColumn);
		}
		loc.y1 = BACKUP_MNEMONIC_LIST_TOP_MARGIN + ((BACKUP_MNEMONIC_LIST_TEXTBOX_HEIGHT + BACKUP_MNEMONIC_LIST_TEXTBOX_LINE_DISTANCE) * listLine);
		if (i + 1 >= 10) {
			number[0] = '0' + (i + 1) / 10;
			number[1] = '0' + (i + 1) % 10;
			number[2] = '.';
			numSize = 3;
		}
		else {
			number[0] = '0' + (i + 1) % 10;
			number[1] = '.';
			numSize = 2;
		}
		memcpy(listNum[i], number, numSize);
		textInfo.text = listNum[i];
		textInfo.font = getScreenFontType(ID_FONT_TYPE_BACKUP_MNEMONIC_LIST);
		initTextBox(&control, controlId++, loc, BACKUP_MNEMONIC_LIST_NUMBER_WIDTH, BACKUP_MNEMONIC_LIST_TEXTBOX_HEIGHT, NULL, 0, NULL, 0, textInfo, RIGHT_CONTENT_ALIGN, VERTICAL_CENTER_CONTENT_ALIGN);
		addTextViewBox(&control, executeTextViewBox);

		DBG_LOG("loc : %d, %d", loc.x1, loc.y1);
		DBG_LOG("mnemonicList : %s", mnemonicList[i]);
		loc.x1 += (BACKUP_MNEMONIC_LIST_NUMBER_WIDTH + BACKUP_MNEMONIC_LIST_NUMBER_DISTANCE);
		textInfo.text = mnemonicList[i];
		textInfo.font = getScreenFontType(ID_FONT_TYPE_BACKUP_MNEMONIC_LIST);
		initTextBox(&control, controlId++, loc, mnemonicWidth, BACKUP_MNEMONIC_LIST_TEXTBOX_HEIGHT, NULL, 0, NULL, 0, textInfo, LEFT_CONTENT_ALIGN, VERTICAL_CENTER_CONTENT_ALIGN);
		addTextViewBox(&control, executeTextViewBox);
	}

	return TIMA_SUCCESS;
}

void setEnableNextButton() {
	Node* node = pickingControlById(ID_CONTROL_BUTTON_BACKUP_OK);
	if (node == NULL || node->control.state == ENABLE_CONTROL_STATE) {
		return;
	}
	node->control.state = ENABLE_CONTROL_STATE;
	drawButton(&node->control);
}

void setDisableNextButton() {
	Node* node = pickingControlById(ID_CONTROL_BUTTON_BACKUP_OK);
	if (node == NULL || node->control.state == DISABLE_CONTROL_STATE) {
		return;
	}
	node->control.state = DISABLE_CONTROL_STATE;
	drawButton(&node->control);
}

void setCheckboxStates(bool bCheckboxOn) {
	Node *nodeCheckboxOff = pickingControlById(ID_CONTROL_IMAGE_CHECKBOX_OFF);
	Node *nodeCheckboxOn = pickingControlById(ID_CONTROL_IMAGE_CHECKBOX_ON);

	if (nodeCheckboxOff == NULL || nodeCheckboxOff->control.state == DISABLE_CONTROL_STATE
		|| nodeCheckboxOn == NULL || nodeCheckboxOn->control.state == DISABLE_CONTROL_STATE) {
		return;
	}

	if (bCheckboxOn) {
        nodeCheckboxOn->control.state = ENABLE_CONTROL_STATE;
		nodeCheckboxOff->control.state = INVISIBLE_CONTROL_STATE;
        drawButton(&nodeCheckboxOn->control);

	} else {
		nodeCheckboxOn->control.state = INVISIBLE_CONTROL_STATE;
		nodeCheckboxOff->control.state = ENABLE_CONTROL_STATE;

        drawButton(&nodeCheckboxOff->control);
	}
}


ResponseControl executeButtonCheckbox(Control *control) {
    ResponseControl rc;
    initResponseControl(&rc);


    switch (control->state) {
        case RELEASED_CONTROL_STATE:
			drawButton(control);
			if(getScreenState() == BACKUP_SCREEN_STATE) {
				setEnableNextButton();
				setCheckboxStates(true);
				changeScreenState(BACKUP_SCREEN_CHECKED_STATE);
			} else if (getScreenState() == BACKUP_SCREEN_CHECKED_STATE) {
				setDisableNextButton();
				setCheckboxStates(false);
				changeScreenState(BACKUP_SCREEN_STATE);
			} else {
				changeState(CANCELLED_TUI_STATE);
			}
			break;
        case PRESSED_CONTROL_STATE:
            drawButton(control);
            break;
        default:
            break;
    }
    return rc;
}

void drawQuizTextInputActivated(uint32_t order) {
	uint32_t resourceSize = 0;
	uint8_t* resource;

	Node* imageNode = pickingControlById(gGroupQuizTextEditImage.startId + order);
	if (imageNode != NULL) {
		imageNode->control.originResource = getScreenResource(ID_RESOURCE_BACKUP_QUIZ_TEXT_INPUT_ACTIVATED, &resourceSize);
		imageNode->control.originResourceSize = resourceSize;
		imageNode->control.state = ENABLE_CONTROL_STATE;
		drawImageView(&imageNode->control);
	}
}

void drawQuizTextInputError(uint32_t order) {
	uint32_t resourceSize = 0;

	Node* imageNode = pickingControlById(gGroupQuizTextEditImage.startId + order);
	if (imageNode != NULL) {
		imageNode->control.originResource = getScreenResource(ID_RESOURCE_BACKUP_QUIZ_TEXT_INPUT_ERROR, &resourceSize);
		imageNode->control.originResourceSize = resourceSize;
		imageNode->control.state = ENABLE_CONTROL_STATE;
		drawImageView(&imageNode->control);
	}
}

void drawQuizTextInputComplete(uint32_t order) {
	uint32_t resourceSize = 0;
	uint32_t textWidth = 0;
	uint32_t textHeight = 0;

	Node* textEditNode = pickingControlById(gGroupQuizTextEdit.startId + order);
	if (textEditNode != NULL) {
		getTextWidthAndHeight(textEditNode->control.textInfo.text, textEditNode->control.textInfo.font, &textWidth, &textHeight);
		clearCursor(textEditNode->control.location.x1 + textWidth, textEditNode->control.location.y1, RESTORE_MNEMONIC_TEXTINPUT_CURSOR_MARGIN);
	}

	Node* imageNode = pickingControlById(gGroupQuizTextEditImage.startId + order);
	if (imageNode != NULL) {
		imageNode->control.originResource = getScreenResource(ID_RESOURCE_BACKUP_QUIZ_TEXT_INPUT_COMPLETE, &resourceSize);
		imageNode->control.originResourceSize = resourceSize;
		imageNode->control.state = ENABLE_CONTROL_STATE;
		drawImageView(&imageNode->control);
	}
}

void drawQuizButtonEnterChecked(Control* button) {
	uint32_t checkedImageSize = 0;
	uint8_t* checkedImageBuffer = getScreenResource(ID_RESOURCE_BACKUP_QUIZ_BUTTON_ENTER_CHECKED, &checkedImageSize);
	button->extraResource = checkedImageBuffer;
	button->extraResourceSize = checkedImageSize;
	button->state = DISABLE_CONTROL_STATE;
	drawButton(button);
}

void updateQuizComplete(Control* button, uint32_t order) {
	DBG_LOG("updateQuizComplete");
	uint32_t id = 0;
	if (order == 0) {
		id = ID_CONTROL_IMAGE_VIEW_BACKUP_QUIZ_SECOND_MESSAGE;
	} else {
		id = ID_CONTROL_IMAGE_VIEW_BACKUP_QUIZ_THIRD_MESSAGE;
	}
	Node* msgNode = pickingControlById(id);
	if (msgNode != NULL) {
		msgNode->control.state = ENABLE_CONTROL_STATE;
		drawImageView(&msgNode->control);
	}
	
	Node* textEditNode = pickingControlById(gGroupQuizTextEdit.startId + order);
	if (textEditNode != NULL) {
		setFocus(&textEditNode->control, false);
		textEditNode->control.state = DISABLE_CONTROL_STATE;
		drawTextBox(&textEditNode->control);
		drawQuizTextInputComplete(order);
	}

	Node* buttonNode = pickingControlById(button->id);
	if (buttonNode != NULL) {
		buttonNode->next->control.state = DISABLE_CONTROL_STATE;
		drawButton(&buttonNode->next->control);
	}

	textEditNode = pickingControlById(gGroupQuizTextEdit.startId + order + 1);
	if (textEditNode != NULL) {
		setFocus(&textEditNode->control, true);
		textEditNode->control.state = ENABLE_CONTROL_STATE;
		drawTextBox(&textEditNode->control);
		drawQuizTextInputActivated(order + 1);
	}

	drawQuizButtonEnterChecked(button);
}

bool isLastGroupQuizTextEdit(uint32_t id) {
	if ((id - gGroupQuizTextEdit.startId) == (QUIZ_WORD_COUNT - 1)) {
		return true;
	}
	return false;
}

void clearErrorMessage(uint32_t order) {
	uint32_t id = 0;
	if (order == 0) {
		id = ID_CONTROL_IMAGE_VIEW_BACKUP_QUIZ_FIRST_WRONG_INPUT;
	} else if (order == 1) {
		id = ID_CONTROL_IMAGE_VIEW_BACKUP_QUIZ_SECOND_WRONG_INPUT;
	} else {
		id = ID_CONTROL_IMAGE_VIEW_BACKUP_QUIZ_THIRD_WRONG_INPUT;
	}

	Node* node = pickingControlById(id);
	if (node == NULL) {
		DBG_LOG("clear error message is NULL");
		return;
	}
	clearImageView(&(node->control));
}

ResponseControl executeTextEditQuizWord(Control *control) {
	DBG_LOG("executeTextEditQuizWord");
	ResponseControl rc;
	initResponseControl(&rc);

	Node* buttonNode;

	uint32_t order = 0;
	uint32_t textLen = 0;
	uint32_t textWidth = 0;
	uint32_t textHeight = 0;

	switch (control->state) {
	case UPDATED_CONTROL_STATE:
		if (control->focused == false) {
			break;
		}
		order = control->id - gGroupQuizTextEdit.startId;
		getTextWidthAndHeight(control->textInfo.text, control->textInfo.font, &textWidth, &textHeight);
		buttonNode = pickingControlById(gGroupQuizEnterButton.startId + order);
		textLen = strlen((char *)control->textInfo.text);
		if (textLen == 0) {
			updateBufferCursor(control->location.x1, control->location.y1);
			buttonNode->control.state = DISABLE_CONTROL_STATE;
			drawButton(&buttonNode->control);
		} else {
			updateBufferCursorWithMargin(control->location.x1 + textWidth, control->location.y1, RESTORE_MNEMONIC_TEXTINPUT_CURSOR_MARGIN);
			buttonNode->control.state = ENABLE_CONTROL_STATE;
			drawButton(&buttonNode->control);
		}
		clearErrorMessage(order);
		drawQuizTextInputActivated(order);
		break;
	default:
		break;
	}

	return rc;
}

uint8_t* getMnemonicFromBackupList(uint32_t index) {
	uint32_t controlId = gGroupBackupList.startId + (index * 2) - 1;
	Node *node;
	for (node = &gBackupScreenControlNode[0]; node != NULL; node = node->next) {
		if (node->control.id == controlId) {
			return node->control.textInfo.text;
		}
	}
	return NULL;
}

ResponseControl executeButtonFirstEnter(Control *control) {
	DBG_LOG("executeButtonFirstEnter");
	ResponseControl rc;
	initResponseControl(&rc);

	Node* textEditNode;
	Node* msgNode;

	uint32_t index = 0;

	switch (control->state) {
	case PRESSED_CONTROL_STATE:
		drawButton(control);
		break;

	case RELEASED_CONTROL_STATE:
		drawButton(control);
		index = gBackupQuizOrderArray[0];
		if (index <= 0 || index > (gGroupBackupList.groupSize / 2)) {
			TTY_LOG("First quiz order is invalid : %d", index);
			changeState(FAILED_TUI_STATE);
			return rc;
		}
		
		textEditNode = pickingFocusedControl(TEXT_EDIT_BOX_CONTROL_TYPE);
		if (textEditNode == NULL) {
			TTY_LOG("Focused text box is NULL");
			changeState(FAILED_TUI_STATE);
			return rc;
		}

		if (strcmp((char *)textEditNode->control.textInfo.text, (char *)getMnemonicFromBackupList(index)) == 0) {
			updateQuizComplete(control, 0);
		} else {
			msgNode = pickingControlById(ID_CONTROL_IMAGE_VIEW_BACKUP_QUIZ_FIRST_WRONG_INPUT);
			if (msgNode == NULL) {
				changeState(REQUEST_TEXT_BACKUP_FIRST_WRONG_INPUT_TUI_STATE);
			} else {
				msgNode->control.state = ENABLE_CONTROL_STATE;
				drawImageView(&msgNode->control);
			}
			drawQuizTextInputError(0);
		}
		break;
	default:
		break;
	}
	return rc;
}

ResponseControl executeButtonSecondEnter(Control *control) {
	DBG_LOG("executeButtonSecondEnter");
	ResponseControl rc;
	initResponseControl(&rc);

	Node* textEditNode;
	Node* msgNode;

	uint32_t index = 0;

	switch (control->state) {
	case PRESSED_CONTROL_STATE:
		drawButton(control);
		break;

	case RELEASED_CONTROL_STATE:
		drawButton(control);
		index = gBackupQuizOrderArray[1];
		if (index <= 0 || index > (gGroupBackupList.groupSize / 2)) {
			TTY_LOG("Second quiz order is invalid : %d", index);
			changeState(FAILED_TUI_STATE);
			return rc;
		}

		textEditNode = pickingFocusedControl(TEXT_EDIT_BOX_CONTROL_TYPE);
		if (textEditNode == NULL) {
			TTY_LOG("Focused text box is NULL");
			changeState(FAILED_TUI_STATE);
			return rc;
		}

		if (strcmp((char *)textEditNode->control.textInfo.text, (char *)getMnemonicFromBackupList(index)) == 0) {
			updateQuizComplete(control, 1);
		} else {
			msgNode = pickingControlById(ID_CONTROL_IMAGE_VIEW_BACKUP_QUIZ_SECOND_WRONG_INPUT);
			if (msgNode == NULL) {
				changeState(REQUEST_TEXT_BACKUP_SECOND_WRONG_INPUT_TUI_STATE);
			} else {
				msgNode->control.state = ENABLE_CONTROL_STATE;
				drawImageView(&msgNode->control);
			}
			drawQuizTextInputError(1);
		}
		break;
	default:
		break;
	}
	return rc;
}

ResponseControl executeButtonThirdEnter(Control *control) {
	DBG_LOG("executeButtonThirdEnter");
	ResponseControl rc;
	initResponseControl(&rc);

	Node* textEditNode;
	Node* buttonNode;
	Node* msgNode;

	uint32_t index = 0;

	switch (control->state) {
	case PRESSED_CONTROL_STATE:
		drawButton(control);
		break;

	case RELEASED_CONTROL_STATE:
		drawButton(control);
		index = gBackupQuizOrderArray[2];
		if (index <= 0 || index > (gGroupBackupList.groupSize / 2)) {
			TTY_LOG("Third quiz order is invalid : %d", index);
			changeState(FAILED_TUI_STATE);
			return rc;
		}
		
		textEditNode = pickingFocusedControl(TEXT_EDIT_BOX_CONTROL_TYPE);
		if (textEditNode == NULL) {
			TTY_LOG("Focused text box is NULL");
			changeState(FAILED_TUI_STATE);
			return rc;
		}

		if (strcmp((char *)textEditNode->control.textInfo.text, (char *)getMnemonicFromBackupList(index)) == 0) {
			changeState(OK_TUI_STATE);
		} else {
			msgNode = pickingControlById(ID_CONTROL_IMAGE_VIEW_BACKUP_QUIZ_THIRD_WRONG_INPUT);
			if (msgNode == NULL) {
				changeState(REQUEST_TEXT_BACKUP_THIRD_WRONG_INPUT_TUI_STATE);
			} else {
				msgNode->control.state = ENABLE_CONTROL_STATE;
				drawImageView(&msgNode->control);
			}
			drawQuizTextInputError(2);
		}
		break;
	default:
		break;
	}
	return rc;
}

uint32_t drawBackupScreenQuiz() {
	DBG_LOG("drawBackupScreenQuiz");
	Control control;
	Location loc;
	uint32_t controlId = 1;
	TextInfo textInfo;

	uint32_t enableImgSize = 0;
	uint32_t pressedImgSize = 0;
	uint32_t defaultImgSize = 0;
	uint8_t* enableImgBuffer;
	uint8_t* pressedImgBuffer;
	uint8_t* defaultImgBuffer;

	Node* node = pickingControlById(ID_CONTROL_IMAGE_VIEW_BACKUP_QUIZ_FIRST_MESSAGE);
	if (node != NULL) {
		node->control.state = ENABLE_CONTROL_STATE;
		drawImageView(&node->control);
	}

	gGroupQuizEnterButton.startId = controlId;
	gGroupQuizEnterButton.groupSize = QUIZ_WORD_COUNT;
	enableImgBuffer = getScreenResource(ID_RESOURCE_BACKUP_QUIZ_BUTTON_ENTER_ENABLE, &enableImgSize);
	pressedImgBuffer = getScreenResource(ID_RESOURCE_BACKUP_QUIZ_BUTTON_ENTER_PRESSED, &pressedImgSize);
	defaultImgBuffer = getScreenResource(ID_RESOURCE_BACKUP_QUIZ_BUTTON_ENTER_DEFAULT, &defaultImgSize);
	for (uint32_t i = 0; i < QUIZ_WORD_COUNT; i++) {
		loc.x1 = BACKUP_QUIZ_TEXTINPUT_LEFT_MARGIN + BACKUP_QUIZ_TEXTINPUT_WIDTH + BACKUP_QUIZ_BUTTON_LEFT_MARGIN;
		loc.y1 = BACKUP_QUIZ_BUTTON_START_TOP_MARGIN + (i * BACKUP_QUIZ_NEXT_DISTANCE);
		initButton(&control, controlId++, loc, BACKUP_QUIZ_BUTTON_WIDTH, BACKUP_QUIZ_BUTTON_HEIGHT,
			pressedImgBuffer, pressedImgSize, enableImgBuffer, enableImgSize, defaultImgBuffer, defaultImgSize, 0);
		if (i == 0) {
			control.state = DISABLE_CONTROL_STATE;
		} else {
			control.isDrawingWhenAdded = 0;
			control.state = INVISIBLE_CONTROL_STATE;
		}

		if (i == 0) {
			addButton(&control, executeButtonFirstEnter);
		} else if (i == 1) {
			addButton(&control, executeButtonSecondEnter);
		} else {
			addButton(&control, executeButtonThirdEnter);
		}
	}

	gGroupQuizTextEditImage.startId = controlId;
	gGroupQuizTextEditImage.groupSize = QUIZ_WORD_COUNT;
	enableImgBuffer = getScreenResource(ID_RESOURCE_BACKUP_QUIZ_TEXT_INPUT_ACTIVATED, &enableImgSize);
	for (uint32_t i = 0; i < QUIZ_WORD_COUNT; i++) {
		loc.x1 = BACKUP_QUIZ_TEXTINPUT_LEFT_MARGIN;
		loc.y1 = BACKUP_QUIZ_TEXTINPUT_START_TOP_MARGIN + BACKUP_QUIZ_TEXTINPUT_HEIGHT + BACKUP_QUIZ_TEXTINPUT_LINE_DISTANCE + (i * BACKUP_QUIZ_NEXT_DISTANCE);
		initImageView(&control, controlId++, loc, 0, 0, NULL, 0, enableImgBuffer, enableImgSize);
		if (i != 0) {
			control.isDrawingWhenAdded = 0;
		}
		addImageView(&control);
	}

	gGroupQuizTextEdit.startId = controlId;
	gGroupQuizTextEdit.groupSize = QUIZ_WORD_COUNT;
	for (uint32_t i = 0; i < QUIZ_WORD_COUNT; i++) {
		loc.x1 = BACKUP_QUIZ_TEXTINPUT_LEFT_MARGIN;
		loc.y1 = BACKUP_QUIZ_TEXTINPUT_START_TOP_MARGIN + (i * BACKUP_QUIZ_NEXT_DISTANCE);
		textInfo.text = emptyString;
		textInfo.font = getScreenFontType(ID_FONT_TYPE_RESTORE_MNEMONIC_INPUT);
		initTextBox(&control, controlId++, loc, BACKUP_QUIZ_TEXTINPUT_WIDTH, BACKUP_QUIZ_TEXTINPUT_HEIGHT, NULL, 0, NULL, 0, textInfo, LEFT_CONTENT_ALIGN, VERTICAL_CENTER_CONTENT_ALIGN);
		if (i == 0) {
			setFocus(&control, TRUE);
		} else {
			control.isDrawingWhenAdded = 0;
		}
		addTextEditBox(&control, executeTextEditQuizWord);
	}

	loc.x1 = BACKUP_QUIZ_KEYPAD_START_X;
	loc.y1 = BACKUP_QUIZ_KEYPAD_START_Y;
	initKeypad(&control, loc);
	addKeypad(&control);

	return TIMA_SUCCESS;
}