% Copyright 2008,9 by Igor Wojnicki
%
% ATTML/XTTML Parser for Prolog
%
%
%     Copyright (C) 2006-9 by the HeKatE Project
%
%     The Parser has been developed by the HeKatE Project, 
%     see http://hekate.ia.agh.edu.pl
%
%     This is free software: you can redistribute it and/or modify
%     it under the terms of the GNU General Public License as published by
%     the Free Software Foundation, either version 3 of the License, or
%     (at your option) any later version.
%
%     It is distributed in the hope that it will be useful,
%     but WITHOUT ANY WARRANTY; without even the implied warranty of
%     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
%     GNU General Public License for more details.
%
%     You should have received a copy of the GNU General Public License
%     along with it.  If not, see <http://www.gnu.org/licenses/>.


% WARNING: The parser works for STRING and NUMERIC base types ONLY.
% if more base types are needed implement additional valconvert/3 clauses

% load a given HML file into Prolog knowledge base
% file contents available as hml/1
hml_load(File):-
	load_xml_file(File,HML), 
	retractall(hml(_)),
	assert(hml(HML)).

% translation between Id and Name
% What could be: att, type, group
id_name(What,Id,Name):-
	hml(HML),
	HML = [element(hml,_,L)],
	member(element(_,_,Attribs),L),
	member(element(What,AttData,_),Attribs),
	member(name=Name,AttData),
	member(id=Id,AttData).

% identify attributes 
att(Id,Name,Abbrev,TypeId,Value,Class):-
	hml(HML),
	HML = [element(hml,_,L)],
	member(element(attribute_set,_,Attribs),L),
	member(element(att,AttData,_),Attribs),
	member(id=Id,AttData),
	member(abbrev=Abbrev,AttData),
	member(name=Name,AttData),
	member(type=TypeId,AttData),
	member(value=Value,AttData),
	member(class=Class,AttData).

% identify types 
type(Id,Name,Base,Len,Scale,Domain,Vals):-
	hml(HML),
	HML = [element(hml,_,L)],
	member(element(type_set,_,Types),L),
	member(element(type,TypeData,TypeContents),Types),
	member(id=Id,TypeData),
	member(name=Name,TypeData),
	member(base=Base,TypeData),
	member(length=Lena,TypeData),
	atom_number(Lena,Len),
	member(scale=Scalea,TypeData),
	atom_number(Scalea,Scale),
	member(element(domain,[type=Domain],V),TypeContents),
	domainconv(V,Vals).

% helper predicates for type/7
	
%converts domain HML element to prolog representation, used by type/6
domainconv([],[]).
domainconv([element(value,[],[Va])|List],[V|Values]):-
	valconvert(_,Va,V),
	domainconv(List,Values).
domainconv([element(range,R,[])|List],[V|Values]):-
	member(from=Fa,R),
	member(to=Ta,R),
	valconvert(_,Fa,F),
	valconvert(_,Ta,T),
	V=range(F,T),
	domainconv(List,Values).

% value conversion depending on the base type
% atom-> list of char codes
% atom->numeric
valconvert(numeric,From,To):-
	atom_codes(From,Codes),
	name(To,Codes), number(To),!.
valconvert(string,From,To):-
	atom_codes(From,To).

% access xtt schema
schema(XttId,Independent,Dependent):-
	hml(HML),
	HML = [element(hml,_,L)],
	member(element(xtt,_,Xtt),L),
	member(element(xtt_table,XttData,XttContents),Xtt),
	member(id=XttId,XttData),
	member(element(schema,_,SchemaContents),XttContents),
	member(element(independent,_,IndependenContents),SchemaContents),
	member(element(dependent,_,DependentContents),SchemaContents),
%	Independent=IndependenContents,
%	Dependent=DependentContents.
	findall(att(AttId),member(element(attref,[ref=AttId],_),IndependenContents),Independent),
	findall(att(AttId),member(element(attref,[ref=AttId],_),DependentContents),Dependent).

% access rules
rule(XttId, Id, Condition, Decision, XttNext):-
	hml(HML),
	HML = [element(hml,_,L)],
	member(element(xtt,_,Xtt),L),
	member(element(xtt_table,XttData,XttContents),Xtt),
	member(id=XttId,XttData),
% a schema check could be added here FIXME
	member(element(rule,RuleData,RuleContents),XttContents),
	member(id=Id,RuleData),
	rule_condition(RuleContents,Condition),
	rule_decision(RuleContents,Decision),
	rule_link(RuleContents,XttNext).
	
	

rule_condition(RuleContents,Condition):-
	member(element(condition,_,ConditionContents),RuleContents),
	rule_condition_logop(ConditionContents,Condition),
	!.

rule_condition(_,[]).

rule_condition_logop(ConditionContents,Condition):-
	findall([LogOpName,att(AttId),RightArgumentOut],
		(
		 member(element(logop,[name=LogOpName],
				[element(attref,[ref=AttId],_)|RightArgument]),
			ConditionContents),

		 rule_condition_logop_rightargument(RightArgument,RightArgumentOut)
	       ),
		Condition).
	
rule_condition_logop_rightargument([element(domain,_,Domain)],domain(RightArgumentOut)):-
		domainconv(Domain,RightArgumentOut).
rule_condition_logop_rightargument([element(attref,[ref=AttId],_)],att(AttId)).

rule_decision(RuleContents,Decision):-
	member(element(decision,_,DecisionContents),RuleContents),
	rule_decision_modop(DecisionContents,Decision),
	!.
rule_decision(_,[]).

rule_decision_modop(DecisionContents,Decision):-
	findall([ModOpName|AttribsOrDomainOrEvalop],
		(
		 member(element(modop,[name=ModOpName],ModOpContents),DecisionContents),
		 attribs_domain_evalop(ModOpContents,AttribsOrDomainOrEvalop)
	       ),
		Decision).
	
attribs_domain_evalop([],[]).
attribs_domain_evalop([element(attref,[ref=AttId],_)|ModOpContents],
		      [att(AttId)|Object]):-
	attribs_domain_evalop(ModOpContents,Object).
attribs_domain_evalop([element(domain,_,DomainContents)|ModOpContents],
		      [domain(O)|Object]):-
	domainconv(DomainContents,O),
	attribs_domain_evalop(ModOpContents,Object).
attribs_domain_evalop([element(evalop,[name=EvalOpName],EvalOpContents)|ModOpContents],
		      [[EvalOpName|EvalOpContentsOut]|Object]):-
	
	attribs_domain_evalop(EvalOpContents,EvalOpContentsOut),
	attribs_domain_evalop(ModOpContents,Object).



rule_link(RuleContents,XttNext):-
	findall(LinkId,
		member(element(link,[xtt=LinkId],_),RuleContents),
		XttNext),
	!.
rule_link(_,[]).