state_custom_dot_graph

add_default_attrs([],Attrs,Attrs).

add_default_attrs([Attr/Val|T],Attrs,ResAttrs) :-
    (member(Attr/_,Attrs) -> add_default_attrs(T,Attrs,ResAttrs)
    ; Val=none, \+ none_valid(Attr) -> add_default_attrs(T,Attrs,ResAttrs) % Should we completely remove this line?
    ; ResAttrs = [Attr/Val|RT],
    add_default_attrs(T,Attrs,RT)).

assert_custom_edges2(Edges,DefaultAttrs,Span,_Nr) :- Edges = rec(_),
    extract_record_fields(Edges,_,DotAttributes,OtherFields),!,
    % we have a nested record with default Attributes for the edges
    add_default_attrs(DefaultAttrs,DotAttributes,NewDefaultAttrs),
    exclude(process_edges_field(NewDefaultAttrs,Span),OtherFields,Infos1),
    (Infos1 = [] -> true
    ; add_warning(state_custom_dot_graph,'Unrecognized CUSTOM_GRAPH edges fields: ',Infos1,Span)).

assert_custom_edges2(Edges,DefaultAttrs,_,Nr) :-
    try_expand_custom_set_with_catch(Edges, EdgesRes,extract_dot_function),
    (select(label/Label,DefaultAttrs,DA) -> true
    ; Label='edge', DA=DefaultAttrs),
    assertz(custom_edges(Label,Nr,DA,EdgesRes)).

assert_custom_nodes2(Nodes,DefaultAttrs,Span,_Nr) :- Nodes = rec(_),
    extract_record_fields(Nodes,_,DotAttributes,OtherFields),!,
    % we have a nested record with default Attributes for the nodes
    add_default_attrs(DefaultAttrs,DotAttributes,NewDefaultAttrs),
    exclude(process_nodes_field(NewDefaultAttrs,Span),OtherFields,Infos1),
    (Infos1 = [] -> true
    ; add_warning(state_custom_dot_graph,'Unrecognized CUSTOM_GRAPH nodes fields: ',Infos1,Span)).

assert_custom_nodes2(Nodes,DefaultAttrs,_,Nr) :-
    try_expand_custom_set_with_catch(Nodes, NodesRes,extract_dot_function),
    assertz(custom_nodes('custom',Nr,DefaultAttrs,NodesRes)). %translate:print_bvalue(NodesRes),nl

cg_node_predicate(NodeID,SubGraph,Attributes) :- SubGraph=none,
    custom_nodes(CustomID,_Nr,DefaultAttrs,Nodes),
    debug_format(19,'Processing CUSTOM_GRAPH_NODES ~w~n',[CustomID]),
    (var(Nodes) -> add_error(cg_node_predicate,'Variable custom_nodes: ',Nodes),fail ; true),
    get_node_attributes(Nodes,DefaultAttrs,NodeVal,Attributes),
    %tools:print_message(node(NodeVal,ColVal,Color,NodeID)),
    gen_id(NodeVal,NodeID). %tools:print_message(nodeid(NodeID)).

cg_trans_aux(Pair,DefaultLabelCol,Infos, FromNode,ToNode,[label/Label, color/Colour]) :-
    get_pair(Pair,From1,To2),!,
    trans_pred_aux(From1,DefaultLabelCol,Infos,To2,FromNode,ToNode,Label,Colour).

cg_trans_aux(Record,(DefaultLabel,DefaultCol),_Infos, FromNode,ToNode,Attrs) :-
    extract_record_fields(Record,_,DotAttrs,Vals),
    get_from_to(Vals,FromNode,ToNode),
    add_default_attrs([color/DefaultCol,label/DefaultLabel],DotAttrs,Attrs).

