module arsd.bbcode;

import std..string;
import std.array : replace;
import arsd.dom; // BBCode is really tied to HTML, so we depend on it

string bbCodeToText(string bbcode) {
	bbcode = bbcode.replace("\r\n", "\n");

	BbCodeComponent bbc = parseBbCode(bbcode);

	return bbc.toPlainText();
}

string htmlToBbCode(Element htmlRoot) {
	string ret;

	//if(htmlRoot.childNodes.length == 0)
		if(htmlRoot.nodeType == NodeType.Text)
			return htmlRoot.nodeValue().replace("\n", " ");

	auto child = htmlRoot;

	switch(child.tagName) {
		case "b":
		case "i":
		case "s":
		case "u":
			ret ~= "[" ~ child.tagName ~ "]";
			ret ~= child.innerText;
			ret ~= "[/" ~ child.tagName ~ "]";
		break;
		case "p":
			// whitespace is all the same for html......

			string para = "\n\n";
			foreach(c; child.childNodes) {
				para ~= htmlToBbCode(c);
			}
			para ~= "\n\n";

			para = para.squeeze(" "); // in HTML, whitespace is collapsed

			ret ~= para;

			//ret ~= "\n\n" ~ strip(child.innerText().replace("\r\n", "\n").replace("\n", " ")) ~ "\n\n";
		break;
		case "br":
			ret ~= "\n";
		break;
		case "blockquote":
			string attribute;
			string value;
			foreach(c; child.childNodes) {
				if(c.tagName == "cite")
					attribute = c.innerText().replace(" wrote:", "");
					attribute = attribute.strip;
					if(attribute.length && attribute[$-1] == ':')
						attribute = attribute[0..$-1];
				else {
					value ~= htmlToBbCode(c);
				}
			}

			attribute = attribute.strip;

			if(attribute.length) {
				ret ~= "[quote=\""~attribute~"\"]"~value~"[/quote]";
			} else {
				ret ~= "[quote]"~value~"[/quote]";
			}
		break;
		case "pre":
			if(indexOf(child.getAttribute("class"), "d_code") != -1) {
				ret ~= "[code]" ~ child.innerText ~ "[/code]";
				break;
			}
		/* fallthrough */
		default:
			foreach(c; htmlRoot.childNodes) {
				ret ~= htmlToBbCode(c);
			}
	}

	// collapses the paragraphs splits...
	return ret.replace("\n\n\n\n", "\n\n");
}

BbCodeComponent parseBbCode(string bbcode, BbCodeComponent delegate(string, string, ref string) spawner = null, int* consumed = null) {
	if(spawner is null) {
		BbCodeComponent delegateWrapper(string a, string b, ref string c) {
			return bbCodeDefaultSpawner(a, b, c);
		}
		spawner = &delegateWrapper;
	}

	BbCodeComponent root = new BbCodeComponent;

	int idx;

	int loops;

	int originalLength = bbcode.length;

	while(bbcode.length) {
		loops++;
		if(loops > 15)
			assert(0, bbcode);
		idx = bbcode.indexOf("[");
		if(idx == -1) {
		    done:
			root.appendChild(new BbCodePlainText(bbcode));
			if(consumed !is null)
				*consumed = originalLength = bbcode.length;
			return root; // we're done, no more tags
		} else {
			root.appendChild(new BbCodePlainText(bbcode[0 .. idx]));
			bbcode = bbcode[idx .. $];

			idx = bbcode.indexOf("]");
			if(idx == -1) // never closes; not bbcode anymore
				goto done;

			auto equal = bbcode.indexOf("=");

			string tagName;
			string attributeValue;

			// it has an attribute
			if(equal != -1 && equal < idx) {
				tagName = bbcode[1 .. equal]; // skip the [
				attributeValue = bbcode[equal + 1 .. idx];

				if(attributeValue[0] == '"' && attributeValue[$-1] == '"') // quoted value...
					attributeValue = attributeValue[1 .. $-1]; // ... gets chopped off
			} else {
				tagName = bbcode[1 .. idx];
			}

			string storedData = bbcode[0 .. idx + 1]; // skip the closing ]
			bbcode = bbcode[idx + 1 .. $];

			auto com = spawner(tagName, attributeValue, bbcode);

			if(com is null) {
				root.appendChild(new BbCodePlainText(storedData)); // assume plain text
				continue;
			} else {
				root.appendChild(com);
			}
		}
	}

	if(consumed !is null)
		*consumed = originalLength;

	return root;
}


