%% la_strings.pl

:- dynamic html_api_maker_or_terminal/1.

use_module(library(pio)).
use_module(library(dcg/basics)).

string_strings(S,S1) :-
	string_chars(S,S2),
	findall(S3,(member(S4,S2),atom_string(S4,S3)),S1),!.

get_until_char(S,C,Cs1,Left1) :-
	string_strings(S,S1),
	append(Cs,B,S1),(is_list(C)->C1=C;	string_strings(C,C1)),
	append(C1,Left,B),
	foldr(string_concat,Cs,Cs1),
	foldr(string_concat,Left,Left1),
	!.
get_until_char(S,_C,S,"") :- !.

open_s(File,Mode,Stream) :-
	atom_string(File1,File),
	open(File1,Mode,Stream),!.

string_atom(String,Atom) :-
	atom_string(Atom,String),!.

phrase_from_file_s(string(Output), String) :-
	atom_string(String1,String),
	phrase_from_file(string(Output), String1),!.
	
writeln0(Term) :-
	%term_to_atom(Term,Atom),
%append([Term],["\n"],Term1),	
	%append_retry_back_stack([text,Term1]),!.
	(html_api_maker_or_terminal(html)->
	(%term_to_atom(Term,Atom),
	writeln(Term%Atom%,[]
	)
	,format('<br>\n',[]));
	writeln(Term)),!.
	
write0(Term) :-
	%term_to_atom(Term,Atom),
	%append_retry_back_stack([text,Term])
	(html_api_maker_or_terminal(html)->
	(%term_to_atom(Term,Atom),
	format(Term,[])%,format('\n',[])
	);
	write(Term)),!.

writeln1(Term) :-
	term_to_atom(Term,Atom),
	
%atom_concat(Atom,"\n",Atom1),
	%append_retry_back_stack([text,Atom1]),!.
	(html_api_maker_or_terminal(html)->
	(%term_to_atom(Term,Atom),
	format(Atom,[]),format('<br>\n',[]));
	writeln(Atom)),!.
	
	%writeln(Atom),!.
	
write1(Term) :-
/*
	term_to_atom(Term,Atom),
	append_retry_back_stack([text,Atom]),!.
	%write(Atom),!.
	*/
	term_to_atom(Term,Atom),
	
%atom_concat(Atom,"\n",Atom1),
	%append_retry_back_stack([text,Atom1]),!.
	(html_api_maker_or_terminal(html)->
	(%term_to_atom(Term,Atom),
	format(Atom,[])%,format('\n',[])
	);
	write(Atom)),!.




n_to_br(Term,Term1) :-
	sub_term_types_wa([string,atom],Term,Instances),
	findall([Add,X],(member([Add,X1],Instances),
	atomic_list_concat(A,'\n',X1),
	atomic_list_concat(A,'<br>',X2),	
	(atom(X1)
	->X2=X;(atom_string(X2,X4)),X4=X%,term_to_atom(X4,X)
	)),X3),
	foldr(put_sub_term_wa_ae,X3,Term,Term1),!.

writeln_br(Term) :-	
	(html_api_maker_or_terminal(html)->
	(n_to_br(Term,Term1),
	%term_to_atom(Term1,Atom),
	write(Term1),write('<br>\n'));
	(%term_to_atom(Term,Atom),
	writeln(Term))),!.

write_br(Term) :-	
	(html_api_maker_or_terminal(html)->
	(n_to_br(Term,Term1),
	%term_to_atom(Term1,Atom),
	write(Term1));
	(%term_to_atom(Term,Atom),
	write(Term))),!.
	
	
shell1_s(Command,Out) :-
 	atom_string(Command1,Command),
	bash_command(Command1,Out),
	%not(Out=user:fail),
	!.
		
shell1_s(Command) :-
 	atom_string(Command1,Command),
	shell1(Command1),!.
	
shell1(Command) :-
				(bash_command(Command,_)->
					true;
					(writeln0(["Failed shell1 command: ",Command]),abort)
				),!.

bash_command(Command, Output) :-
        setup_call_cleanup(process_create(path(bash),
                ['-c', Command],
                [stdout(pipe(Out))]),
        read_string(Out, _, Output),
        close(Out)),!.

foldr(string_concat,[A,B,C],D) :-
	not(var(A)),var(B),not(var(C)),
	string_concat(A,G,D),
	string_concat(B,C,G),!.
	