cg_trans_predicate(NodeID,SuccID,DotAttributes) :-
    custom_edges(DefaultLabel,_,Infos,Edges),
    (member(color/DefaultCol,Infos) -> true ; DefaultCol=blue),
    (var(Edges) -> add_error(trans_predicate,'Variable custom_edges: ',Edges),fail ; true),
    member(Edge,Edges),
    cg_trans_aux(Edge,(DefaultLabel,DefaultCol),Infos,FromNode,ToNode,Attrs),
    add_default_attrs(Infos,Attrs,DotAttributes),
    lookup_id(FromNode,source,NodeID),
    lookup_id(ToNode,target,SuccID).

checked_attribute(description).

checked_attribute(color).

checked_attribute(shape).

checked_attribute(style).

convert_to_field((string(FieldName),Value),field(FieldName,Value)).

deconstruct_node(((NodeVal,string(Shape)),ColVal),DefaultAttrs,ResNodeVal,Attrs,'$default_no_label') :-
    valid_dot_shape(Shape),
    !, % we have a triple (Node,"box","colour") = ((Node,"box"),"colour")
    ResNodeVal=NodeVal,
    translate_bvalue_to_colour(ColVal,ResColVal),
    add_default_attrs(DefaultAttrs,[color/ResColVal,shape/Shape],Attrs).

deconstruct_node((NodeVal,string(ColVal)),DefaultAttrs,ResNodeVal,Attrs,'$default_no_label') :-
    valid_rgb_color(ColVal),
    !, % we have a pair (Node,"colour")
    ResNodeVal=NodeVal,
    add_default_attrs(DefaultAttrs,[color/ColVal],Attrs).

deconstruct_node((NodeVal,string(Shape)),DefaultAttrs,ResNodeVal, Attrs,'$default_no_label') :-
    valid_dot_shape(Shape),
    !, % we have a pair (Node,"shape")
    ResNodeVal=NodeVal,
    add_default_attrs(DefaultAttrs,[shape/Shape],Attrs).

deconstruct_node(Record,DefaultAttrs,NodeVal,
    Attrs,Label) :-
    % New record style: this should probably be the default now
    extract_record_fields(Record,AllFields,DotAttributes,RemainingVals),
    DotAttributes = [_|_], % at least one field recognised
    ( RemainingVals = [field(_,NodeVal)] -> true
    ; member(field(value,NodeVal),RemainingVals) -> true
    ; member(field(id,NodeVal),RemainingVals) -> true % like in VisB / SVG; note is also a valid dot_attribute_field
    ; RemainingVals=[], member(label/_,DotAttributes)
    -> member(field(label,NodeVal),AllFields) % get original value before translation to string
    % but using label as node value may not be ideal for linking edges, better use separate value/id field
    ; RemainingVals \= [] -> add_warning(state_custom_dot_graph,'Node has no label or value field:',Record,Record),
    NodeVal = rec(RemainingVals)
    ),
    !,
    % add default values if not specified:
    ( select(label/LB,DotAttributes,Attrs0) -> Label=LB
    ; select(description/LB,DotAttributes,Attrs0) -> Label=LB
    ; Label = '$default_no_label', Attrs0=DotAttributes),
    add_default_attrs(DefaultAttrs,Attrs0,Attrs).

deconstruct_node(NodeVal,DefaultAttrs,NodeVal,Attrs,'$default_no_label') :-
    (DefaultAttrs=[]
    -> format('CUSTOM_GRAPH_NODES value not recognised:~w~nUse rec(label:L,shape:"rect",...)~n',[NodeVal])
    ; true % user has provided attributes in outer rec(...) construct
    ),
    add_default_attrs(DefaultAttrs,[],Attrs). % will remove none attributes

definitely_not_dot_attribute(edge).

definitely_not_dot_attribute(from).

definitely_not_dot_attribute(nodes).

definitely_not_dot_attribute(to).

definitely_not_dot_attribute(value).

definitely_not_dot_attribute(E) :- is_edges_field(E,_).