/// return null if you don't know what to do. You should consume data as you go, or leave it as it is if you fail
BbCodeComponent bbCodeDefaultSpawner(string tag, string attribute, ref string data) {
	switch(tag) {
		// inline elements
		case "b":
		case "i":
		case "u":
		case "s":
			if(attribute.length)
				return null;

			auto idx = data.indexOf("[/"~tag~"]");
			if(idx == -1) // they can't nest
				return null;

			// nor do they have children aside from text

			BbCodeTagWithChildren e;
			switch(tag) {
				case "b": e = new BbCodeBold; break;
				case "i": e = new BbCodeItalic; break;
				default: e = new BbCodeTagWithChildren;
			}

			assert(e !is null);

			e.tagName = tag;
			e.appendChild(new BbCodePlainText(data[0 .. idx]));
			data = data[idx + ("[/"~tag~"]").length .. $];

			return e;
		break;
		case "hr":
			auto e = new BbCodeHr;
			e.tagName = "hr";

			return e;
		break;

		// nestable blocks
		case "section":
		case "quote":
			auto idx = findNestedCloser(data, tag);
			if(idx == -1)
				return null;

			auto parsed = parseBbCode(data[0.. idx], null);

			data = data[idx + ("[/"~tag~"]").length .. $];

			BbCodeComponent e;
			
			switch(tag) {
				default: assert(0);
				case "quote": e = new BbCodeQuote; break;
				case "section": e = new BbCodeSection; break;
			}

			e.tagName = tag;
			e.attributeValue = attribute;

			foreach(p; parsed.children)
				e.appendChild(p);

			return e;
		break;

		// non-parsed blocks
		case "code":
			auto idx = data.indexOf("[/" ~ tag ~ "]");
			if(idx == -1)
				return null;

			auto e = new BbCodeCode;
			e.tagName = tag;
			e.value = data[0 .. idx];

			data = data[idx + ("[/" ~ tag ~ "]").length .. $];

			return e;
		break;
		default:
			return null;
	}

	return null;
}

int findNestedCloser(string data, string tag) {
	int itemsOpen = 1;

	int idxOpener, idxCloser;

	int startingFrom = 0;

   more:
   	assert(startingFrom >= 0);
	idxOpener = data[startingFrom .. $].indexOf("[" ~ tag);
	idxCloser = data[startingFrom .. $].indexOf("[/" ~ tag ~ "]");

	if(idxCloser == -1)
		return -1; //  no closer means we're done

	if(idxOpener == -1)
		idxOpener = int.max; // didn't find an opener... pretend it is infinitely long

	if(idxCloser < idxOpener) {
		// encountered a closing tag
		itemsOpen --;
		if(itemsOpen == 0)
			return idxCloser + startingFrom; // it's our closer!
		if(itemsOpen < 0)
			assert(0, "too many closers");
//			return -1; // wtf too many closers?

		// there was something else... let's skip past it
		startingFrom = idxCloser + startingFrom + 1;
	} else {
		// encountered an opening tag
		itemsOpen++;
		startingFrom = idxOpener + startingFrom + 1;
	}

	goto more;
}
import std.stdio;

class BbCodeSection : BbCodeTagWithChildren {
	override bool isBlock() { return true; }

	override string toPlainText() {
		string ret;
		if(attributeValue.length) {
			ret = attributeValue;
			switch(nestingLevel) {
				case 0:
				ret ~= "\n==================================\n";
				break;
				case 1:
				ret ~= "\n----------------------------------\n";
				break;
				default:
					ret = ret.toUpper ~ "\n";
			}
		}

		ret ~= super.toPlainText();

		return ret;
	}
}

class BbCodeCode : BbCodeComponent {
	string value;

	override bool isBlock() { return true; }
	override string toPlainText() {
		string ret;

		ret ~= "/* **************** */\n";
		ret ~= value;
		ret ~= "\n/* **************** */";

		return ret;
	}
}

class BbCodeQuote : BbCodeTagWithChildren {
	override bool isBlock() { return true; }
	override string toPlainText() {
		string c = ">";
		foreach(i; 0 .. nestingLevel())
			c ~= ">";

		c ~= " ";

		string ret;

		if(attributeValue.length)
			ret = attributeValue ~ " wrote:\n";

		ret ~= replace(
			c ~ super.toPlainText().strip,
			"\n", "\n" ~ c);

		ret = ret.replace("> >", ">");

		return ret;
	}
}