% aBc=abc	
foldr(string_concat1,ABC,D) :-
	findall(E,(member(E,ABC),var(E)),E1),
	length(E1,1),not(var(D)),
	member(V,ABC),var(V),!,
	sub_term_types_wa([var],ABC,[[Ad,_]]),
	(string(D)->string_strings(D,D11);atom_chars(D,D11)),
	%trace,
	findall(M,(member(M1,D11),(catch(number_string(M,M1),_,false)->true;M=M1)),M2),
	get_sub_term_wa(M2,Ad,V),!.
	
/*
foldr(string_concat2,["a","b",C,D,E,"f"],"abcdef").

C = D, D = "",
E = "cde" ;
C = "",
D = "c",
E = "de" ;
C = "",
D = "cd",
E = "e" ;
C = E, E = "",
D = "cde" ;
C = "c",
D = "",
E = "de" 
...
*/
	
foldr(string_concat2,ABC,D) :-
	findall(E,(member(E,ABC),var(E)),E1),
	length(E1,3),
	not(var(D)),
	sub_term_types_wa([var],ABC,[[Ad1,_],[Ad2,_],[Ad3,_]]),
	Ad1=[_,N1],Ad2=[_,N2],N2 is N1+1,Ad3=[_,N3],N3 is N2+1,
	(string(D)->string_strings(D,D11);atom_chars(D,D11)),
	findall(M,(member(M1,D11),(catch(number_string(M,M1),_,false)->true;M=M1)),M2),
	%findall(L,(member(L1,ABC),(var(L1)->L=L1;L=[L1])),L2),
	
	N4 is N1-1,
	length(N4L,N4),
	length(N4L1,N4),
	N5 is 3,
	length(N5L,N5),
	length(N5L1,N5),
	append(N4L,N6,M2),
	append(N5L,_,N6),

	append(N4L1,N61,ABC),
	append(N5L1,_,N61),

	append(V1,V4,N5L),
	append(V2,V3,V4),

	foldr(string_concat,V1,V11),
	foldr(string_concat,V2,V21),
	foldr(string_concat,V3,V31),	
	N5L1=[V11,V21,V31].
	

foldr(Function,A,L,B) :-
	reverse(A,C),
	foldl(Function,C,L,B),!.

foldr(append,A,B) :-
	foldr(append,A,[],B),!.
	
%foldr(append1,A,B) :-
%	foldr(append1,A,[],B),!.
	
foldr(string_concat,A,B) :-
	foldr(string_concat,A,"",B),!.

foldr(atom_concat,A,B) :-
	foldr(atom_concat,A,'',B),!.

concat_list_terms(A,B) :-
	findall(X,(member(X1,A),((string(X1)->true;(atom(X1)->true;number(X1)))->X=X1;term_to_atom(X1,X)%,term_to_atom(X2,X)
	)),A1),
	concat_list(A1,B),!.
	
concat_list([],""):-!.
concat_list(A1,B):-
	%A1=[A|List],
	concat_list("",A1,B),!.

concat_list(A,List,B) :-
	concat_list1(A,List,B).
	%string_codes(B,B1),!.

concat_list1(A,[],A):-!.
concat_list1(A,List,B) :-
	List=[Item|Items],
	%string_codes(Item,Item1),
	string_concat(A,Item,C),
	concat_list1(C,Items,B).

atom_concat_list([],''):-!.
atom_concat_list(A1,B):-
	%A1=[A|List],
	atom_concat_list([],A1,B),!.

atom_concat_list(A,List,B) :-
	atom_concat_list1(A,List,B1),
	atom_codes(B,B1),!.

atom_concat_list1(A,[],A):-!.
atom_concat_list1(A,List,B) :-
	List=[Item|Items],
	atom_codes(Item,Item1),
	append(A,Item1,C),
	atom_concat_list1(C,Items,B).

append_list(A1,B):-
	%A1=[A|List],
	append_list([],A1,B),!.

append_list(A,[],A):-!.
append_list(A,List,B) :-
	List=[Item|Items],
	append(A,[Item],C),
	append_list(C,Items,B).

append_list2([],[]):-!.
append_list2(A1,B):-
	%A1=[A|List],
	append_list2([],A1,B),!.

append_list2(A,[],A):-!.
append_list2(A,List,B) :-
	List=[Item|Items],
	append(A,Item,C),
	append_list2(C,Items,B).

list1(A,_,_) :-
	(A=[_|_]->true;A=[]),!.
	
	% splits after !,?,.