definitely_not_dot_attribute(N) :- is_nodes_field(N,_).

dot_attribute_field(colour,color).

dot_attribute_field(fontcolour,fontcolor).

dot_attribute_field(description,description). % virtual attribute

dot_attribute_field(stroke,style). % used in SVG

dot_attribute_field(Name,Name) :- is_dot_attribute(Name).

eval_custom_graph_function(GraphFunction,Nr,BState) :-
    eval_definition_fun(GraphFunction, Nr, graph, BState, GraphAttrs, rec(OtherFields)),
    exclude(process_nodes_field([],GraphFunction),OtherFields,Infos1),
    exclude(process_edges_field([],GraphFunction),Infos1,Infos2),
    % instead of passing [] above, we could auto-detect GraphAttrs which are node or edge attributes
    (Infos2 = [] ->
    (Infos1=[]
    -> add_message(state_custom_dot_graph,'No edges detected in CUSTOM_GRAPH: ',OtherFields,GraphFunction)
    ; true)
    ; add_warning(state_custom_dot_graph,'Unrecognized CUSTOM_GRAPH fields: ',Infos2,GraphFunction)),
    (custom_graph(_,_)
    -> add_warning(state_custom_dot_graph,'Duplicate CUSTOM_GRAPH definition: ',Nr,GraphFunction)
    ; assertz(custom_graph(Nr,GraphAttrs))
).

eval_definition_fun(AnimFunction, Nr, Kind, BState, SInfos, FunctionRes) :-
    b_compute_expression_nowf(AnimFunction,[],BState,FunctionResCl,'custom state graph',Nr),
    %nl, print('FunctionResult'(FunctionResCl)),nl,
    get_texpr_info(AnimFunction,Pos),
    extract_dot_function(FunctionResCl, Kind, Infos, FunctionRes,Pos),
    sort(Infos,SInfos).

eval_defs(BState) :-
    b_get_machine_custom_nodes_function(NodesFunction,Nr),
    eval_definition_fun(NodesFunction, Nr, nodes, BState, Infos, NodesRes),
    debug_println(19,custom_nodes(Nr,NodesRes)),
    (select(label/EFID,Infos,RestInfos)
    -> assertz(custom_nodes(EFID,Nr,RestInfos,NodesRes))
    ; get_texpr_id(NodesFunction,EFID)
    -> assertz(custom_nodes(EFID,Nr,Infos,NodesRes))
    ; % we cannot derive name, then generate one
    number_codes(Nr,NC), append("custom",NC,CC), atom_codes(Custom,CC),
    assertz(custom_nodes(Custom,Nr,Infos,NodesRes))),
    fail.

eval_defs(BState) :-
    b_get_machine_custom_edges_function(EdgesFunction,Nr),
    eval_definition_fun(EdgesFunction, Nr, edges, BState, Infos, EdgesRes),
    debug_println(19,custom_edges(Nr,EdgesRes)),
    (select(label/Label,Infos,RestInfos) -> true
    ; get_texpr_id(EdgesFunction,Label) -> RestInfos=Infos
    ; b_get_machine_custom_edges_function(_,Nr2), Nr2 \= Nr % other relation exists; makes sense to use label
    -> number_codes(Nr,NC), append("custom",NC,CC),
    atom_codes(Label,CC),RestInfos=Infos
    ; Label='',RestInfos=Infos
    ),
    assertz(custom_edges(Label,Nr,RestInfos,EdgesRes)),
    % print(edges(Label,Nr,RestInfos)),nl, translate:print_bvalue(EdgesRes),nl,nl,
    fail.

eval_defs(BState) :-
    b_get_machine_custom_graph_function(GraphFunction,Nr),
    format('Detected single CUSTOM_GRAPH DEFINITION ~w~n',[Nr]),
    eval_custom_graph_function(GraphFunction,Nr,BState),
    fail.

eval_defs(_).

