procedure.ced~

% Procedures
signature(cpi:procedureCommand(Proc, Command) :: proc, [Proc::procedure, Command::command]).

signature(procedure(Proc, Command)::statement, [Proc::procedure, Command::command]).
procedure(Proc, Command) ~> cpi:procedureCommand(Proc, Command) :- builtin:true.

signature(function(Expr, T, Result, Command) :: statement, [Expr::expr(T), T::type, Result::ref(T), Command::command]).
signature(cpi:func(Proc, Result, T) :: procedure, [Proc::procedure, Result::ref(T), T::type]).
function(Expr, T, Result, Command) ~> procedure(cpi:func(Expr, Result, T), Command).

signature(cpi:termClass(TTerm, ClassName)::pred, [TTerm::typedTerm, ClassName::string]).
signature(class(TTerm, ClassName)::statement, [TTerm::typedTerm, ClassName::string]).
commandClass(Cmd, ClassName) ~> cpi:termClass(Cmd::command, ClassName) :- builtin:true.


signature(doAll(List)::command, [List::list(command)]).
commandClass(doAll(_), s('net.nansore.cedalion.cmd.DoAll')).

signature(assign(Ref, Expr, Type)::command, [Ref::ref(Type), Expr::expr(Type), Type::type]).
commandClass(assign(_, _, _), s('net.nansore.cedalion.cmd.Assign')).

signature(doProc(Proc)::command, [Proc::procedure]).
commandClass(doProc(_), s('net.nansore.cedalion.cmd.DoProc')).

signature(readFile(FileName, Namespace, FileContent)::command, [FileName::string, Namespace::string, FileContent::fileContent]).
commandClass(readFile(FileName, Namespace, FileContent), s('net.nansore.cedalion.cmd.ReadFile')).

signature(writeFile(FileName, FileContent)::command, [FileName::string, FileContent::fileContent]).
commandClass(writeFile(FileName, FileContent), s('net.nansore.cedalion.cmd.WriteFile')).

signature(assignFinal(Var, Expr, T)::command, [Var::T, Expr::expr(T), T::type]).
commandClass(assignFinal(Var, Expr, T), s('net.nansore.cedalion.cmd.AssignFinal')).

signature(dbInsert(Statement)::command, [Statement::statement]).
commandClass(dbInsert(Statement), s('net.nansore.cedalion.cmd.DBInsert')).

signature(dbRemove(Statement)::command, [Statement::statement]).
commandClass(dbRemove(Statement), s('net.nansore.cedalion.cmd.DBRemove')).

signature(termToString(TTerm, VarNames, Depth, NsList, Str)::command, [TTerm::typedTerm, VarNames::list(varName), Depth::number, NsList::list(namespacePair), Str::ref(string)]).
commandClass(termToString(TTerm, VarNames, Depth, NsList, Str), s('net.nansore.cedalion.cmd.TermToString')).

signature(stringToTerm(StringRef, NsList, TTerm, VarNames)::command, [StringRef::ref(string), NsList::list(namespacePair), TTerm::typedTerm, VarNames::list(varName)]).
commandClass(stringToTerm(StringRef, NsList, TTerm, VarNames), s('net.nansore.cedalion.cmd.StringToTerm')).

% Open a file
procedure(cpi:openFile(FileName, ResourceName, Namespace), 
	doAll([
		readFile(FileName, Namespace, FileContent),
		assignFinal(Model, fileToModel(FileContent), model),
		dbInsert(loadedFile(ResourceName, FileName, Model)),
		dbInsert(editState(ResourceName, [], [], 0))
	])).

procedure(cpi:closeFile(ResourceName), 
	doAll([
		dbRemove(loadedFile(ResourceName, _, _)),
		dbRemove(editState(ResourceName, _, _, _))
	])).

loadedFile(ResourceName, FileName, Model) ~> fileIsLoaded(ResourceName, FileName, Model) :- builtin:true.
editState(ResourceName, UndoStack, RedoStack, ModifiedCounter) ~> editStateIs(ResourceName, UndoStack, RedoStack, ModifiedCounter) :- builtin:true.

