###############################
## Lexipython Lexicon engine ##
###############################

import sys		# For argv and stderr
import os		# For reading directories
import re		# For parsing lex content
import networkx # For pagerank analytics
from collections import defaultdict # For rank inversion in statistics

# Utility functions for handling titles and filenames

def titlecase(s):
	s = s.strip()
	return s[:1].capitalize() + s[1:]

def as_filename(s):
	"""Makes a string filename-safe."""
	# Strip out <, >, :, ", ', /, \, |, ?, and *
	s = re.sub(r"[<>:\"'/\\|?*]", '', s)
	# Strip out Unicode for -
	s = re.sub(r"[^\x00-\x7F]+", '-', s)
	# Strip out whitespace for _
	s = re.sub(r"\s+", '_', s)
	return s

def titlestrip(s):
	"""Strips certain prefixes for title sorting."""
	if s.startswith("The "): return s[4:]
	if s.startswith("An "): return s[3:]
	if s.startswith("A "): return s[2:]
	return s

def cmp_title(x, y):
	"""Compares strings in titular order, ignoring prefixed articles."""
	return cmp(titlestrip(x), titlestrip(y))

def link_formatter(written_articles):
	"""
	Creates a lambda that formats citation links and handles the phantom class.
	Input:  written_articles, a list of article titles to format as live links
	Output: a lambda (fid, alias, title) -> link_string
	"""
	return lambda fid, alias, title: "<a href=\"{1}.html\"{2}>{0}</a>".format(
			alias, as_filename(title),
			"" if title in written_articles else " class=\"phantom\""
		)

# Parsing functions for source intake

def parse_lex_header(header_para):
	"""
	Parses the header paragraph of a lex file.
	Input:  header_para, raw header paragraph from the lex file
	Output: {"error": <error message>} if there was an error, otherwise
	        {"title": <article title>, "filename": <article filename>}
	"""
	# The title, which is also translated to the filename, heads the article after the #
	title_match = re.match("#(.+)", header_para)
	if not title_match:
		return {"error": "No match for title"}
	title = titlecase(title_match.group(1).strip())
	if not title:
		return {"error": "Could not parse header as title"}
	return {"title": title, "filename": as_filename(title)}

def parse_lex_content(paras):
	"""
	Parses the content paragraphs of a lex file.
	Input:  paras, a list of raw paragraphs from the lex file
	Output: {"error": <error message>} if there was an error, otherwise
	        {"content": <article HTML content>,
			 "citations": {<format id>: (link text, link target)}}
	"""
	parsed = {"content": "", "citations": {}}
	format_id = 1 # Each citation will be ID'd by {c#} for formatting later
	for para in paras:
		# Escape angle brackets
		para = re.sub("<", "&lt;", para)
		para = re.sub(">", "&gt;", para)
		# Replace bold and italic marks with tags
		para = re.sub(r"\*\*([^*]+)\*\*", r"<b>\1</b>", para)
		para = re.sub(r"\/\/([^\/]+)\/\/", r"<i>\1</i>", para)
		# Replace \\LF with <br>LF
		para = re.sub(r"\\\\\n", "<br>\n", para)
		# Abstract citations into the citation record
		link_match = re.search(r"\[\[(([^|\[\]]+)\|)?([^|\[\]]+)\]\]", para)
		while link_match:
			# Identify the citation text and cited article
			cite_text = link_match.group(2) if link_match.group(2) else link_match.group(3)
			cite_title = titlecase(link_match.group(3).strip())
			# Record the citation
			parsed["citations"]["c"+str(format_id)] = (cite_text, cite_title)
			# Stitch the format id in place of the citation
			para = para[:link_match.start(0)] + "{c"+str(format_id)+"}" + para[link_match.end(0):]
			format_id += 1 # Increment to the next format citation
			link_match = re.search(r"\[\[(([^|\[\]]+)\|)?([^|\[\]]+)\]\]", para)
		# Convert signature to right-aligned
		if para[:1] == '~':
			para = "<hr><span class=\"signature\"><p>" + para[1:] + "</p></span>\n"
		else:
			para = "<p>" + para + "</p>\n"
		parsed["content"] += para
	if not parsed["content"]:
		return {"error": "No content parsed"}
	return parsed