extract_dot_function(Value,graph,Attributes,FunctionRes,Pos) :- !, % for CUSTOM_GRAPH
    extract_dot_graph_function(Value,Attributes,OtherFields,Pos),
    FunctionRes=rec(OtherFields). % list of fields

extract_dot_function((Label,Value),Kind,Info,FunctionRes,Pos) :- % treat e.g. == ("red","F",F)
    extract_dot_info(Label,Info,Info2),!,
    extract_dot_function(Value,Kind,Info2,FunctionRes,Pos).

extract_dot_function((Value,Label),Kind,Info,FunctionRes,Pos) :-
    extract_dot_info(Label,Info,Info2),!,
    extract_dot_function(Value,Kind,Info2,FunctionRes,Pos).

extract_dot_function(Record,Kind,DefaultDotAttributes,FunctionRes,Pos) :-
    % treat e.g. CUSTOM_GRAPH_NODES == rec(color:"blue", shape:"rect", nodes:e);
    % or CUSTOM_GRAPH_EDGES == rec(color:"red", style:"dotted", edges:e);
    % or CUSTOM_GRAPH_NODES == rec(color:"blue", label:"root", shape:"")
    extract_record_fields(Record,_,DotAttributes,Vals),
    !,
    ( select(field(ValAttr,Value),Vals,RestVals),
    member(ValAttr,[value, Kind]) % there is a value, edge, nodes field
    % this a record setting attributes for a set of nodes/edges
    -> DefaultDotAttributes = DotAttributes,
    try_expand_custom_set_with_catch(Value, FunctionRes,extract_dot_function),
    (RestVals=[] -> true ; add_message(state_custom_dot_graph,'Unrecognised DOT attributes: ',RestVals,Pos))
    ; member(label/_,DotAttributes) % in case we have a label this represents a single record
    -> FunctionRes = [Record], DefaultDotAttributes=[]
    ; add_message(state_custom_graph,'CUSTOM_GRAPH record not ok (use fields color,shape,style,description and either label, edges or nodes): ',Vals,Pos),
    fail
).

extract_dot_function(Value,_Kind,[],FunctionRes,_) :-
    % we try to see if it is a set of nodes (ideally as records) or edges
    try_expand_custom_set_with_catch(Value,FunctionRes,extract_dot_function),!.

extract_dot_function(Value,_Kind,_,_,Pos) :-
    add_warning(state_custom_dot_graph,'Illegal CUSTOM_GRAPH value (use rec(label:L,shape:,...) record or set of records): ',Value,Pos),
    fail.

extract_dot_graph_function(Record,Attributes,OtherFields,_) :-
    extract_record_fields(Record,_,Attributes,OtherFields),!.

extract_dot_graph_function(Value,_,_,Pos) :-
    add_warning(state_custom_dot_graph,'Illegal CUSTOM_GRAPH value, use record',Value,Pos),
    fail.

extract_dot_info((A,B),I0,I2) :- !, extract_dot_info(A,I0,I1), extract_dot_info(B,I1,I2).

extract_dot_info(string(Str),[Type/Str|T],T) :-
    (infer_string_type(Str,Type) -> true ; Type=label).

extract_dot_info(Value,[label/Str|T],T) :- simple_label_value(Value),
    translate_bvalue(Value,Str).

extract_info_from_fields([],[],[]).

extract_info_from_fields([field(FName,FVAL)|TF],[Type/Str|TI],Val) :-
    dot_attribute_field(FName,Type),!,
    ( \+ checked_attribute(Type) -> get_as_string_for_attr(Type,FVAL,Str)
    ; get_label_value(Type,FVAL,Str) -> true
    ; add_message(state_custom_dot_graph,'Unexpected value for dot attribute: ',Type/FVAL),
    get_as_string(FVAL,Str)
    ),
    extract_info_from_fields(TF,TI,Val).

