csp_sequences

app1([],Y,R) :- !,Y=R.

app1([H|X],Y,R) :- !,R=[H|Z], app1(X,Y,Z).

app1(X,Y,Z) :- add_internal_error(/*csp_sequences,*/'Unexpected arguments to append: ',app1(X,Y,Z)),fail.

append_list(listFrom(F),_,Res) :- !, Res=listFrom(F).

append_list(listFromTo(F,T),Y,Res) :- expand_sequence(Y,list(EY)),!, Res=list(ZL),
    expand_seq_from_to(F,T,EX), app1(EX,EY,ZL).

append_list(list(XL),Y,list(ZL)) :- expand_sequence(Y,list(YL)),!,
    app1(XL,YL,ZL).

append_list(X,Y,Z) :-
    translate_csp_value(X,TX),translate_csp_value(Y,TY),
    (var(Z) -> ajoin([TX,' ^ ',TY],Text)
    ; translate_csp_value(Z,TZ), ajoin([TX,' ^ ',TY,' = ', TZ],Text)),
    add_error(csp_sequences,'Illegal arguments for sequence catenation ^ : ',Text),fail.

conc([],Res) :- !, Res=[].

conc([HL|X],Res) :- expand_sequence(HL,list(H)),!,
    conc(X,RX), app1(H,RX,Res).

conc(X,Y) :-
    add_error(csp_sequences,'Unexpected arguments to conc:',conc(X,Y)),fail.

concat_lists(X,Y) :-
    ((X=list(XL),Y=list(YL))
    -> conc(XL,YL)
    ; add_error(csp_sequences,'Unexpected arguments to concat of sequences: ',concat(X,Y)),fail
).

convert_seq_to_set(listExp(E,GeneratorList),Res) :- !,
    expand_sequence(listExp(E,GeneratorList),list(ESeq)),
    evaluate_set(ESeq,Res).%evaluate_set(ESeq,Res,evaluate_argument).

convert_seq_to_set(listFromTo(X,Y),Res) :- !, Res = setFromTo(X,Y).

convert_seq_to_set(listFrom(X),Res) :- !, Res = setFrom(X).

convert_seq_to_set(list(L),Res) :- !, evaluate_set(L,Res).%evaluate_set(L,Res,evaluate_argument).

convert_seq_to_set(X,_R) :- add_error(csp_sequences,'Unexpected argument for the seq(-) built-in function: ',X),fail.

convert_set_to_seq(setExp(E,Generators),Res) :- !,
    expand_set_comprehension(E,Generators,setValue(R)),
    %print(expand_set(Generators,E,R)),nl,
    Res=list(R).

convert_set_to_seq(setFromTo(X,Y),Res) :- !, Res = listFromTo(X,Y).

convert_set_to_seq(setFrom(X),Res) :- !, Res = listFrom(X).

convert_set_to_seq(setValue(S),Res) :- !, Res = list(S).

convert_set_to_seq(X,_R) :- add_error(csp_sequences,'Unexpected argument for the set(-) built-in function: ',X),fail.

elem([H|T],E) :- (E=H ; (/*dif(E,H),*/elem(T,E))).

expand_listcomprehension(RangeExpr,GeneratorList,Res) :-
    %% print(expand_listComp(RangeExpr,GeneratorList)),nl,
    csp_sets:extract_variables_from_generator_list(GeneratorList,Vars),
    term_variables(GeneratorList,GVars),
    remove_variables(GVars,Vars,WaitVars),
    when(ground(WaitVars), (
    %print(waitVars(WaitVars)),nl,
    findall(EExpr,(treat_list_generators(GeneratorList,Vars,Seqs,Guard),
    %% print(treated_generators(Vars,Sets,Guard)),nl,
    haskell_csp:check_boolean_expression(Guard),
    generator_list_sol(Vars,Seqs),
    csp_sets:member_range_expr(RangeExpr,EExpr)),Expressions),
    Res=list(Expressions)
%,print(expanded(Res)),nl
)).

expand_seq_from_to(X,Y,R) :- X>Y,!, R=[].

expand_seq_from_to(X,Y,[int(X)|T]) :- X1 is X+1, expand_seq_from_to(X1,Y,T).