def parse_lex(lex_contents):
	"""
	Parses the contents of a lex file into HTML and abstracts citations.
	Input:  lex_contents, the read contents of a lex file
	Output: A dictionary in the following format:
	{"title": <article title>, "filename": <article filename>,
	 "content": <article HTML content>, 
	 "citations": {<format id>: (link text, link target)}}
	"""
	parsed_article = {}
	# Split the file into paragraphs
	paras = re.split("\n\n+", lex_contents)
	# Parse the title from the header
	title_parsed = parse_lex_header(paras.pop(0))
	if "error" in title_parsed:
		return title_parsed
	parsed_article.update(title_parsed)
	# Parse each paragraph
	content_parsed = parse_lex_content(paras)
	if "error" in content_parsed:
		return content_parsed
	parsed_article.update(content_parsed)
	# Return the fully abstracted article
	return parsed_article

def parse_lex_from_directory(directory):
	"""
	Reads and parses each lex file in the given directory.
	Input:  directory, the path to the folder to read
	Output: a list of parsed lex file structures
	"""
	lexes = []
	print "Reading lex files from", directory
	for filename in os.listdir(directory):
		path = directory + filename
		# Read only .lex files
		if path[-4:] == ".lex":
			print "    Parsing", path,
			with open(path) as lex_file:
				lex_raw = lex_file.read()
				parsed_lex = parse_lex(lex_raw)
				if "error" in parsed_lex:
					print "ERROR:", parsed_lex["error"]
				else:
					print "SUCCESS:", parsed_lex["title"]
					lexes.append(parsed_lex)
	return lexes

def load_resource(filename, cache={}):
	if filename not in cache:
		cache[filename] = open("resources/" + filename).read()
	return cache[filename]

def load_config():
	config = {}
	with open("lexicon.cfg") as f:
		line = f.readline()
		while line:
			# Skim lines until a value definition begins
			conf_match = re.match(">>>([^>]+)>>>\s+", line)
			if not conf_match:
				line = f.readline()
				continue
			# Accumulate the conf value until the value ends
			conf = conf_match.group(1)
			conf_value = ""
			line = f.readline()
			conf_match = re.match("<<<{0}<<<\s+".format(conf), line)
			while line and not conf_match:
				conf_value += line
				line = f.readline()
				conf_match = re.match("<<<{0}<<<\s+".format(conf), line)
			if not line:
				raise SystemExit("Reached EOF while reading config value {}".format(conf))
			config[conf] = conf_value.strip()
	# Check that all necessary values were configured
	for config_value in ['LEXICON_TITLE', 'SIDEBAR_CONTENT', 'SESSION_PAGE', "INDEX_LIST"]:
		if config_value not in config:
			raise SystemExit("Error: {} not set in lexipython.cfg".format(config_value))
	return config

# Building functions for output

def make_cite_map(lex_list):
	"""
	Compiles all citation information into a single map.
	Input:  lex_list, a list of lex structures
	Output: a map from article titles to cited titles
	"""
	cite_map = {}
	for lex in lex_list:
		cited_titles = [cite_tuple[1] for format_id, cite_tuple in lex["citations"].items()]
		cite_map[lex["title"]] = sorted(set(cited_titles), cmp=cmp_title)
	return cite_map

def format_content(lex, format_func):
	"""
	Formats citations into the lex content according to the provided function.
	Input:  lex, a lex structure
	        formatted_key, the key to store the formatted content under
	        format_func, a function matching (fid, alias, dest) -> citation HTML
	Output: lex content formatted according to format_func
	"""
	format_map = {
		format_id: format_func(format_id, cite_tuple[0], cite_tuple[1])
		for format_id, cite_tuple in lex["citations"].items()
	}
	return lex["content"].format(**format_map)

def citation_lists(title, cite_map):
	"""
	Returns the citation lists for an article.
	Input:  title, an article title
			cite_map, generated by make_cite_map
	Output: a list of cited article titles
	        a list of titles of article citing this article
	"""
	citers = [citer_title
		for citer_title, cited_titles in cite_map.items()
		if title in cited_titles]
	return cite_map[title], citers

