#!/usr/bin/python
################################################################
#
#           Check syntax 
#
################################################################
import pickle, argparse, os
import pattern,synt
from getpath import getpath
from prop import readprops

parser = argparse.ArgumentParser()

parser.add_argument("file", 
	help = "name of the file to be parsed")

parser.add_argument("-e", "--expression", type=str,
	help = "parse a command line expression")

parser.add_argument("-m", "--mathonly", action = "store_true",
	help = "check math but not proof syntax")

parser.add_argument("-q", "--quiet", action = "store_true",
	help = "suppress output")

parser.add_argument("-r","--resetdefs", action = "store_true", 
	help = "expunge latent definitions")

parser.add_argument("-t","--textmode", action = "store_true",
	help = "output everything outside of math mode")

args = parser.parse_args()

if args.file.endswith(".tex"):
	Arg_1 = args.file[:-4]
else:
	Arg_1 = args.file 

if not os.path.isfile(Arg_1 + ".tex"):
	print(Arg_1 + ".tex not found.")
	raise SystemExit

new_dfs = False
rebuild_mathdb = args.resetdefs 
dfs_filename = os.path.split(Arg_1)[1] + ".dfs"
Arg1_dfs_pathname = getpath(dfs_filename)
if not rebuild_mathdb:
	if Arg1_dfs_pathname:
		f = open(Arg1_dfs_pathname,"rb")
		syntdb = pickle.load(f)
		f.close()
		dfs_mtime = os.stat(Arg1_dfs_pathname).st_mtime
	else:
		rebuild_mathdb = True
		new_dfs = True
if rebuild_mathdb:
	syntdb = synt.makemathdb() 
	dfs_mtime = -1

synt.mathdb = syntdb
synt.mathtf = {}

#############################################################
#
#     Read or Rebuild math data base
#
#############################################################

f = open(Arg_1 + ".tex","r")
line_list = f.readlines()
f.close()

callinglist = []
for r in line_list: 
		inputfilem = pattern.inputfile.match(r)
		if inputfilem:
			called_fname = inputfilem.group(2) 
			df_suffix = "." + inputfilem.group(3)
			if called_fname == "utility":
				continue	
			if called_fname == Arg_1:
				break
			dfs_pathname = getpath(called_fname + ".dfs")  
			if not dfs_pathname:
				print("Warning: can't find ", called_fname + ".dfs")  
			else:
				callinglist.append(called_fname)
else:
	raise SystemExit("input " + Arg_1 + ".[lt]df call not found")

syntax_header_file = Arg_1 + df_suffix

for called_fname in callinglist:
	fpathname = getpath(called_fname + ".tex")
	df_pathname = getpath(called_fname + df_suffix)
	if not fpathname:
		raise SystemExit(called_fname + ".tex" + " not found")
	if not df_pathname:
		raise SystemExit(called_fname + df_suffix + " not found")
	dfs_pathname = getpath(called_fname + ".dfs")  
	if os.stat(dfs_pathname).st_mtime < os.stat(df_pathname).st_mtime or\
		os.stat(dfs_pathname).st_mtime < os.stat(fpathname).st_mtime:
		print("Parsing",called_fname)
		if os.name == 'nt':
			os.system("parse.py -qrm " + fpathname) 
		else:
			os.system("parse -qrm " + fpathname) 
	if dfs_mtime < os.stat(dfs_pathname).st_mtime:
		f = open(dfs_pathname, "rb")
		pickled_db = pickle.load(f)
		f.close()
		if syntdb:
			synt.dbmerge(syntdb, pickled_db)
		else:
			syntdb = pickled_db
		synt.mathdb = syntdb

############################################################
#
#  Read header file and execute directives 
#
############################################################

headerf = getpath(syntax_header_file)

if not headerf:
	raise SystemExit("Can't find " + syntax_header_file)
elif rebuild_mathdb or dfs_mtime < os.stat(headerf).st_mtime:
	for s in open(headerf): 
		if pattern.directive.match(s):
			p = synt.process_directive(s,hereditary_only = False)
			if type(p) is str:
				print("Error in " + syntax_header_file + ":", s)
				raise SystemExit(p)

######################################################
#
# Single Expression from the Command Line
#
######################################################

if args.expression:
	parsetree = []
	mode = [2]

	synt.mathparse(mode,[args.expression],parsetree)
	print(parsetree)
	raise SystemExit

################################################################
#
#	 Read File 
#
####################################################

f = open(Arg_1 + ".tex","r")
line_list = f.readlines()
f.close()

#line_list = synt.translate(line_list) 

defs = syntdb[synt.MD_DEFS]

ndefs= 0
for x in defs:
	ndefs= ndefs+ len(defs[x])

#
#############################################################
#
# Get Transitive Parsing Properties 
#
#############################################################
#

if not args.mathonly:
	for entry in syntdb[synt.MD_TRFILE]:
		propfilename = entry[0]
#		propfilename = syntdb[synt.MD_PFILE] 
		proppathname = getpath(propfilename)
		if not proppathname:
			raise SystemExit("Transitive property file: " + propfilename + " not found.")
		readprops(proppathname,entry,syntdb)
#	synt.mathdb = syntdb

import document

doc = document.Document(line_list,args.mathonly,args.textmode)

if args.textmode:
	for k, b in enumerate(doc.blocklist):
		if k % 2 == 0:
			for s in b:
				for t in list(s)[:-2]:
					print(t, end = ' ')
	raise SystemExit

ndefs_old = ndefs
ndefs= 0
for x in defs:
	ndefs= ndefs+ len(defs[x])

if args.mathonly:

	if ndefs == 1 + ndefs_old:
		print ("    1 new definition (or primitive) processed.")
	elif ndefs > 1 + ndefs_old:
		print ("    ",(ndefs - ndefs_old), " new definitions (or primitives) processed.")
	else:
		print()


else:
#	if len(synt.needed_syntax_handlers) > 1:
#		print("No syntax handler for precedences: ", end = ' ')
#		for x in synt.needed_syntax_handlers:
#			print(x, end = ',')
#		print()
#	elif synt.needed_syntax_handlers:
#		print("No syntax handler for precedence: ", synt.needed_syntax_handlers.pop())
	print(doc)
	f = open(Arg_1 + ".pfs","wb")
	pickle.dump(doc,f)
	f.close()

if Arg1_dfs_pathname:
	g = open(Arg1_dfs_pathname,"wb")
	if new_dfs: print("Creating ", Arg1_dfs_pathname) 
else:
	g = open(Arg_1 + ".dfs","wb")
	if new_dfs: print("Creating ", Arg_1 + ".dfs")
pickle.dump(synt.mathdb, g)
g.close()

if synt.mathtf:
	premise_trace_function = {}
	for n in synt.mathtf:
		premise_trace_function[(Arg_1 + ".tex", n)] = synt.mathtf[n]
	g = open(Arg_1 + ".trc","wb")
	pickle.dump(premise_trace_function,g)
	g.close()