/*	
split_string17(String1,List) :-
	%string_codes(String2,String1),
	test(17,_,Code,_),
	%trace,
	%writeln1([interpret(off,[[n,grammar1],[String1,Chars,[v,t]]],
	%	Code,A)]),
	interpret(off,[[n,grammar1],[String1,[v,t]]],
		Code,[[[[v,t],List]]]),!.
*/

% split_string1(Docs,["`"],Input1) - splits and deletes on chars

split_string(A,B,C) :-
	split_string(A,B,B,C),!.
	
split_string1a(String1,Chars,List) :-
	%string_codes(String2,String1),
	test(116,_,Code,_),
	%trace,
	%writeln1([interpret(off,[[n,grammar1],[String1,Chars,[v,t]]],
	%	Code,A)]),
	interpret(off,[[n,grammar1],[String1,Chars,[v,t]]],
		Code,[[[[v,t],List]]]),!.

/**
?- split_string2("a   a",[" "],A).
A = ["a", " ", " ", " ", "a"].
**/

split_string2(String1,Chars,List) :-
	%string_codes(String2,String1),
	test(117,_,Code,_),
	%trace,
	%writeln1([interpret(off,[[n,grammar1],[String1,Chars,[v,t]]],
	%	Code,A)]),
	interpret(off,[[n,grammar1],[String1,Chars,[v,t]]],
		Code,[[[[v,t],List]]]),!.

% ?- join_chars_after(["d","e","a","c","f","b","g"],["a","b"],[],L).
% L = ["d", "ea", "c", "fb", "g"].

join_chars_after([],_Chars,List,List) :- !.
join_chars_after([List1],_Chars,List2,List3) :-
	append(List2,[List1],List3),!.
join_chars_after(List1,Chars,List5,List2) :-
	List1=[Char1,Char2|List3],
	member(Char2,Chars),
	string_concat(Char1,Char2,Char3),
	append([Char3],List3,List4),
	join_chars_after(List4,Chars,List5,List2),!.
join_chars_after(List1,Chars,List5,List2) :-
	List1=[Char1,Char2|List3],
	not(member(Char2,Chars)),
	append([Char2],List3,List4),
	append(List5,[Char1],List6),
	join_chars_after(List4,Chars,List6,List2),!.

% split_on_substring117a("AAABAAD","BD",[],A).
% A = ["AAA", "B", "AA", "D"].

split_on_substring117a(A,B,_,D) :-
    string_codes(A,A1),
    string_codes(B,B1),
	split_on_substring117(A1,B1,[],D),!.

% split_on_substring117a("AAABAAD","BD",A).
% A = ["AAA", "B", "AA", "D"].

split_on_substring117a(A,B,C) :-
	split_on_substring117a(A,B,_,C),!.


% split_on_substring117(`AAABAAD`,`BD`,[],A). or
% ?- split_on_substring117([65,65,65,66,65,65,68],[66,68],[],A).
% A = ["AAA", "B", "AA", "D"].

split_on_substring117([],_A,E,E) :- !.
split_on_substring117(A,B2,E,C) :-
    intersection(A,B2,[]),
    string_codes(E1,E),
    string_codes(A1,A),
    concat_list([E1,A1],C2),
    append_list([C2],C),
    !.
split_on_substring117(A,B2,E,C) :-
    member(B,B2),
    append([B],D,A),
    %trace,
    split_on_substring117(D,B2,[],C1),
    string_codes(E1,E),
    string_codes(B1,[B]),
    %trace,
    (E1=""->maplist(append,[[[B1],C1]],[C]);
    (%trace,
    maplist(append,[[[E1,B1],C1]],[C]))),
    !.
split_on_substring117(A,B,E1,C) :-
    length(E,1),
    append(E,D,A),
    append(E1,E,E2),
    split_on_substring117(D,B,E2,C),!.

num_chars(Char,Num1,String) :-
	numbers(Num1,1,[],Nums),
	findall(Char,(member(_Num2,Nums)),Chars),
	concat_list(Chars,String),!.
	
/*
replace_new('0ab0','a','c',A).
A = "0cb0".
*/

replace_new(A1,Find,Replace,F) :-
string_length(Replace,Replace_l),
string_concat("%",A1,A2),
string_concat(A2,"%",A),		split_string(A,Find,Find,B),findall([C,Replace],(member(C,B)),D),maplist(append,[D],[E]),concat_list(E,F1),string_concat(F2,G,F1),string_length(G,Replace_l),
	string_concat("%",F3,F2),	
	string_concat(F,"%",F3),!.