cpi:procedureCommand(cpi:func(fileToModel(fileContent(Terms, NsList)), ModelRef, model), assign(ModelRef, cpi:constExpr(model(Statements, VarNames, NsList)), model)) :-
	fileModel(Terms, Statements, VarNames).

signature(fileModel(Terms, Statements, VarNames)::pred, [Terms::list(annotatedTerm), Statements::list(statement), VarNames::list(varName)]).
fileModel([], [], []) :- builtin:true.
fileModel([statement(S, VN1) | Terms], [S | Statements], VarNames) :-
	fileModel(Terms, Statements, VN2),
	mergeVarNames(VN1, VN2, VarNames).


mergeVarNames([], VarNames, VarNames) :- builtin:true.
mergeVarNames([varName(Var::T, Name) | VN1], VN2, VarNames) :-
	builtin:if(varInVarNames(Var::T, VN2),
		mergeVarNames(VN1, VN2, VarNames),
		%else
		mergeVarNames(VN1, [varName(Var::T, Name) | VN2], VarNames)).

varInVarNames(Var::T, [varName(Var1::T, _) | _]) :-
	builtin:equals(Var1::T, Var::T).
varInVarNames(Var::T, [_ | VN]) :-
	varInVarNames(Var::T, VN).


% Save a file
cpi:procedureCommand(cpi:saveFile(ResourceName, FileName), writeFile(FileName, Content)) :-
	fileIsLoaded(ResourceName, _, Model),
	modelToContent(Model, Content).

modelToContent(model(Statements, VarNames, NsList), fileContent(AnnoStatements, NsList)) :-
	annotateStatements(Statements, VarNames, AnnoStatements).


annotateStatements([], _, []) :- builtin:true.
annotateStatements([Statement | Statements], VarNames, [statement(Statement, VN1) | AnnoStatements]) :-
	selectVarNamesFor(Statement::statement, VarNames, VN1),
	annotateStatements(Statements, VarNames, AnnoStatements).

selectVarNamesFor(_, [], []) :- builtin:true.
selectVarNamesFor(TTerm, [varName(Var::T, Name) | VarNames], VN) :-
	selectVarNamesFor(TTerm, VarNames, VN1),
	builtin:if(varIn(Var::T, TTerm),
		VN = [varName(Var::T, Name) | VN1],
		% else
		VN = VN1).

varIn(Var::VarType, Term::TermType) :-
	builtin:if(builtin:var(Term::TermType),
		builtin:equals(Var::VarType, Term::TermType),
		(% else
			builtin:compound(Term::TermType),
			builtin:parseTerm(Term::TermType, _, Args),
			varInList(Var::VarType, Args)
		)).

varInList(Var::VarType, [First::FirstType | _]) :-
	varIn(Var::VarType, First::FirstType).

varInList(Var::VarType, [_ | Tail]) :-
	varInList(Var::VarType, Tail).

% Retrieve a term at a given path
cpi:termAtPath(cpi:path(ResourceName, []), Statements::list(statement), VarNames) :-
	fileIsLoaded(ResourceName, _, model(Statements, VarNames, _)).

cpi:termAtPath(cpi:path(ResourceName, [Innermost | Rest]), TTerm, CroppedVarNames) :-
	cpi:termAtPath(cpi:path(ResourceName, Rest), TParent, VarNames),
	builtin:parseTerm(TParent, _, TArgs),
	element(TTerm, Innermost, TArgs, typedTerm),
%	selectVarNamesFor(TTerm, VarNames, CroppedVarNames).
	CroppedVarNames = VarNames.

% The n'th element of a list (1-based)
signature(element(Elem, Index, List, Type)::pred, [Elem::Type, Index::number, List::list(Type), Type::type]).
element(First, 1, [First | _], _) :- builtin:true.
element(Elem, Index, [_ | Rest], Type) :-
	builtin:succ(IndexMinusOne, Index),
	element(Elem, IndexMinusOne, Rest, Type).

