#include "zkbxml.h"
#include "zkbnames.h"

static QString Keymap_Tag("keymap");
static QString Include_Tag("include");
static QString Label_Tag("label");
static QString State_Tag("state");
static QString Map_Tag("map");
static QString Event_Tag("event");
static QString NextState_Tag("next-state");

ZkbXmlHandler::ZkbXmlHandler() {
}

ZkbXmlHandler::~ZkbXmlHandler() {
}

bool ZkbXmlHandler::startElement(const QString&, const QString&, 
	const QString& name, const QXmlAttributes& attr) {

	bool ret = false;

	if (name == Keymap_Tag) {
		ret = start_keymap(attr);
	} else if (name == Include_Tag) {
		ret = start_include(attr);
	} else if (name == Label_Tag) {
		ret = start_label(attr);
	} else if (name == State_Tag) {
		ret = start_state(attr);
	} else if (name == Map_Tag) {
		ret = start_map(attr);
	} else if (name == Event_Tag) {
		ret = start_event(attr);
	} else if (name == NextState_Tag) {
		ret = start_next_state(attr);
	}

	elements.prepend(name);

	return ret;
}

bool ZkbXmlHandler::endElement(const QString&, const QString&, 
	const QString& name) {

	bool ret = false;

	elements.remove(elements.begin());

	if (name == Keymap_Tag) {
		ret = end_keymap();
	} else if (name == Include_Tag) {
		ret = end_include();
	} else if (name == Label_Tag) {
		ret = end_label();
	} else if (name == State_Tag) {
		ret = end_state();
	} else if (name == Map_Tag) {
		ret = end_map();
	} else if (name == Event_Tag) {
		ret = end_event();
	} else if (name == NextState_Tag) {
		ret = end_next_state();
	}

	return ret;
}

QString ZkbXmlHandler::errorString() {
	return err;
}

bool ZkbXmlHandler::startKeymapElement(int ardelay, int arperiod, const QString& author) {
	return false;
}

bool ZkbXmlHandler::startIncludeElement(const QString& file, 
	const QString& prefix) {

	return false;
}

bool ZkbXmlHandler::startLabelElement(const QString& label, 
	const QString& state) {

	return false;
}

bool ZkbXmlHandler::startStateElement(const QString& name, 
	const QString& parent, bool dflt) {

	return false;
}

bool ZkbXmlHandler::startMapElement(int keycode, bool pressed) {
	return false;
}

bool ZkbXmlHandler::startEventElement(int keycode, int unicode, int modifiers, 
	bool pressed, bool autorepeat) {

	return false;
}

bool ZkbXmlHandler::startNextStateElement(const QString& state) {
	return false;
}


bool ZkbXmlHandler::endKeymapElement() {
	return false;
}

bool ZkbXmlHandler::endIncludeElement() {
	return false;
}

bool ZkbXmlHandler::endLabelElement() {
	return false;
}

bool ZkbXmlHandler::endStateElement() {
	return false;
}

bool ZkbXmlHandler::endMapElement() {
	return false;
}

bool ZkbXmlHandler::endEventElement() {
	return false;
}

bool ZkbXmlHandler::endNextStateElement() {
	return false;
}


bool ZkbXmlHandler::start_keymap(const QXmlAttributes& attr) {
	int nattr = 0;
	int didx = attr.index("autorepeat-delay");
	int pidx = attr.index("autorepeat-period");
	int aidx = attr.index("author");
	int ard = -1;
	int arp = -1;
	QString author;

	if (!elements.isEmpty()) {
		setError("keymap element should be top-level element");
		return false;
	}

	if (didx >= 0) {
		QString s = attr.value(didx);
		bool ok;

		ard = s.toInt(&ok);
		if (!ok) {
			setError("Invalid autorepeat-delay value: " + s);
			return false;
		}

		nattr++;
	}

	if (pidx >= 0) {
		QString s = attr.value(pidx);
		bool ok;

		arp = s.toInt(&ok);
		if (!ok) {
			setError("Invalid autorepeat-period value: " + s);
			return false;
		}

		nattr++;
	}

	if (aidx >= 0) {
		author = attr.value(aidx);
		nattr++;
	}

	if (attr.length() > nattr) {
		setError("Unsupported attributes");
		return false;
	}

	return startKeymapElement(ard, arp, author);
}