def build_article_page(lex, cite_map, config):
	"""
	Builds the full HTML of an article page.
	Input:  lex, a lex structure
			cite_map, generated by make_cite_map
			config, a dict of config values
	Output: the full HTML as a string
	"""
	lf = link_formatter(cite_map.keys())
	# Build the article content
	content = format_content(lex, lf)
	# Build the article citeblock
	cites, citedby = citation_lists(lex["title"], cite_map)
	cites_str = " | ".join([lf(None, title, title) for title in cites])
	citedby_str = " | ".join([lf(None, title, title) for title in citedby])
	citeblock = ""\
		"<div class=\"content citeblock\">\n"\
		"<p>Citations: {cites}</p>\n"\
		"<p>Cited by: {citedby}</p>\n"\
		"</div>\n".format(
			cites=cites_str,
			citedby=citedby_str)
	# Fill in the entry skeleton
	entry_skeleton = load_resource("entry-page.html")
	css = load_resource("lexicon.css")
	return entry_skeleton.format(
		title=lex["title"],
		lexicon=config["LEXICON_TITLE"],
		css=css,
		logo=config["LOGO_FILENAME"],
		sidebar=config["SIDEBAR_HTML"],
		content=content,
		citeblock=citeblock)

def build_phantom_page(title, cite_map, config):
	"""
	Builds the full HTML of a phantom page.
	Input:  title, the phantom title
			cite_map, generated by make_cite_map
			config, a dict of config values
	Output: the full HTML as a string
	"""
	lf = link_formatter(cite_map.keys())
	# Fill in the content with filler
	content = "<p><i>This entry hasn't been written yet.</i></p>"
	# Build the stub citeblock
	cites, citedby = citation_lists(title, cite_map)
	citedby_str = " | ".join([lf(None, title, title) for title in citedby])
	citeblock = ""\
		"<div class=\"content citeblock\">\n"\
		"<p>Cited by: {citedby}</p>\n"\
		"</div>\n".format(
			citedby=citedby_str)
	# Fill in the entry skeleton
	entry_skeleton = load_resource("entry-page.html")
	css = load_resource("lexicon.css")
	return entry_skeleton.format(
		title=title,
		lexicon=config["LEXICON_TITLE"],
		css=css,
		logo=config["LOGO_FILENAME"],
		sidebar=config["SIDEBAR_HTML"],
		content=content,
		citeblock=citeblock)

def build_stub_page(title, cite_map, config):
	"""
	Builds the full HTML of a stub page.
	Input:  title, the stub title
			cite_map, generated by make_cite_map
			config, a dict of config values
	Output: the full HTML as a string
	"""
	lf = link_formatter(cite_map.keys())
	# Fill in the content with filler
	content = "<p>[The handwriting is completely illegible.]</p>\n"\
		"<hr><span class=\"signature\"><p>Ersatz Scrivener</p></span>\n"
	# Build the stub citeblock
	citedby = [citer_title
		for citer_title, cited_titles in cite_map.items()
		if title in cited_titles]
	citedby_str = " | ".join([lf(None, title, title) for title in citedby])
	citeblock = ""\
		"<div class=\"content citeblock\">\n"\
		"<p>Citations: [Illegible]</p>\n"\
		"<p>Cited by: {citedby}</p>\n"\
		"</div>\n".format(
			citedby=citedby_str)
	# Fill in the entry skeleton
	entry_skeleton = load_resource("entry-page.html")
	css = load_resource("lexicon.css")
	return entry_skeleton.format(
		title=title,
		lexicon=config["LEXICON_TITLE"],
		css=css,
		logo=config["LOGO_FILENAME"],
		sidebar=config["SIDEBAR_HTML"],
		content=content,
		citeblock=citeblock)