% Modify the n'th element of a list (1-based) to produce a new list
signature(setElement(Index, List, Elem, NewList, Type)::pred, [Index::number, List::list(Type), Elem::Type, NewList::Type, Type::type]).
setElement(1, [_ | Rest], Elem, [Elem | Rest], _) :- builtin:true.
setElement(Index, [First | Rest], Elem, [First | ModRest], Type) :-
	builtin:succ(IndexMinusOne, Index),
	setElement(IndexMinusOne, Rest, Elem, ModRest, Type).

% Modify a term at a given path
cpi:procedureCommand(cpi:setAtPath(cpi:path(ResourceName, []), Statements::list(statement), VarNames2), doAll([
		dbRemove(loadedFile(ResourceName, _, _)),
		dbInsert(loadedFile(ResourceName, FileName, model(Statements, VarNames, NsList)))])) :-
	fileIsLoaded(ResourceName, FileName, model(_, VarNames1, NsList)),
	mergeVarNames(VarNames1, VarNames2, VarNames).

cpi:procedureCommand(cpi:setAtPath(cpi:path(ResourceName, [Innermost | Rest]), TTerm, VarNames1), Command) :-
	cpi:termAtPath(cpi:path(ResourceName, Rest), TParent, VarNames2),
	mergeVarNames(VarNames1, VarNames2, VarNames),
	builtin:parseTerm(TParent, Func, TArgs),
	setElement(Innermost, TArgs, TTerm, TModArgs, typedTerm),
	builtin:parseTerm(TModParent, Func, TModArgs),
	cpi:procedureCommand(cpi:setAtPath(cpi:path(ResourceName, Rest), TModParent, VarNames), Command).

% Edit operation: Modify and update the undo stack
cpi:procedureCommand(cpi:edit(cpi:path(ResourceName, Path), TTerm, VarNames), doAll([
		doProc(cpi:setAtPath(cpi:path(ResourceName, Path), TTerm, VarNames)),
		dbRemove(editState(ResourceName, _, _, _)),
		dbInsert(editState(ResourceName, [editOp(cpi:path(ResourceName, Path), OldTypedContent, OldVarNames) | UndoStack], [], NewModifiedCounter))
	])) :-
	editStateIs(ResourceName, UndoStack, _, OldModifiedCounter),
	cpi:termAtPath(cpi:path(ResourceName, Path), OldTypedContent, OldVarNames),
	builtin:if(OldModifiedCounter < 0,
		NewModifiedCounter::number = 99999::number,
		%else
		builtin:succ(OldModifiedCounter, NewModifiedCounter)).

% Undo editing
cpi:procedureCommand(cpi:undo(ResourceName), doAll([
		doProc(cpi:setAtPath(cpi:path(ResourceName, Path), TypedContent, VarNames)),
		assignFinal(NewModifiedCounter, cpi:constExpr(OldModifiedCounter) - cpi:constExpr(1), number),
		dbRemove(editState(ResourceName, _, _, _)),
		dbInsert(editState(ResourceName, UndoStack, [editOp(cpi:path(ResourceName, Path), OldTypedContent, OldVarNames) | RedoStack], NewModifiedCounter))
	])) :-
	editStateIs(ResourceName, [editOp(cpi:path(ResourceName, Path), TypedContent, VarNames) | UndoStack], RedoStack, OldModifiedCounter),
	cpi:termAtPath(cpi:path(ResourceName, Path), OldTypedContent, OldVarNames).

% Redo editing
cpi:procedureCommand(cpi:redo(ResourceName), doAll([
		doProc(cpi:setAtPath(cpi:path(ResourceName, Path), TypedContent, VarNames)),
		assignFinal(NewModifiedCounter, cpi:constExpr(OldModifiedCounter) - cpi:constExpr(1), number),
		dbRemove(editState(ResourceName, _, _, _)),
		dbInsert(editState(ResourceName, [editOp(cpi:path(ResourceName, Path), OldTypedContent, OldVarNames) | UndoStack], RedoStack, NewModifiedCounter))
	])) :-
	editStateIs(ResourceName, UndoStack, [editOp(cpi:path(ResourceName, Path), TypedContent, VarNames) | RedoStack], OldModifiedCounter),
	cpi:termAtPath(cpi:path(ResourceName, Path), OldTypedContent, OldVarNames).

