/*
 *  Handles the flashcard form.
 */

#include <PalmOS.h>

#include "flipMain.h"
#include "flipFlip.h"
#include "palmUtil.h"
#include "flipEdit.h"
#include "resdefs.h"

static Boolean FlipEventStealer(EventPtr event);
static Boolean FlipEventHandler(EventPtr event);
static void FlipFormInit(void);
static void FlipFormDeinit(void);
static void FlipFormUpdate(void);

struct FormInfo FlipFormInfo = {
	EventStealer: FlipEventStealer,
	EventHandler: FlipEventHandler,
	InitForm: FlipFormInit,
	DeinitForm: FlipFormDeinit,
	UpdateForm: FlipFormUpdate,
};


/* FlipForm globals */

/* Record index for the current word. */
static UInt16 wordIndex = 0;

/* The direction flipped in. */
static Boolean lastDirection = true;

/* The current word unpacked. */
static UnpackedWord currentWord = INVALID_UNPACKED_WORD;

/* Whether the current word has been flipped. */
static Boolean flipped = false;



/*
 * FlipForm stuff
 */

extern void FlipGetFlipState (UInt16 *flipWord, Boolean *flipFlipped)
{
	*flipWord = wordIndex;
	*flipFlipped = flipped;
}

static void FlipFormUpdate(void)
{
	FieldPtr wordField;

	wordField = GetObjectPtr(FlipFormWordField);

	FldSetTextHandle(wordField,
			 flipped ? currentWord.word2 : currentWord.word1);
	FldDrawField(wordField);

	CtlSetValue(GetObjectPtr(FlipFormKnownBox), currentWord.known);
}

static void clearCurrentWord(void)
{
	if (currentWord.valid) {
		FldSetTextHandle(GetObjectPtr(FlipFormWordField), NULL);
		FreeUnpackedWord(&currentWord);
	}
}

/* Loads the current word from the database. */
static void FlipLoadWord(void)
{
	MemHandle recordH;

	clearCurrentWord();

	recordH = DmQueryRecord(wordDB, wordIndex);
	UnpackWord(recordH, &currentWord);
}

extern void FlipWord(UInt16 newWordIndex, Boolean newFlipped)
{
	wordIndex = newWordIndex;
	lastDirection = true;
	flipped = newFlipped;

	FrmGotoForm(FlipForm);
}

/* Step the word index to next unknown, wraps around. */
static void StepWordIndex(Boolean forward)
{
	UInt16 numWords = GetNumWords(wordDB);
	UInt16 newWordIndex = wordIndex;

	do {
		if (forward) {
			newWordIndex++;
			if (newWordIndex >= numWords)
				newWordIndex = 0;
		} else {
			if (newWordIndex == 0)
				newWordIndex = numWords - 1;
			else
				newWordIndex--;
		}
		if (newWordIndex == wordIndex)
			return;	/* TODO - did a full circle, do what? */
	} while (IsKnown(wordDB, newWordIndex));

	wordIndex = newWordIndex;
	FlipLoadWord();
}

static void Flip(Boolean forward)
{
	lastDirection = forward;

	if ((forward && flipped) || (!forward && !flipped))
		StepWordIndex(forward);
	flipped = !flipped;
	FlipFormUpdate();
}

static void MarkCurrentAsKnown(void)
{
	SetKnown(wordDB, wordIndex, 1);
	flipped = !lastDirection; /* if forward, start not flipped, and v.v. */
	StepWordIndex(lastDirection);
	FlipFormUpdate();
}

static void FlipFormInit(void)
{
	UInt16 numWords;

	numWords = GetNumWords(wordDB);

	if (numWords == 0) {
		FrmGotoForm(WordListForm);
		return;
	}

	if (wordIndex >= numWords)
		wordIndex = numWords - 1;
	FlipLoadWord();

	FldSetTextPtr(GetObjectPtr(FlipFormDictField), wordDBInfo.name);
}

static void FlipFormDeinit(void)
{
	clearCurrentWord();
}

/* Intercept hard button events. */
static Boolean FlipEventStealer(EventPtr event)
{
	if ((event->eType == keyDownEvent)) {
		/* 'To Do' button marks current word as known. */
		if (TxtCharIsHardKey
		    (event->data.keyDown.modifiers,
		     event->data.keyDown.chr)
		    && event->data.keyDown.chr == vchrHard3) {
			MarkCurrentAsKnown();
			return true;
			/* Down key flips. */
		} else if (event->data.keyDown.chr == vchrPageDown) {
			Flip(true);
			return true;
			/* Up key backflips. */
		} else if (event->data.keyDown.chr == vchrPageUp) {
			Flip(false);
			return true;
		}
	}

	return false;
}

static Boolean FlipEventHandler(EventPtr event)
{
	FormPtr frm;

	frm = FrmGetActiveForm();

	if (event->eType == ctlSelectEvent) {
		switch (event->data.ctlSelect.controlID) {
		case FlipFormListButton:
			FrmGotoForm(WordListForm);
			return true;
		case FlipFormEditButton:
			EditRecord(wordIndex);
			return true;

		}
	}

	return false;
}