/*
 * Copyright (c) 2012-2013 Kaarle Ritvanen
 * See LICENSE file for license details
 */

$(function() {
    $("#login").submit(function() {

	var statusBar = (function() {
	    function set(status, msg, mode) {
		$("#status").prop("class", status);
		$("#status p").text(msg);
		$("#logout").prop("class", mode ? "hidden" : null);
		$("#status div").prop("class", mode == "txn" ? null : "hidden");
		$("#commit").prop("disabled", status == "invalid");
	    }

	    return {
		enableCommit: function() {
		    set("changed", "You have uncommitted changes", "txn");
		},
		setError: function(msg, mode) { set("invalid", msg, mode); },
		reset: function() { set(null, ""); }
	    }
	})();

	$.ajax("/login", {
	    type: "POST",
	    data: JSON.stringify({
		username: $("#username").val(), password: $("#password").val()
	    })
	}).done(function(data, status, xhr) {

	    function split(path) {
		var res = [];
		while (path && path != "/") {
		    var comp = path.match(/^\/([^\\\/]|\\.)+/)[0];
		    res.push(comp.substring(1));
		    path = path.substring(comp.length);
		}
		return res;
	    }

	    function join() {
		var arg = _.toArray(arguments);
		if (arg.length == 1) return arg[0];

		var path = arg.shift();
		var name = arg.shift();

		if (_.isString(name)) {
		    name = name.replace(/([\\\/])/g, "\\$1");
		    if (!isNaN(Number(name))) name = "\\" + name;
		}
		arg.unshift((path == "/" ? "" : path) + "/" + name);

		return join.apply(undefined, arg);
	    }

	    function isRealSubordinate(p1, p2) {
		return !p1.indexOf(p2 + "/");
	    }

	    function isSubordinate(p1, p2) {
		return p1 == p2 || isRealSubordinate(p1, p2);
	    }

	    function isTreeNode(meta) {
		return _.contains(
		    ["collection", "list", "model", "set"], meta.type
		);
	    }

	    
	    var txnMgr = (function(token) {
		var txn, changed, invalid;
		
		function reset() {
		    txn = null;
		    changed = {};
		    invalid = {};
		}
		reset();

		function isValid() { return !(_.size(invalid)); }

		function request(url, options) {
		    options = options || {};
		    options.headers = {"X-ACF-Auth-Token": token};
		    if (txn) options.headers["X-ACF-Transaction-ID"] = txn;
		    return $.ajax(url, options);
		}

		function abort() {
		    var def = request("/transaction", {type: "DELETE"});
		    reset();
		    return def;
		}
		
		function objRequest(path, options) {
		    return request("/config" + path, options);
		}
		
		function query(path) {
		    var def = $.Deferred();

		    objRequest(path).done(function(data) {
			function index(name) {
			    return _.isArray(data.data) ? name - 1 : name;
			}

			data.get = function(name, valid) {
			    var p = join(path, name);
			    return (!valid && p in invalid) ?
				invalid[p][0] : data.data[index(name)];
			};

			data.status = function(name) {
			    var p = join(path, name);
			    function scan(objs) {
				return _.size(_.filter(
				    _.keys(objs), function(obj) {
					return isSubordinate(obj, p);
				    }
				));
			    }

			    if (scan(invalid)) return "invalid";
			    if (scan(changed)) return "changed";
			    return null;
			}

			data.set = function(name, newValue) {
			    var def = $.Deferred();
			    function reject(xhr) { def.reject(xhr); }

			    var mpath = join(path, name);
			    var value = data.get(name);

			    var tn = _.isObject(newValue);
			    var npv = tn ? mpath : newValue;

			    function resolve() {
				if (mpath in invalid &&
				    invalid[mpath][1] == def) {
				    
				    var del = invalid[mpath][0] == null;
				    delete invalid[mpath];
				    
				    if (del)
					_.each(
					    _.keys(invalid),
					    function(p) {
						if (isRealSubordinate(p, mpath))
						    delete invalid[p];
					    }
					);
				}
				
				def.resolve(isValid());
			    }

			    function validate() {
				var options;
				if (newValue != null)
				    options = {
					type: "PUT",
					data: JSON.stringify(newValue)
				    };
				else if (data.get(name, true) != null)
				    options = {type: "DELETE"};

				if (!options) {
				    if (data.meta.type == "model" &&
					_.findWhere(
					    data.meta.fields, {name: name}
					).required)
					def.reject("Required value not set");
				    else resolve();
				    return;
				}
				
 				objRequest(mpath, options).done(function() {
				    if (!(mpath in changed))
					changed[mpath] = value;
				    if (!tn && newValue == changed[mpath])
					delete changed[mpath];
				    else {
					data.data[index(name)] = npv;
					if (npv == null)
					    _.each(
						_.keys(changed),
						function(p) {
						    if (isRealSubordinate(
							p, mpath
						    )) delete changed[p];
						}
					    );
				    }

				    if (tn) query(mpath).done(function(data) {
					if (mpath in invalid &&
					    data.meta.type == "model")
					    _.each(
						data.meta.fields,
						function(field) {
						    var mmpath = join(
							mpath, field.name
						    );
						    if (field.required &&
							!(mmpath in invalid) &&
							data.get(
							    field.name
							) == null)
							invalid[mmpath] = [
							    null
							];
						});
					resolve();
				    }).fail(reject);
				    
				    else resolve();
				    
				}).fail(reject);
			    }

			    var prevTask;
			    if (mpath in invalid) prevTask = invalid[mpath][1];

			    invalid[mpath] = [npv, def];

			    if (prevTask) prevTask.always(validate);
			    else validate();

			    return def;
			};

			data.delete = function(name) {
			    var def = $.Deferred();
			    function resolve(txnValid) { def.resolve(txnValid); }
			    function reject() { def.reject(); }

			    var tasks = _.filter(
				_.pluck(_.values(invalid), 1),
				function(d) { return d.state() == "pending"; }
			    );

			    if (tasks.length)
				tasks[0].always(function() {
				    data.delete(name).done(resolve).fail(reject);
				});

			    else {
				var length = data.data.length;

				data.set(name, null).done(function(txnValid) {
				    if (isTreeNode(data.meta)) {
					delete changed[join(path, name)];
					changed[path] = path;

					if (data.meta.type == "list")
					    for (var i = name; i < length; i++) {
						var opath = join(path, i + 1);
						var npath = join(path, i);
						
						_.each(
						    [changed, invalid],
						    function(map) {
							_.each(
							    _.keys(map),
							    function(p) {
								if (isSubordinate(
								    p, opath
								)) {
								    map[npath +
									p.substring(
									    opath.length
									)] = map[p];
								    delete map[p];
								}
							    });
						    }
						);
					    }
				    }
				    resolve(txnValid);

				}).fail(reject);
			    }

			    return def;
			};

			def.resolve(data);
		    }).fail(function() { def.reject(); });
		    
		    return def;
		}

		return {
		    start: function() {
			var def = $.Deferred();
			if (txn && isValid() && !(_.size(changed))) abort();

			if (txn)
			    def.resolve();

			else request("/transaction", {type: "POST"})
			    .done(function(data, status, xhr) {
				txn = xhr.getResponseHeader(
				    "X-ACF-Transaction-ID"
				);
				def.resolve();
			    })
			    .fail(function() { def.reject(); });

			return def;
		    },

		    commit: function() {
			var def = $.Deferred();
			request(
			    "/transaction", {type: "PUT"}
			).done(function() {
			    reset();
			    def.resolve();
			}).fail(function(xhr) { def.reject(xhr); });
			return def;
		    },

		    abort: abort,

		    query: query,

		    logout: function() {
			return request("/login", {type: "DELETE"});
		    }
		};
	    })(xhr.getResponseHeader("X-ACF-Auth-Token"));
	    


	    function href() {
		return $("<a>").attr({href: "javascript:void(0);"});
	    }

	    var Field = {
		format: function(value, status, label, level) {
		    var el = this.staticRender(value, level);
		    this.setElStatus(el, status);
		    if (label) return this.wrap(el, label).row;
		    return el;
		},

		staticRender: function(value, level) {
		    return $("<div>").text(value);
		},

		setElStatus: function(el, status) {
		    el.prop("class", status);
		},

		wrap: function(el, label, remove) {
		    var row = $("<tr>");
		    row.append($("<td>").text(label));

		    var td = $("<td>");
		    var msg = $("<div>");
		    td.append(msg);
		    td.append(el);
		    row.append(td);

		    if (remove)
			row.append(
			    $("<td>").html(href().click(remove).text("Delete"))
			);

		    return {row: row, msg: msg};
		},

		init: function(value, meta, update, remove, label, level) {
		    this.el = this.render(value, meta, level);
		    this.el.change(update);
		    if (!label) return this.el;
		    this.els = this.wrap(this.el, label, remove);
		    return this.els.row;
		},

		render: function(value, meta, level) {
		    return $("<input>").attr({type: "text", value: value});
		},

		setMessage: function(msg, html) {
		    if (html) this.els.msg.html(msg);
		    else this.els.msg.text(msg);
		},

		setStatus: function(status) {
		    this.setElStatus(this.el, status);
		},

		get: function() { return this.el.val() || null; }
	    }

	    var ComboBox = Object.create(Field);
	    ComboBox.render = function(value, meta, level) {
		var el = $("<select>");

		function opt(value, ui_value, selected) {
		    el.append($("<option>").attr(
			{value: value, selected: selected}
		    ).text(ui_value));
		}

		if (!meta.required)
		    opt("", "(none)", value == null)

		_.each(
		    _.zip(meta.choice, meta["ui-choice"]),
		    function(choice) {
			opt(choice[0], choice[1], value == choice[0]);
		    }
		);

		return el;
	    }

	    var CheckBox = Object.create(Field);
	    CheckBox.staticRender = function(value, level) {
		return $("<div>").text(value ? "Yes" : "No");
	    };
	    CheckBox.setElStatus = function(el, status) {
		Field.setElStatus(el.parent(), status);
	    };
	    CheckBox.render = function(value, meta, level) {
		return $("<input>").attr({type: "checkbox", checked: value});
	    };
	    CheckBox.get = function() { return this.el.is(":checked"); };

	    var Link = Object.create(Field);
	    Link.staticRender = function(value, level) {
		var el = href();
		if (value) {
		    el.click(function() {
			$.bbq.pushState("#" + value);
		    }).text("Show");
		}
		return el;
	    };
	    Link.render = function(value, meta, level) {
		return this.staticRender(value, level);
	    };
	    Link.get = function() { return {}; };

	    Inline = Object.create(Link);
	    Inline.staticRender = function(value, level) {
		var el = $("<div>");
		var obj = $("<div>");
		fetchAndRender(value, obj, level == 6 ? 6 : level + 1);
		el.append(obj);
		return el;
	    };
	    Inline.wrap = function(el, label, remove) {
		if (remove) el.append(href().click(remove).text("Delete"));
		return {row: el};
	    };
	    Inline.setStatus = function(status) {};

	    var Reference = Object.create(Link);
	    Reference.staticRender = function(value, level) {
		return Link.staticRender(value, level).text(value);
	    };
	    Reference.setElStatus = function(el, status) {
		ComboBox.setElStatus(el.find("select"), status);
	    };
	    Reference.render = function(value, meta, level) {
		var link = $("<div>");
		var update = _.bind(function() {
		    link.html(Link.staticRender(this.get(), level));
		}, this);
		
		this.cbox = Object.create(ComboBox);
		
		var el = $("<div>");
		el.append(this.cbox.init(value, meta, update));
		el.append(" ");
		el.append(link);

		update();

		return el;
	    };
	    Reference.get = function() { return this.cbox.get(); };


	    var widgets = {
		boolean: CheckBox,
		combobox: ComboBox,
		field: Field,
		inline: Inline,
		link: Link,
		reference: Reference
	    }


	    function formatError(msg, xhr) {
		msg += " " + xhr.statusCode().status;
		if (xhr.responseText) msg += ': ' + xhr.responseText;
		return msg;
	    }


	    function renderObject(path, data, target, level) {
		target = target || $("#content");
		level = level || 1;

		target.html($("<h" + level + ">").text(data.meta["ui-name"]));

		if (!isTreeNode(data.meta))
		    return target.append(JSON.stringify(data));
		
		function validated(txnValid) {
		    if (txnValid) statusBar.enableCommit();
		    else statusBar.setError("Some values need checking", "txn");
		}

		var div = $("<div>");
		target.append(div);
		
		var table;
		function appendRow(row) {
		    if (!table) {
			table = $("<table>");
			div.append(table);
		    }
		    table.append(row);
		}
		
		function renderField(
		    name, value, meta, label, editable, removable
		) {

		    var status = data.status(name);
		    
		    if (!(meta.widget in widgets))
			return $("<tr>").html($("<td>").text(value));

		    var widget = widgets[meta.widget];
		    if (!editable)
			return widget.format(value, status, label, level);

		    widget = Object.create(widget);
		    
		    function change() {
			if (isTreeNode(meta)) return;

			widget.setMessage("[checking]");
			statusBar.setError("Validating changes", "validate");
			
			data.set(name, widget.get()).done(function(txnValid) {
			    widget.setMessage("");
			    widget.setStatus(data.status(name));
			    validated(txnValid);
			    
			}).fail(function(xhr) {
			    if (_.isString(xhr)) widget.setMessage(xhr);
			    
			    else if (xhr.statusCode().status == 422)
				widget.setMessage(
				    _.reduce(
					_.map(
					    $.parseJSON(xhr.responseText),
					    _.escape
					),
					function(a, b) {
					    return a + "<br/>" + b;
					}
				    ),
				    true
				);
			    
			    else widget.setMessage(formatError("Error", xhr));
			    
			    widget.setStatus("invalid");
			    validated(false);
			});
		    }

		    var el = widget.init(
			value,
			meta,
			change,
			removable ? function() {
			    data.delete(name).done(function(txnValid) {
				validated(txnValid)
				fetchAndRender(path);
			    });
			} : null,
			label,
			level
		    );

		    if (status == "invalid") change();
		    
		    widget.setStatus(status);

		    if (el.is("tr")) appendRow(el);
		    else {
			table = null;
			div.append(el);
		    }
		}
		
		function renderCollectionMember(name, value, meta) {
		    var set = meta.type == "set";
		    renderField(
			name,
			value,
			meta.members,
			meta["ui-member"] + " " + name,
			!set,
			!set
		    );
		}
		
		if (data.meta.type == "model")
		    _.each(data.meta.fields, function(field) {
			renderField(
			    field.name,
			    data.get(field.name),
			    field,
			    field["ui-name"],
			    true,
			    false
			);
		    });
		
		else _.each(data.data, function(value, name) {
		    if (_.isArray(data.data)) name++;
		    renderCollectionMember(name, data.get(name), data.meta);
		});
		
		if (_.contains(["collection", "list"], data.meta.type)) {
		    var keys = _.clone(_.keys(data.data));
		    
		    var button = $("<input>").attr(
			{type: "submit", value: "Insert"}
		    ).click(function() {
			
			var getter;
			
			function insert() {
			    var name = getter();
			    
			    if (_.contains(keys, name)) {
				button.prop("class", null);
				return;
			    }
			    keys.push(name);
			    
			    var tn = isTreeNode(data.meta.members);
			    data.set(
				name, tn ? {} : null
			    ).done(function(txnValid) {
				renderCollectionMember(
				    name,
				    tn ? join(path, name) : null,
				    data.meta
				);
				button.prop("class", null);
				validated(txnValid);
			    });
			}
			
			button.prop("class", "hidden");

			if (data.meta.type == "collection") {
			    var field = $("<input>").attr({type: "text"});
			    var row = $("<tr>").html($("<td>").html(field));
			    getter = function() {
				var res = field.val();
				row.remove();
				return res;
			    }
			    field.change(insert);
			    appendRow(row);
			}
			else {
			    getter = function() {
				return data.data.length + 1;
			    };
			    insert();
			}
		    });
		    target.append($("<p>").html(button));
		}
	    }	    

	    function fetchAndRender(path, target, level) {
		var def = $.Deferred();
		txnMgr.query(path).done(function(data) {
		    renderObject(path, data, target, level);
		    def.resolve();
		}).fail(function() { def.reject(); });
		return def;
	    }


	    function redirect(path) { $.bbq.pushState("#" + path); }

	    function render() {
		var path = $.param.fragment();

		function renderMenu(target, path, current, selectFirst) {
		    var def = $.Deferred();

		    txnMgr.query(path).done(function(data) {
			if (data.meta.type != "model" || _.filter(
			    data.meta.fields, function(field) {
				return !isTreeNode(field);
			    }
			).length) {
			    def.reject(data);
			    return;
			}

			var first = data.meta.fields[0].name;
			if (!current && selectFirst) current = first;

			_.each(data.meta.fields, function(field) {
			    var el = $("<li>");
			    var link = Link.format(data.get(field.name));
			    link.text(field["ui-name"]);
			    el.prop("class", data.status(field.name));
			    if (field.name == current)
				el.addClass("current");
			    el.append(link);
			    target.append(el);
			});

			def.resolve(first);
		    });

		    return def;
		}


		txnMgr.start().done(function() {
		    var comps = split(path);
		    renderMenu($("#modules").empty(), "/", comps[0], false);
		    var tabs = $("#tabs").empty();

		    if (path == "/") return;
		    var topLevel = comps.length == 1;

		    renderMenu(tabs, "/" + comps[0], comps[1], true)
			.done(function(first) {
			    fetchAndRender(
				topLevel ? join(path, first) : path
			    ).fail(function() {
				comps.pop();
				comps.unshift("/");
				redirect(join.apply(undefined, comps));
			    });
			})
			.fail(function(data) {
			    if (topLevel) renderObject(path, data);
			    else fetchAndRender(path);
			});
		});
	    }

	    
	    function clearState() {
		statusBar.reset();
		render();
	    }
	    
	    $("#commit").click(function() {
		txnMgr.commit().done(clearState).fail(function(xhr) {
		    statusBar.setError(
			formatError("Commit failed", xhr), "txn"
		    );
		})
	    });
	    $("#revert").click(function() {
		txnMgr.abort().always(clearState);
	    });
	    
	    $("#logout").click(function() {
		txnMgr.logout().done(function() {
		    $("body").html($("<p>").text("Logged out"));
		});
	    });
	    
	    statusBar.reset();
	    $("#content").empty();

	    $(window).bind("hashchange", render);
	    redirect("/");

	}).fail(function() {
	    statusBar.setError("Login failed", "login");
	});

	return false;
    });
});