extract_info_from_fields([field(FName,FVAL)|TF],[FName/EStr|TI],Val) :-
    \+ definitely_not_dot_attribute(FName),
    get_as_string(FVAL,Str),
    !,
    add_message(state_custom_dot_graph,'Assuming this is a dot attribute: ',FName/Str),
    string_escape(Str,EStr),
    extract_info_from_fields(TF,TI,Val).

extract_info_from_fields([F|TF],Info,[F|TVal]) :-
    extract_info_from_fields(TF,Info,TVal).

extract_record_fields(Record,Fields,DotAttributes,OtherFields) :-
    flexible_get_record_fields(Record,Fields),
    extract_info_from_fields(Fields,DotAttributes,OtherFields).

flexible_get_record_fields(rec(Fields),Res) :- !, Res=Fields.

flexible_get_record_fields(StringFunction,Fields) :-
    is_set_value(StringFunction,flexible_get_record_fields),
    try_expand_custom_set_with_catch(StringFunction,Expanded,get_visb_DEFINITION_svg_object),
    % TODO: check we have no duplicates
    maplist(convert_to_field,Expanded,Fields).

gen_graph(File) :-
    (custom_graph(_,GraphAttrs) -> true ; GraphAttrs=[]),
    temporary_set_preference(dot_print_self_loops,true,Chng), % the user provides the edges function explicitly, show all edges
    call_cleanup(gen_dot_graph(File,GraphAttrs,
    use_new_dot_attr_pred(state_custom_dot_graph:cg_node_predicate),
    use_new_dot_attr_pred(state_custom_dot_graph:cg_trans_predicate),
    dot_no_same_rank,dot_no_subgraph),
    reset_temporary_preference(dot_print_self_loops,Chng)).

gen_id(NodeVal,ID) :-
    (custom_node_id(NodeVal,ID) -> true
    ; get_ctr(C),
    assertz(custom_node_id(NodeVal,C)),ID=C).

gen_trans_color(Label,Col,_,IsColor) :- custom_trans_label(Label,C),!,Col=C,IsColor=false.

gen_trans_color(_Label,Col,Infos,IsColor) :- member(color/C,Infos),!,Col=C,IsColor=false.

gen_trans_color(Label,Col,_,IsColor) :- try_translate_bvalue_to_colour(Label,C),!,Col=C,IsColor=true.

gen_trans_color(Label,Col,_,IsColor) :- retract(trans_ctr(Ctr)), C1 is Ctr+1, assertz(trans_ctr(C1)),
    translate_bvalue_to_colour(int(Ctr),C),
    assertz(custom_trans_label(Label,C)), Col=C,IsColor=false.

get_as_id_string(string(SValue),Res) :- !, Res=SValue.

get_as_id_string((A,B),Res) :- !,
    get_as_id_string(A,VA), get_as_id_string(B,VB), atom_concat(VA,VB,Res).

get_as_id_string(FValue,Res) :- get_as_string(FValue,Res).

get_as_string(BValue,Str) :- to_b_string(BValue,string(Str)).

get_as_string_for_attr(id,Val,Str) :- !, get_as_id_string(Val,Str). % like SVG ids in VisB

get_as_string_for_attr(_,Val,Str) :- !, get_as_string(Val,Str).

get_color(string(Str),Val) :- !, Val=Str.

get_color(int(Nr),Val) :- !, Val=Nr. % numbers can be valid DOT colors when colorscheme provided

get_color(Val,Col) :-
    try_translate_bvalue_to_colour(Val,Col). % from dot_graph_generator

get_ctr(Res) :- retract(nodectr(C)),!, C1 is C+1, assertz(nodectr(C1)), Res=C.

get_ctr(0) :- assertz(nodectr(1)).

get_from_to(Vals,FromNode,ToNode) :- % either two field from:Fromnode, to:ToNode
    member(field(from,FromNode),Vals),!,
    member(field(to,ToNode),Vals).