def build_index_page(cite_map, config):
	"""
	Builds the full HTML of the index page.
	Input:	cite_map, generated by make_cite_map
			config, a dict of config values
	Output:	the HTML of the index page
	"""
	# Count up all the titles
	titles = sorted(
		(set(cite_map.keys()) |
		set([title for cited_titles in cite_map.values() for title in cited_titles]))
		, cmp=cmp_title)
	content = ""
	if len(titles) == len(cite_map.keys()):
		content = "<p>There are <b>{0}</b> entries in this lexicon.</p>\n<ul>\n".format(len(titles))
	else:
		content = "<p>There are <b>{0}</b> entries, <b>{1}</b> written and <b>{2}</b> phantom.</p>\n<ul>\n".format(
			len(titles), len(cite_map.keys()), len(titles) - len(cite_map.keys()))
	# Write all of the entries out as links under their indices
	lf = link_formatter(cite_map.keys())
	indices = config["INDEX_LIST"].split("\n")
	for index_str in indices:
		content += "<h3>{0}</h3>".format(index_str)
		index_titles = []
		for c in index_str.upper():
			for title in titles:
				if (titlestrip(title)[0] == c):
					index_titles.append(title)
		for title in index_titles:
			titles.remove(title)
			content += "<li>"
			content += lf(None, title, title)
			content += "</li>\n"
	if len(titles) > 0:
		content += "<h3>&c.</h3>".format(index_str)
		for title in titles:
			content += "<li>"
			content += lf(None, title, title)
			content += "</li>\n"
	content += "</ul>\n"
	# Fill in the entry skeleton
	entry_skeleton = load_resource("entry-page.html")
	css = load_resource("lexicon.css")
	return entry_skeleton.format(
		title="Index of " + config["LEXICON_TITLE"],
		lexicon=config["LEXICON_TITLE"],
		css=css,
		logo=config["LOGO_FILENAME"],
		sidebar=config["SIDEBAR_HTML"],
		content=content,
		citeblock="")

def build_rules_page(config):
	"""
	Builds the full HTML of the rules page.
	Input:	config, a dict of config values
	Output:	the HTML of the rules page
	"""
	content = load_resource("rules.html")
	# Fill in the entry skeleton
	entry_skeleton = load_resource("entry-page.html")
	css = load_resource("lexicon.css")
	return entry_skeleton.format(
		title="Rules",
		lexicon=config["LEXICON_TITLE"],
		css=css,
		logo=config["LOGO_FILENAME"],
		sidebar=config["SIDEBAR_HTML"],
		content=content,
		citeblock="")

def build_formatting_page(config):
	"""
	Builds the full HTML of the formatting page.
	Input:	config, a dict of config values
	Output:	the HTML of the formatting page
	"""
	content = load_resource("formatting.html")
	# Fill in the entry skeleton
	entry_skeleton = load_resource("entry-page.html")
	css = load_resource("lexicon.css")
	return entry_skeleton.format(
		title="Formatting",
		lexicon=config["LEXICON_TITLE"],
		css=css,
		logo=config["LOGO_FILENAME"],
		sidebar=config["SIDEBAR_HTML"],
		content=content,
		citeblock="")

def build_session_page(config):
	"""
	Builds the full HTML of the session page.
	Input:	config, a dict of config values
	Output:	the HTML of the session page
	"""
	session_lex = parse_lex(config["SESSION_PAGE"])
	content = format_content(session_lex, lambda fid,alias,dest: "<u>" + alias + "</u>")
	# Fill in the entry skeleton
	entry_skeleton = load_resource("entry-page.html")
	css = load_resource("lexicon.css")
	return entry_skeleton.format(
		title=session_lex["title"],
		lexicon=config["LEXICON_TITLE"],
		css=css,
		logo=config["LOGO_FILENAME"],
		sidebar=config["SIDEBAR_HTML"],
		content=content,
		citeblock="")

def build_statistics_page(cite_map, config):
	"""
	Builds the full HTML of the statistics page.
	Input:	citation_map, a dictionary returned by make_cite_map
			config, a dict of config values
	Output:	the HTML of the statistics page
	"""
	content = ""
	# Compute the pagerank
	content += "<p><u>Top 10 by page rank:</u><br>\n"
	G = networkx.Graph()
	for citer, citeds in cite_map.items():
		for cited in citeds:
			G.add_edge(citer, cited)
	ranks = networkx.pagerank(G)
	sranks = sorted(ranks.items(), key=lambda x: x[1], reverse=True)
	ranking = list(enumerate(map(lambda x: x[0], sranks)))
	content += "<br>\n".join(map(lambda x: "{0} - {1}".format(x[0]+1, x[1]), ranking[:10]))
	content += "</p>\n"
	# Count the top number of citations made from
	content += "<p><u>Most citations made from:</u><br>\n"
	citation_tally = [(kv[0], len(kv[1])) for kv in cite_map.items()]
	citation_count = defaultdict(list)
	for title, count in citation_tally: citation_count[count].append(title)
	content += "<br>\n".join(map(
			lambda kv: "{0} - {1}".format(kv[0], "; ".join(kv[1])),
			sorted(citation_count.items(), reverse=True)[:3]))
	content += "</p>\n"
	# Count the top number of citations made to
	content += "<p><u>Most citations made to:</u><br>\n"
	all_cited = set([title for cites in cite_map.values() for title in cites])
	cited_by_map = { cited: [citer for citer in cite_map.keys() if cited in cite_map[citer]] for cited in all_cited }
	cited_tally = [(kv[0], len(kv[1])) for kv in cited_by_map.items()]
	cited_count = defaultdict(list)
	for title, count in cited_tally: cited_count[count].append(title)
	content += "<br>\n".join(map(
			lambda kv: "{0} - {1}".format(kv[0], "; ".join(kv[1])),
			sorted(cited_count.items(), reverse=True)[:3]))
	#cited_count = map(lambda kv: (kv[0], len(kv[1])), cited_by_map.items())
	#cited_count_sort = sorted(cited_count, key=lambda x: x[1], reverse=True)
	#top_cited_count = [kv for kv in cited_count_sort if kv[1] >= cited_count_sort[:5][-1][1]]
	#content += "<br>\n".join(map(lambda x: "{0} - {1}".format(x[1], x[0]), top_cited_count))
	content += "</p>\n"
	# Fill in the entry skeleton
	entry_skeleton = load_resource("entry-page.html")
	css = load_resource("lexicon.css")
	return entry_skeleton.format(
		title="Statistics",
		lexicon=config["LEXICON_TITLE"],
		css=css,
		logo=config["LOGO_FILENAME"],
		sidebar=config["SIDEBAR_HTML"],
		content=content,
		citeblock="")