bool ZkbXmlHandler::start_include(const QXmlAttributes& attr) {
	int nattr = 0;
	int fidx = attr.index("file");
	int pidx = attr.index("prefix");
	QString file;
	QString prefix((const char*) 0);

	if (elements.first() != Keymap_Tag) {
		setError("include element should be used only "
			"within keymap element");
		return false;
	}

	if (fidx >= 0) {
		file = attr.value(fidx);
		nattr++;
	} else {
		setError("Missing file attribute");
		return false;
	}

	if (pidx >= 0) {
		prefix = attr.value(pidx);
		nattr++;
	}

	if (attr.length() > nattr) {
		setError("Unsupported attributes");
		return false;
	}

	return startIncludeElement(file, prefix);
}

bool ZkbXmlHandler::start_label(const QXmlAttributes& attr) {
	int nattr = 0;
	int nidx = attr.index("name");
	int sidx = attr.index("state");
	QString name;
	QString state;

	if (elements.first() != Keymap_Tag) {
		setError("label element should be used only "
			"within keymap element");
		return false;
	}

	if (nidx >= 0) {
		name = attr.value(nidx);
		nattr++;
	} else {
		setError("Missing name attribute");
		return false;
	}

	if (sidx >= 0) {
		state = attr.value(sidx);
		nattr++;
	} else {
		setError("Missing name attribute");
		return false;
	}

	if (attr.length() > nattr) {
		setError("Unsupported attributes");
		return false;
	}

	return startLabelElement(name, state);
}

bool ZkbXmlHandler::start_state(const QXmlAttributes& attr) {
	int nattr = 0;
	int nidx = attr.index("name");
	int pidx = attr.index("parent");
	int didx = attr.index("default");
	QString name;
	QString parent((const char*) 0);
	bool dflt = false;

	if (elements.first() != Keymap_Tag) {
		setError("state element should be used only "
			"within keymap element");
		return false;
	}

	if (nidx >= 0) {
		name = attr.value(nidx);
		nattr++;
	} else {
		setError("Missing name attribute");
		return false;
	}

	if (pidx >= 0) {
		parent = attr.value(pidx);
		nattr++;
	}

	if (didx >= 0) {
		dflt = str2bool(attr.value(didx));
		if (!err.isEmpty()) {
			return false;
		}

		nattr++;
	}

	if (attr.length() > nattr) {
		setError("Unsupported attributes");
		return false;
	}

	return startStateElement(name, parent, dflt);
}

bool ZkbXmlHandler::start_map(const QXmlAttributes& attr) {
	int nattr = 0;
	int kidx = attr.index("keycode");
	int pidx = attr.index("pressed");
	int key;
	bool pressed;

	if (elements.first() != State_Tag) {
		setError("map element should be used only "
			"within state element");
		return false;
	}

	if (kidx >= 0) {
		key = str2key(attr.value(kidx));
		if (!err.isEmpty()) {
			return false;
		}
		nattr++;
	} else {
		setError("Missing keycode attribute");
		return false;
	}

	if (pidx >= 0) {
		pressed = str2bool(attr.value(pidx));
		if (!err.isEmpty()) {
			return false;
		}
		nattr++;
	} else {
		setError("Missing pressed attribute");
		return false;
	}

	if (attr.length() > nattr) {
		setError("Unsupported attributes");
		return false;
	}

	return startMapElement(key, pressed);
}

