% backtracking
% ==========================================

stateG(S) :- member(S, [a,b,c,d,e,f,g]).
nextG(a, b).
nextG(a, e).
nextG(b, c).
nextG(b, d).
nextG(d, a). % recursive
nextG(e, f).
nextG(e, g).
initialG(a).
finalG(f).
finalG(g).
problemG(problem(initialG, nextG, finalG)).

initial(Problem, Initial) :- Problem=problem(InitialPred, _, _),
    call(InitialPred, Initial).
final(Problem, Final) :- Problem=problem(_, _, FinalPred), call(FinalPred, Final).
next(Problem, S, SNext) :- Problem=problem(_, NextPred, _), call(NextPred, S, SNext).

% perspectivă declarativă
% Path cale între starea [initială] si o stare finală
% onPath adevarat pentru o stare si calea dintre stare si o stare finala
onPath(Pb, S, [S]) :- final(Pb, S).
onPath(Pb, S, [S|Path1]) :- next(Pb, S, S1), onPath(Pb, S1, Path1).
% path adevarat pentru o cale dintre starea initiala si o stare finala
path(Pb, Path) :- initial(Pb, Si), onPath(Pb, Si, Path).

% perspectiva algoritmica
%
search(Pb, S, [S]) :- final(Pb, S).
% solutie construita *pe intoarcerea* din recursivitate
search(Pb, S, [S | SolNext]) :- next(Pb, S, SNext), search(Pb, SNext, SolNext).
%search(Pb, S, Sol) :- next(Pb, S, SNext), search(Pb, SNext, SolNext),
%    Sol=[S | SolNext].
search(Pb, Sol) :- initial(Pb, Si), search(Pb, Si, Sol).

searchR(Pb, S, Visited, [S]) :- final(Pb, S), write(Visited).
% solutie construita *pe intoarcerea* din recursivitate
% lista de noduri vizitate este construita *pe avansul* in recursivitate
searchR(Pb, S, Visited, [S | SolNext]) :-
    next(Pb, S, SNext),
    \+ member(SNext, Visited),
    searchR(Pb, SNext, [SNext|Visited], SolNext).
searchR(Pb, Sol) :- initial(Pb, Si), searchR(Pb, Si, [Si], Sol).



% search(_, a, Sol)
%   ...
%   next(a, e), search(_, e, SolNext1)
%     next(e, f), search(_, f, SolNext2)
%       SolNext2=[f]
%     SolNext=[e|[f]]=[e,f]
%   Sol=[a|[e,f]]=[a,e,f]
%