% Arithmetic functions
signature((X+Y)::number, [X::number, Y::number]).
function(X+Y, number, Z, plus(X, Y, Z)).
commandClass(plus(X, Y, Z), s('net.nansore.cedalion.cmd.Plus')).

signature((X-Y)::number, [X::number, Y::number]).
function(X-Y, number, Z, minus(X, Y, Z)).
commandClass(minus(X, Y, Z), s('net.nansore.cedalion.cmd.Minus')).

% Path to string
cpi:procedureCommand(cpi:func(cpi:termAsString(cpi:path(ResourceName, Path), Depth), Str, string), termToString(TTerm, VarNames, Depth, NsList, Str)) :-
	cpi:termAtPath(cpi:path(ResourceName, Path), TTerm, VarNames),
	fileIsLoaded(ResourceName, _, model(_, _, NsList)).

% Edit a certain path with the given string
cpi:procedureCommand(cpi:editFromString(cpi:path(ResourceName, Path), StringRef), doAll([
		stringToTerm(StringRef, NsList, TTerm, VarNames),
		doProc(cpi:edit(cpi:path(ResourceName, Path), TTerm, VarNames))
	])) :-
	fileIsLoaded(ResourceName, _, model(_, _, NsList)).

%%%%% Visualization %%%%%%%

cpi:visualizePath(Path, Vis) :-
	cpi:termAtPath(Path, Term::Type, VarNames),
	builtin:if(builtin:var(Term::Type),
		visualizeVar(Term::Type, VarNames, Vis),
		% else
		builtin:if(builtin:number(Term::Type),
			visualizeNumber(Term::Type, Vis),
			% else
			builtin:if(builtin:string(Term::Type),
				visualizeString(Term::Type, Vis),
				% else
				visualizeCompound(Path, Term::Type, Vis)
			)
		)
	).

visualizeVar(_, [varName(_, Name)], italic(color(label(Name), rgb(0, 128, 0)))) :- builtin:true.
visualizeNumber(Num::number, numLabel(Num)) :- builtin:true.
visualizeString(Str::string, label(Str)) :- builtin:true.

visualizeCompound(Path, TTerm, Vis) :-
	builtin:parseTerm(TTerm, Func, TArgs),
	builtin:length(TArgs, typedTerm, Arity),
	subPaths(Path, 0, Arity, SubPaths),
	visualizeNameSubpaths(Func, SubPaths, Vis).

subPaths(_, Last, Last, []) :- builtin:true.
subPaths(cpi:path(Res, Path), BeforeFirst, Last, [cpi:path(Res, [First | Path]) | SubPaths]) :-
	builtin:succ(BeforeFirst, First),
	subPaths(cpi:path(Res, Path), First, Last, SubPaths).

visualizeNameSubpaths(Func, SubPaths, Vis) :-
	builtin:if(userVisualization(Func, SubPaths, Vis),
		builtin:true,
		% else
		defaultVisualization(Func, SubPaths, Vis)).

defaultVisualization(Func, SubPaths, Vis) :-
	builtin:if(SubPaths::list(cpi:path) = []::list(cpi:path),
		Vis::visualization = label(Func)::visualization,
		(% else
			argListForPathList(SubPaths, ArgList),
			Vis::visualization = horiz([label(Func), label(s('(')), horiz(ArgList), label(s(')'))])::visualization
		)
	).

argListForPathList([Path], [vis(Path)]) :- builtin:true.
argListForPathList([First | Rest], [vis(First), label(s(',')) | ArgList]) :-
	argListForPathList(Rest, ArgList).

signature(visualize(Func, Args, Vis)::statement, [Func::string, Args::list(cpi:path), Vis::visualization]).
visualize(Func, Args, Vis) ~> userVisualization(Func, Args, Vis) :- builtin:true.