get_from_to(Vals,FromNode,ToNode) :- % or a single edge field which is a pair
    member(field(edge,(FromNode,ToNode)),Vals),!.

get_label_value(label,Val,Str) :- !, get_as_string(Val,Str).

get_label_value(description,string(Str),Str).

get_label_value(Type,string(Str),Str) :- infer_string_type(Str,Type).

get_label_value(color,Val,Str) :- get_color(Val,Str).

get_node_attributes(CustomNodes,DefaultAttrs,NodeVal,[label/NodeDesc|Attrs]) :-
    %(member(style/DefStyle,DefaultAttrs) -> true ; DefStyle=filled), % to do: extract multiple styles
    %(member(shape/DefShape,DefaultAttrs) -> true ; DefShape=box),
    member(Node,CustomNodes),
    deconstruct_node(Node,DefaultAttrs,NodeVal,Attrs,Label),
    (Label\='$default_no_label' -> NodeDesc=Label
    ; translate_value_and_escape(NodeVal,NodeDesc) -> true
    ; NodeDesc = '???').

get_pair((From,To),From,To).

get_pair(Set,From,To) :- % process optional values, e.g., in Alloy
    singleton_set(Set,El), !, El = (From,To).

get_pair(avl_set(A),From,To) :- % process TLA+ tuples <> translated to -> {(1,From),(2,To)}
    animation_minor_mode(tla),
    try_expand_custom_set_with_catch(avl_set(A), FunctionRes,get_pair),
    FunctionRes = [(int(1),From),(int(2),To)].

get_state_for_graph(BState) :-
    current_expression(_CurID,State),
    state_corresponds_to_fully_setup_b_machine(State,BState),!.

get_state_for_graph(_) :- % we could look at type of definitions and use get_current_state_for_b_formula
    add_error_and_fail(state_custom_dot_graph,'Only possible for initialised B machine.').

get_trans_label((From,string(LabelVal)),From,ELabel) :- string_escape(LabelVal,ELabel).

get_trans_label(From,From,''). % or should we use DefaultLabel

get_trans_label_and_color((FromVal,LabelVal),Infos,From,Color,ELabel) :-
    gen_trans_color(LabelVal,Color,Infos,IsColor),
    (IsColor
    -> get_trans_label(FromVal,From,ELabel)
    ; translate_value_and_escape(LabelVal,ELabel),
    From=FromVal
).

infer_string_type(Str,color) :- valid_rgb_color(Str).

infer_string_type(Str,shape) :- valid_dot_shape(Str).

infer_string_type(Str,style) :- valid_dot_line_style(Str).

infer_string_type(Str,style) :- valid_dot_node_style(Str).

is_edges_field(edges,0).

is_edges_field(edges0,0).

is_edges_field(edges1,1).

is_edges_field(edges2,2).

is_edges_field(edges3,3).

is_edges_field(edges4,4).

is_edges_field(edges5,5).

is_edges_field(edges6,6).

is_edges_field(edges7,7).

is_edges_field(edges8,8).

is_edges_field(edges9,9).

is_nodes_field(nodes,0).

is_nodes_field(nodes0,0).

is_nodes_field(nodes1,1).

is_nodes_field(nodes2,2).

is_nodes_field(nodes3,3).

is_nodes_field(nodes4,4).

is_nodes_field(nodes5,5).

is_nodes_field(nodes6,6).

is_nodes_field(nodes7,7).

is_nodes_field(nodes8,8).

is_nodes_field(nodes9,9).

is_valid_custom_dot_graph_record(b(rec(Fields),_,_)) :-
    member(field(NodesField,_),Fields), is_nodes_field(NodesField,_),!,
    member(field(EdgesField,_),Fields), is_edges_field(EdgesField,_),!.

