/* A converter for transforming the problem format of CP'05 into Prolog format */
/* by Neng-Fa Zhou, June 13, 2005, at Monash University on leave from CUNY.    */
main:-
    get_main_args(L),
    process_args(L,BaseName),
    convert(BaseName).

process_args([],InFile):-format("usage: convert FileName",[]).
process_args([BaseName|_],BaseName).

convert(File):- %File is a base name
    write(user,converting(File)),nl(user),
    atom_codes(File,MainString),
    append(MainString,".txt",InFileString),
    atom_codes(InFile,InFileString),
    append(MainString,".pl",OutFileString),
    atom_codes(OutFile,OutFileString),
    (exists(InFile)->true;format("File not found:~w~n",[InFile]),halt),
    see(InFile),
    tell(OutFile),
    global_set(total_min,-320),
    global_set(total_max,320),
    convertProblemName,
    format("comp_problem(Vs):-~n"),
    convertDomainDefinitions,
    global_get(total_min,TMin),
    global_get(total_max,TMax),
    format("~tfd_vector_min_max(~w,~w),~n",[TMin,TMax]),
    convertVariableDefinitions(NVars),
    outputVars(NVars),
    convertRelationDefinitions(RelTypes),
    convertConstraints(RelTypes),
    format("~ttrue.~n"),
    seen,told.

convertProblemName:-
    readLine(NextLine). 

convertDomainDefinitions:-
    readLine(Line),
    getInteger(Line,N,_), %number of domain definitions
    convertDomainDefinitions(0,N).

convertDomainDefinitions(N,N):-!.
convertDomainDefinitions(I,N):-
    readLine(Line),
    getInteger(Line,DNo,Line1),    %domain definition number
    getInteger(Line1,DSize,Line2), % domain size
    getDomains(DSize,Domain,Line2,_),
%    sparse_to_interval(Domain,Domain1),
    format("~tD~d=~w,~n",[DNo,Domain]),
    I1 is I+1,
    convertDomainDefinitions(I1,N).

getDomains(0,Domain,Line,LineR):-!,Line=LineR,Domain=[].
getDomains(N,Domain,Line,LineR):-
    getInteger(Line,Elm,Line1),
    global_get(total_min,TMin),
    (Elm<TMin->global_set(total_min,Elm);true),
    global_get(total_max,TMax),
    (Elm>TMax->global_set(total_max,Elm);true),
    Domain=[Elm|Domain1],
    N1 is N-1,
    getDomains(N1,Domain1,Line1,LineR).

sparse_to_interval([X|Xs],Domain1):-
   sparse_to_interval(X,X,Xs,Domain1).

sparse_to_interval(L,U,[],Domain):-true :
   (L=:=U->Domain=[L];Domain=[L..U]).
sparse_to_interval(L,U,[X|Xs],Domain):-X=:=U+1 :
   sparse_to_interval(L,X,Xs,Domain).
sparse_to_interval(L,U,[X|Xs],Domain):-
   (L=:=U->Domain=[L|Domain1];Domain=[L..U|Domain1]),
   sparse_to_interval(X,X,Xs,Domain).

convertVariableDefinitions(N):-
    readLine(Line),
    getInteger(Line,N,_), %number of variables
    convertVariableDefinitions(0,N).

convertVariableDefinitions(N,N):-!,Vars=[].
convertVariableDefinitions(I,N):-
    readLine(Line),
    getInteger(Line,VNo,Line1), % variable number
    getInteger(Line1,DNo,_),    % domain definition number
    format("~tV~d :: D~d,~n",[VNo,DNo]),
    I1 is I+1,
    convertVariableDefinitions(I1,N).

outputVars(N):-
    format("~tVs=[V0"),
    outputVars(1,N).

outputVars(N,N):-!,format("],~n").
outputVars(I,N):-
    format(",V~d",[I]),
    I1 is I+1,
    outputVars(I1,N).