% find_first(B,(member(B,[true,false]),B),D).
% D = [true] .
find_first(A) :-
 A,!.

/*
find_first(A,B,B_condition,C) :-
 D = (B,(B_condition->!;fail)),findall(A,D,C1),
 (C1=[C|_]->true;C=[]),!.
*/

% findall_until_fail(B,member(B,[true,true,false,true]),B,D).
% D = [true,true] .

findall_until_fail(A,B,B_condition,C) :-
	D=(B,(B_condition->true;(!,fail))),
	findall(A,D,C),!.
	
find_until(A,B,C) :-
	append(C,B4,A),
	append([B],_C4,B4),!.

% repeat_until_the_same(A=1,A,B is A+1,B,C).
% A=1,B = 2.

/*
repeat_until_the_same(A,Value,B_initial,B,B_result) :-
	%copy_term(B,B1),
	A=Value,
	%A_initial_assignment,
	repeat_until_the_same1(A,B_initial,B,B_result),!.
repeat_until_the_same1(A,B_initial,B,B_result2) :-
	%copy_term(A,A1),
	copy_term(B_initial,B_initial1),
	copy_term(B,B1),
	copy_term(B,B2),
	copy_term(B_result,B_result1),
	A=B_initial,B1,(A=B_result->B_result=B_result2;(repeat_until_the_same1(A,B_initial1,B2,B_result2))),!.
*/

% repeat_until_the_same(A,1,(C=1,writeln(C)),C). 
% A = C, C = D.

% repeat_until_the_same(A,1,(random(X),C is floor(3*X),writeln(C)),C).
% 0
% 2
% 1
% A = E, E = C, C = 1,
% X = 0.5791569817112253.

/*
repeat_until_the_same(A,Value,B,B_res_var) :-
	repeat_until_the_same1(A,Value,B_res_var,B,B_res_var,B_res_var),!.

repeat_until_the_same1(A1,Value,Value,B,B_res_var,B_res_var1) :-
	copy_term(A,A1),
	A=Value,
	B,(B_res_var=B_res_var1->
	true;
	repeat_until_the_same1(A1,Value,B_res_var,B,B_res_var,B_res_var1)),!.



% repeat_until_the_same(A,1,((A=1->A2=2;A2=1),writeln(A2)),A2).
% repeat until the last two results are the same.

repeat_until_the_same(A,Value,B,B_res_var) :-
	copy_term(A,A_new),
	copy_term(B,B_new),
	A=Value,
	B,
	repeat_until_the_same1(B_new,A_new,%A,
	A,Value,B_res_var,B,B_res_var,B_res_var),!.

repeat_until_the_same1(B_new,A_new,%A,
A,Value,Value,B,B_res_var,B_res_var1) :-
	copy_term(A,A1),
	copy_term(A_new,A_new1),
	copy_term(A_new,A_new2),
	copy_term(B_new,B_new1),
	A_new=Value,
	B_new,(B_res_var=B_res_var1->
	true;
	repeat_until_the_same1(B_new1,A_new2,%A2,
	A1,Value,B_res_var,B,B_res_var,B_res_var1)),!.
*/

% repeat_until_last_two_same(generate_result(Result),Result,Result1).
		
% to do: initial values, more result vars		

%repeat_until_last_two_same(Pred,Pred_res_var,Result) :-
%   repeat_until_last_two_same(Pred,Pred_res_var, _,_, Result),!.

/*
repeat_until_last_two_same(Pred,Pred_res_var,A, B, Result) :-
	functor(Pred,Name,Arity),
	functor(Pred_new,Name,Arity),
	copy_term(Pred_res_var,Pred_res_var_new),
	%copy_term(Pred_new,Pred_new1),
	%copy_term(Pred_new,Pred_new2),
	% Generate some result
    (Pred,%generate_result(Result1),
    (%false%var(Pred_res_var)
    %->%var(B)
    
    %(
        %repeat_until_last_two_same(Pred_new1,Pred_res_var,B,Pred_res_var, Result);
        
% repeat_until_last_two_same(Result1).
		
% to do: initial values, more result vars		

* put into shell command to work with other Prolog predicate arguments

        */