class BbCodeBold : BbCodeTagWithChildren {
	override string toPlainText() {
		return "*" ~ super.toPlainText() ~ "*";
	}
}
class BbCodeItalic : BbCodeTagWithChildren {
	override string toPlainText() {
		return "/" ~ super.toPlainText() ~ "/";
	}
}

class BbCodeHr : BbCodeNonClosedTag {
	override string toPlainText() {
		return
`                   ----------------------------------                `;
	}

	override bool isBlock() { return true; }
}

/// This is the base of a parsed BBCode group.
/// Various types of bbcode tags should be subclasses of it
class BbCodeComponent {
	this() {

	}
	int nestingLevel() {
		int nesting = 0;

		BbCodeComponent e = parent;
		while(e) {
			if(e.tagName == tagName)
				nesting++;
			e = e.parent;
		}
		return nesting;
	}


	bool setBlock;

	bool isBlock() { return setBlock; }

	invariant() {
		foreach(child; children) {
			assert(child !is null);
		}
	}

	BbCodeComponent appendChild(BbCodeComponent c) {
		children ~= c;
		c.parent = this;
		return c;
	}

	BbCodeComponent[] children;
	BbCodeComponent parent;
	string tagName;
	string attributeValue;

	/// outputs its own source code
	override string toString() {
		string ret;

		foreach(child; children) {
			ret ~= child.toString();
		}

		return ret;
	}

	/// Outputs email style text
	string toPlainText() {
		string ret;

		bool lastWasBlock  = false;

		foreach(child; children) {
			string n = child.toPlainText();

			if(child.isBlock() || lastWasBlock) {
				n = n.strip;
				ret = ret.strip;

				ret ~= "\n\n";

				// blocks must be preceeded
				// and followed by lines
				//if(ret[$-1] != '\n' && n[0] != '\n')
					//ret ~= "\n";

				lastWasBlock = child.isBlock();
			}

			ret ~= n;
		}

		return ret;
	}

	/// converts itself to an HTML element
	Element toHtml(Document document) {
		Element container = document.createElement("div");

		foreach(child; children) {
			container.appendChild(child.toHtml(document));
		}

		return container;
	}
}

/// Just plain text inside the bbcode. If something doesn't parse as anything
/// else, it should fall back on this.
class BbCodePlainText : BbCodeComponent {
	string value;

	this(string txt) {
		value = txt;
	}

	invariant () {
		assert(this.children.length == 0);
		assert(this.tagName == "");
	}

	override string toString() {
		return value;
	}

	override string toPlainText() {
		string ret;

		foreach(paragraph; value.split("\n")) {
			if(paragraph.length == 0)
				ret ~= "\n";
			else
				ret ~= paragraph.wrap(74);

			// just a sanity check
			if(ret[$-1] != '\n')
				ret ~= '\n';
		}

		return ret;
	}

	override Element toHtml(Document document) {
		return document.createTextNode(value);
	}
}

/// A "tag" that doesn't close. For example, "[hr]".
class BbCodeNonClosedTag : BbCodeComponent {
	invariant() {
		assert(this.children.length == 0);
	}

	override string toString() {
		return format("[%s%s]", tagName, attributeValue.length ?
			("=\"" ~ attributeValue ~ "\"")
			: "");
	}

	/// Override me!
	override string toPlainText() {
		return "";
	}

	/// Override me if the attribute is meaningful or the tag names don't match!
	override Element toHtml(Document document) {
		return document.createElement(tagName);
	}
}

/// A tag that requires a closing tag and may have children, such as [p]child[/p]
class BbCodeTagWithChildren : BbCodeComponent {
	override string toString() {
		string ret = format("[%s%s]", tagName, attributeValue.length ?
			("=\"" ~ attributeValue ~ "\"")
			: "");

		foreach(child; children)
			ret ~= child.toString();

		ret ~= "[/" ~ tagName ~ "]";

		return ret;
	}

	override Element toHtml(Document document) {
		auto e = document.createElement(tagName);
		foreach(child; children)
			e.appendChild(child.toHtml(document));
		return e;
	}
}