bool ZkbXmlHandler::start_event(const QXmlAttributes& attr) {
	int nattr = 0;
	int kidx = attr.index("keycode");
	int pidx = attr.index("pressed");
	int uidx = attr.index("unicode");
	int midx = attr.index("modifiers");
	int aidx = attr.index("autorepeat");

	int keycode;
	int unicode;
	int modifiers = 0;
	bool pressed;
	bool autorepeat = false;

	if (elements.first() != Map_Tag) {
		setError("event element should be used only "
			"within map element");
		return false;
	}

	if (kidx >= 0) {
		keycode = str2keycode(attr.value(kidx));
		if (!err.isEmpty()) {
			return false;
		}
		nattr++;
	} else {
		setError("Missing keycode attribute");
		return false;
	}

	if (uidx >= 0) {
		unicode = str2unicode(attr.value(uidx));
		if (!err.isEmpty()) {
			return false;
		}
		nattr++;
	} else {
		setError("Missing unicode attribute");
		return false;
	}

	if (midx >= 0) {
		modifiers = str2modifier(attr.value(midx));
		if (!err.isEmpty()) {
			return false;
		}
		nattr++;
	}

	if (pidx >= 0) {
		pressed = str2bool(attr.value(pidx));
		if (!err.isEmpty()) {
			return false;
		}
		nattr++;
	} else {
		setError("Missing pressed attribute");
		return false;
	}

	if (aidx >= 0) {
		autorepeat = str2bool(attr.value(aidx));
		if (!err.isEmpty()) {
			return false;
		}
		nattr++;
	}

	if (attr.length() > nattr) {
		setError("Unsupported attributes");
		return false;
	}

	return startEventElement(keycode, unicode, modifiers, pressed, 
		autorepeat);
}

bool ZkbXmlHandler::start_next_state(const QXmlAttributes& attr) {
	int nattr = 0;
	int nidx = attr.index("name");
	QString name;

	if (elements.first() != Map_Tag) {
		setError("next-state element should be used only "
			"within map element");
		return false;
	}

	if (nidx >= 0) {
		name = attr.value(nidx);
		nattr++;
	} else {
		setError("Missing name attribute");
		return false;
	}

	if (attr.length() > nattr) {
		setError("Unsupported attributes");
		return false;
	}

	return startNextStateElement(name);
}

bool ZkbXmlHandler::end_keymap() {
	return endKeymapElement();
}

bool ZkbXmlHandler::end_include() {
	return endIncludeElement();
}

bool ZkbXmlHandler::end_label() {
	return endLabelElement();
}

bool ZkbXmlHandler::end_state() {
	return endStateElement();
}

bool ZkbXmlHandler::end_map() {
	return endMapElement();
}

bool ZkbXmlHandler::end_event() {
	return endEventElement();
}

bool ZkbXmlHandler::end_next_state() {
	return endNextStateElement();
}

void ZkbXmlHandler::setError(const QString& e) {
	err = e;
}

int ZkbXmlHandler::str2key(const QString& s) {
	int ret;

	ret = KeyNames::find(s);
	if (ret == -1) {
		setError("Invalid value: " + s);
	}

	return ret;
}

int ZkbXmlHandler::str2modifier(const QString& val) {
	int ret;

	int n, i;
	ret = 0;
	n = 0;
	do {
		i = val.find('|', n);
		if (i < 0) {
			i = val.length();
		}

		QString s = val.mid(n, i - n);
		int v = ModifierNames::find(s.stripWhiteSpace());

		if (v == -1) {
			setError("Invalid value: " + val);
			return -1;
		}

		ret |= v;
		n = i + 1;
	} while (n < val.length());

	return ret;
}

bool ZkbXmlHandler::str2bool(const QString& s) {
	if (s == "true") {
		return true;
	} else {
		return false;
	}
}

int ZkbXmlHandler::str2unicode(const QString& s) {
	return str2uint(s);
}

int ZkbXmlHandler::str2keycode(const QString& s) {
	int ret;

	ret = KeycodeNames::find(s);
	if (ret == -1) {
		setError("Invalid value: " + s);
	}

	return ret;
}

int ZkbXmlHandler::str2uint(const QString& s) {
	int ret;
	bool ok;
	QString val = s;
	int r;

	if (val.left(2) == "0x") {
		val = s.mid(2);
		r = 16;
	} else if (val.left(1) == "0") {
		val = s.mid(1);
		r = 8;
	} else {
		r = 10;
	}

	ret = val.toInt(&ok, r);
	if (!ok) {
		setError("Invalid value: " + s);
		ret = -1;
	}

	return ret;
}