repeat_until_last_two_same(Result) :-
   repeat_until_last_two_same(_, Result),!.
        
  	repeat_until_last_two_same(B, Result) :-
    % Generate some result
    generate_result(Result1),
    % Check if the last two results are the same
    (   ((var(B)->fail;true),
    Result1 = B, B = Result)->true;
    % If not, continue repeating
       repeat_until_last_two_same(Result1, Result)
    ),!.    


/*
%	repeat_until_last_two_same(generate_result(Result1),Result1,R).
    repeat_until_last_two_same( Pred, Result_var, Result) :-
	    repeat_until_last_two_same1(Pred, Result_var,_, Result),!.
    repeat_until_last_two_same1(Pred, Result_var, B, Result) :-
    %copy_term(Result_var,Result_var0),
    functor(Result_var,Name,Arity),
	functor(Result_var0,Name,Arity),

    % Generate some result
    Pred,%generate_result(Result1),
    % Check if the last two results are the same
    (   ((var(B)->fail;true),
    Result_var = B, B = Result)->true;
    % If not, continue repeating
       repeat_until_last_two_same1(Pred, Result_var0,Result_var, Result)
    ),!.    

% Predicate to generate a result (replace this with your actual computation)
*/
generate_result(Result) :-
    % For example, generating a random integer between 1 and 100
    random(1, 3, Result),
    writeln(Result).

%not(A) :- \+(A),!.

% Doesn't delete \n in "\n"
split_on_substring1(A,B,D) :-
	string_codes(A,A1),
	string_codes(B,B1),
	split_on_substring117(A1,B1,[],D),!.

% Deletes \n in "\n"
split_on_substring(A,B,_,D) :-
	split_on_substring(A,B,D),!.
		
split_on_substring(A,B,D) :-
	string_codes(A,A1),
	string_codes(B,B1),
	split_on_substring117(A1,B1,[],D1),
	(D1=[]->D2=[""];D1=D2),
	%D2=D,%delete_double_newlines(D2,[],D),
	append(_D6,B4,D2),
	append([B5],_C4,B4),
	not(B5="\n"),
	delete_newlines_after_text(B4,[],D),!.
	
split_string1(A,B,C) :-
	split_string1(A,B,_,C),!.
	
split_string1(A,B,_,C) :-
	%string_strings(B,B2),
	split_on_substring(A,B,C),
	%findall(D,(member(D1,C1),(member(D1,B2)->D="";D=D1)),C),
	!.
	
split_string1b(A,B,C) :-
	split_string1b(A,B,_,C),!.
	
split_string1b(A,B,_,C) :-
	string_strings(B,B2),
	split_on_substring(A,B,C1),
	findall(D,(member(D1,C1),(member(D1,B2)->D="";D=D1)),C),!.
	
delete_newlines_after_text([],A,A) :- !.
delete_newlines_after_text([A],B,C) :- 
	append(B,[A],C),!.
delete_newlines_after_text(D2,D1,D) :-
	D2=[T,"\n"|D4],
	append(D5,B4,D4),
	append([B],_C4,B4),
	not(B="\n"),
	length(D5,L),
	numbers(L,1,[],Ns),
	findall("",member(_,Ns),D51),
	foldr(append,[D1,[T],D51],D6),
	delete_newlines_after_text(B4,D6,D),!.
delete_newlines_after_text(D2,D1,D) :-
	D2=[T|D4],
	%append(D5,B4,D4),
	%append([B],_C4,B4),
	%not(B="\n"),
	foldr(append,[D1,[T]],D6),
	delete_newlines_after_text(D4,D6,D),!.

/*
delete_double_newlines([],D,D) :- !.
delete_double_newlines(D2,D5,D) :-
	trace,
	D2=["\n","\n"|D4],
	append(D5,["\n"],D6),
	delete_double_newlines(D4,D6,D),!.
delete_double_newlines(D2,D5,D) :-
	trace,
	D2=["\n"|D4],
	append(D5,[],D6),
	delete_double_newlines(D4,D6,D),!.
delete_double_newlines(D2,D5,D) :-
	D2=[D3|D4],
	append(D5,[D3],D6),
	delete_double_newlines(D4,D6,D),!.
*/

retract_all(A) :- retractall(A).

remove_dups([],[]) :- !.
remove_dups([Head|Tail],Result):-
 member(Head,Tail),
 remove_dups(Tail,Result),!.
remove_dups([Head|Tail],[Head|Result]):-
 remove_dups(Tail,Result),!.