# Summative functions

def command_build(argv):
	if len(argv) >= 3 and (argv[2] != "partial" and argv[2] != "full"):
		print "unknown build type: " + argv[2]
		return
	# Set up the entries
	config = load_config()
	sidebar_parsed = parse_lex(config["SIDEBAR_CONTENT"])
	config["SIDEBAR_HTML"] = format_content(sidebar_parsed, lambda fid,alias,dest: alias)
	lexes = parse_lex_from_directory("raw/")
	cite_map = make_cite_map(lexes)
	written_entries = cite_map.keys()
	phantom_entries = set([title for cites in cite_map.values() for title in cites if title not in written_entries])
	# Clear the folder
	print "Clearing old HTML files"
	for filename in os.listdir("out/"):
		if filename[-5:] == ".html":
			os.remove("out/" + filename)
	# Write the written entries
	print "Writing written articles..."
	for lex in lexes:
		page = build_article_page(lex, cite_map, config)
		with open("out/" + lex["filename"] + ".html", "w") as f:
			f.write(page)
		print "    Wrote " + lex["title"]
	# Write the unwritten entries
	if len(phantom_entries) > 0:
		if len(argv) < 3 or argv[2] == "partial":
			print "Writing phantom articles..."
			for title in phantom_entries:
				page = build_phantom_page(title, cite_map, config)
				with open("out/" + as_filename(title) + ".html", "w") as f:
					f.write(page)
				print "    Wrote " + title
		elif argv[2] == "full":
			print "Writing stub articles..."
			for title in phantom_entries:
				page = build_stub_page(title, cite_map, config)
				with open("out/" + as_filename(title) + ".html", "w") as f:
					f.write(page)
				print "    Wrote " + title
		else:
			print "ERROR: build type was " + argv[2]
			return
	# Write the default pages
	print "Writing default pages"
	page = build_rules_page(config)
	with open("out/rules.html", "w") as f:
		f.write(page)
	print "    Wrote Rules"
	page = build_formatting_page(config)
	with open("out/formatting.html", "w") as f:
		f.write(page)
	print "    Wrote Formatting"
	page = build_index_page(cite_map, config)
	with open("out/index.html", "w") as f:
		f.write(page)
	print "    Wrote Index"
	page = build_session_page(config)
	with open("out/session.html", "w") as f:
		f.write(page)
	print "    Wrote Session"
	page = build_statistics_page(cite_map, config)
	with open("out/stats.html", "w") as f:
		f.write(page)
	print "    Wrote Statistics"

def main():
	if len(sys.argv) < 2:
		print "Available commands:"
		print " - build [partial] : Build the lexicon and generate phantom stubs for all unwritten articles."
		print " - build full      : Build the lexicon and generate Ersatz pages for all unwritten articles."
	elif sys.argv[1] == "build":
		command_build(sys.argv)
	else:
		print "Unknown command: " + sys.argv[1]

if __name__ == "__main__":
	main()