expand_sequence(list(X),Res) :- !, Res=list(X).

expand_sequence(listFromTo(X,Y),Res) :- !, Res=list(R),expand_seq_from_to(X,Y,R).

expand_sequence(listExp(RangeExpr,GeneratorList),R) :- !,
    expand_listcomprehension(RangeExpr,GeneratorList,R).

expand_sequence(listFrom(X),_R) :- !,
    translate_csp_value(X,TX),
    add_error(csp_sequences,'Trying to expand infinite list: ',TX),fail.

expand_sequence(X,_Y) :-
    translate_csp_value(X,TX),
    add_error(csp_sequences,'Illegal argument, this is not a list: ',TX),fail.

generator_list_sol([],[]).

generator_list_sol([Var|VT],[Seq|ST]) :-
    force_evaluate_argument(Seq,EvSeq),expand_sequence(EvSeq,ESeq),
    (ground(ESeq) -> true ; add_error(expand_set_comprehension,'Non-ground Seq: ',Seq)),
    is_elem_list(Var,ESeq), generator_list_sol(VT,ST).

head_list(listFrom(F),Res) :- !, Res=int(F).

head_list(listFromTo(F,T),Res) :- number(F),number(T), T >=F, !, Res=int(F).

head_list(List,Res) :-
    (List=list([H|_T]) -> Res = H
    ; (add_error(csp_sequences,'Unexpected argument to head of sequence: ',List),fail)).

is_elem_list(E,X) :-
    (X=list(Y)
    -> elem(Y,E)
    ; X=listFrom(F) -> E=int(EV), mygeq(EV,F)
    ; X=listFromTo(F,T) -> E=int(EV), mygeq(EV,F), mygeq(T,EV)
    ; add_error(csp_sequences,'Unexpected argument to elem: ',X),fail
).

is_empty_list([],R) :- !, R=true.

is_empty_list(_,false).

is_null_list(list(Y),R) :- !, is_empty_list(Y,R).

is_null_list(listFrom(_),R) :- !,R=false.

is_null_list(listFromTo(F,T),R) :- number(F),number(T), !,
    (F>T -> R=true ; R=false).

is_null_list(X,_) :- add_error(csp_sequences,'Unexpected argument to null: ',X),fail.

length2([],0).

length2([_H|T],R) :-length3(T,1,R). %when(nonvar(T),(length2(T,RT), R is RT+1)).

length3([],R,R).

length3([_|T],SF,R) :- SF1 is SF+1, length3(T,SF1,R).

length_list(listFrom(X),R) :- !,
    add_internal_error('Internal Error: Trying to get length of infinite list: ',length_list(listFrom(X),R)),fail.

length_list(list(Y),int(R)) :- !, length2(Y,R).

length_list(listFromTo(F,T),int(R)) :- !, (T<F -> R=0 ; R is T+1-F).

length_list(X,Res) :-
    add_error(csp_sequences,'Unexpected arguments to length: ',length(X,Res)),
    fail.

mygeq(EV,F) :- EV>=F.

tail_list(listFrom(F),Res) :- number(F),!,
    F1 is F+1, Res= listFrom(F1).

tail_list(listFromTo(F,T),Res) :- number(F),number(T), T >=F, !,
    (T>F -> F1 is F+1, Res=listFromTo(F1,T) ; Res=list([])).

tail_list(List,Res) :-
    (List=list([_H|T]) -> Res = list(T)
    ; (add_error(csp_sequences,'Unexpected argument to tail of sequence: ',List),fail)).

treat_list_generators([],V,S,G) :- !, V=[], S=[], G=true.

treat_list_generators([comprehensionGenerator(Var,Seq)|T],Vars,Seqs,TG) :- !, Vars=[Var|VT], Seqs=[Seq|ST],
    treat_list_generators(T,VT,ST,TG).

treat_list_generators([comprehensionGuard(Guard)|T],VT,ST,bool_and(Guard,TGuard)) :- !,
    treat_list_generators(T,VT,ST,TGuard).

treat_list_generators(G,_,_,_) :- add_internal_error('Could not treat Seq Comprehension Generator List: ',G),fail.