convertRelationDefinitions(RelTypes):-
    readLine(Line),
    getInteger(Line,N,_), % number of relation definitions
    functor(RelTypes,v,N),
    convertRelationDefinitions(N,RelTypes).

convertRelationDefinitions(0,RelTypes):-!.
convertRelationDefinitions(N,RelTypes):-
    readLine(Line),
    getInteger(Line,RelNo,Line1), % relation definition no
    getInteger(Line1,Type,Line2), % type
    RelNo1 is RelNo+1,
    arg(RelNo1,RelTypes,Type),
    getInteger(Line2,Arity,Line3),
    getNIntegers(Arity,Line3,DNos,Line4),
    getInteger(Line4,NoTuples,Line5),
    getTuples(NoTuples,Arity,Line5,Tuples,_),
    (Type==0->
       format("~tconflict_rel(Rel~d,~w,~w),~n",[RelNo,Tuples,NoTuples]);
       format("~tsupport_rel(Rel~d,",[RelNo]),
       DNos=[DNo|DNos1],
       format("[D~d",[DNo]),
       outputNos(DNos1,'D'),
       format("],~w,~w),~n",[Tuples,NoTuples])),
    N1 is N-1,
    convertRelationDefinitions(N1,RelTypes).

getNIntegers(0,Line,Ints,LineR):-!,Line=LineR,Ints=[].
getNIntegers(N,Line,Ints,LineR):-
    Ints=[Int|Ints1],
    getInteger(Line,Int,Line1),
    N1 is N-1,
    getNIntegers(N1,Line1,Ints1,LineR).

getTuples(0,Arity,Line,Tuples,LineR):-!,Line=LineR,Tuples=[].
getTuples(N,Arity,Line,Tuples,LineR):-
    Tuples=[Tuple|Tuples1],
    getNIntegers(Arity,Line,Tuple,Line1),
    N1 is N-1,
    getTuples(N1,Arity,Line1,Tuples1,LineR).

convertConstraints(RelTypes):-
    readLine(Line), 
    getInteger(Line,N,_), % number of constraints 
    convertConstraints(N,RelTypes).

convertConstraints(0,RelTypes):-!.
convertConstraints(N,RelTypes):-
    readLine(Line),
    getInteger(Line,Arity,Line1),
    getNIntegers(Arity,Line1,VarNos,Line2),
    getInteger(Line2,RelNo,_),
    RelNo1 is RelNo+1,
    arg(RelNo1,RelTypes,Type),
%    format("~w,~w,~n",[write(constr(N)),nl]),
    output_constraint(Type,VarNos,RelNo),
    N1 is N-1,
    convertConstraints(N1,RelTypes).

output_constraint(Type,VarNos,RelNo):-
    (Type==0->
      format("~tconflict_constraint(Rel~d,",[RelNo]);
      format("~tsupport_constraint(Rel~d,",[RelNo])),
     VarNos=[VarNo|VarNos1],
     format("[V~d",[VarNo]),
     outputNos(VarNos1,'V'),
     format("]),~n",[]).

outputNos([],_).
outputNos([VarNo|VarNos],Letter):-!,
     format(",~w~d",[Letter,VarNo]),
     outputNos(VarNos,Letter).

getInteger(Line,N,LineR):- %number of domain definitions    
     trimSpaces(Line,Line1),
     (Line1=[]->
      readLine(NewLine),
      getInteger(NewLine,N,LineR);
     getIntegerAux(Line1,0,N,LineR)).

getIntegerAux([D|Line],N0,N,LineR):-
     D>=0'0,D=<0'9,!,
     N1 is N0*10+D-0'0,
     getIntegerAux(Line,N1,N,LineR).
getIntegerAux(Line,N0,N,LineR):-
     Line=LineR,
     N=N0.

trimSpaces([Space|Line],LineR):-
     space(Space),!,
     trimSpaces(Line,LineR).
trimSpaces(Line,LineR):-Line=LineR.

space(32).
space(10).
space(13).
space(9).