lookup_id(NodeVal,Kind,ID) :-
    (custom_node_id(NodeVal,ID)
    -> true
    ; get_as_string(NodeVal,VS),
    format(user_error,'The ~w node does not exist in CUSTOM_GRAPH_NODES: ~w~n',[Kind,VS]),
    %format('Internal value: ~w~n',[NodeVal]), portray_nodes,
    string_escape(VS,VSC),
    assertz(custom_node_id(NodeVal,VSC)),
    ID=VSC
).

nodectr(0).

none_valid(arrowhead).

none_valid(arrowtail).

portray_nodes :- format(' ~w : ~w (~w)~n',['ID','Value','internal value']),
    custom_node_id(NodeVal,ID),
    translate_bvalue(NodeVal,NS),
    format(' ~w : ~w (~w)~n',[ID,NS,NodeVal]),fail.

portray_nodes.

process_edges_field(DefaultAttrs,Span,field(EdgesField,Edges)) :-
    is_edges_field(EdgesField,Nr),
    assert_custom_edges2(Edges,DefaultAttrs,Span,Nr).

process_nodes_field(DefaultAttrs,Span,field(NodeField,Nodes)) :-
    is_nodes_field(NodeField,Nr),
    assert_custom_nodes2(Nodes,DefaultAttrs,Span,Nr).

reset_custom_defs :-
    retractall(custom_nodes(_,_,_,_)),
    retractall(custom_edges(_,_,_,_)),
    retractall(custom_graph(_,_)),
    retractall(custom_node_id(_,_)), retractall(nodectr(_)),
    retractall(custom_trans_label(_,_)), retractall(trans_ctr(_)), assertz(trans_ctr(1)).

simple_label_value(fd(_,_)).

state_custom_dot_graph_available :-
    b_get_machine_custom_graph_function(_,_) ;
    % b_get_machine_custom_nodes_function(_,_) ;
    b_get_machine_custom_edges_function(_,_).

tcltk_generate_state_custom_dot_graph(File) :-
    get_state_for_graph(BState),
    (state_custom_dot_graph_available
    -> true
    ; add_error_and_fail(tcltk_generate_state_custom_dot_graph,
    'No CUSTOM_GRAPH_EDGES or CUSTOM_GRAPH Function in DEFINITIONS')),
    reset_custom_defs,
    start_ms_timer(Timer),
    eval_defs(BState),
    gen_graph(File),
    stop_ms_timer_with_msg(Timer,'custom graph: ').

tcltk_generate_state_custom_dot_graph_for_expr(GraphFunction,File) :-
    get_current_state_for_b_formula(GraphFunction,BState),
    extend_state_with_probids_and_lets(BState,BState1),
    reset_custom_defs,
    eval_custom_graph_function(GraphFunction,0,BState1),
    gen_graph(File).

trans_ctr(1).

trans_pred_aux((From,To),(Label,_Col),_Infos,string(Colour),From,To,Label,Colour) :-
    To \= string(_), % we are not in one of the cases below where To is a label
    valid_rgb_color(Colour),!.

trans_pred_aux(FromValue,_Defaults,Infos,To,From,To,ELabel,Color) :-
    % format(user_output,'from: ~w~nto: ~w~n~n',[FromValue,To]),
    % ((From,LabelCol) |-> To) case
    get_trans_label_and_color(FromValue,Infos,From,Color,ELabel), % the From Value contains color and label
    !.

trans_pred_aux(From,_Defaults,Infos,(LabelVal,ToVal),From,To,ELabel,Color) :-
    % (From |-> (LabelCol,To)) case
    get_trans_label_and_color((ToVal,LabelVal),Infos,To,Color,ELabel), % the To Value contains color and label
    !.

trans_pred_aux(From,(Label,Col),_Infos,To,From,To,Label,Col).

translate_value_and_escape(string(S),ELabel) :- !, string_escape(S,ELabel).

translate_value_and_escape(LabelVal,ELabel) :-
    translate:translate_bvalue(LabelVal,Label),string_escape(Label,ELabel).