outputFile('./neighbours_solved.txt').
inputFile('./neighbours_unsolved.txt').

:- use_module(library(clpfd)).

solve(Size, Grid):-
  constraints(Size,Grid),
  removeNeighbours(Grid,Solution),
  transpose(Grid,Columns),
  removeNeighbourLine(Grid,VRows),
  maplist(neighCheck, VRows),
  removeNeighbourLine(Columns,VColumns),
  maplist(neighCheck, VColumns),
  maplist(all_distinct,Solution),
  transpose(Solution,SolutionCol),
  maplist(all_distinct,SolutionCol),
  maplist(label,Solution).

doSolve(neighbours(size(Size),grid(Problem)),neighbours(size(Size),grid(Solution))):-
  solve(Size, Problem),
  removeNeighbours(Problem, Solution).

one_apartx(X, Y) :- abs(X-Y) #= 1, #\=(X,Y).
one_aparto(X, Y) :- abs(X-Y) #\= 1, #\=(X,Y).

neighCheck([_]).
neighCheck([A,C,B|T]):-
  C = x,
  one_apartx(A,B),
  neighCheck([B|T]).
neighCheck([A,C,B|T]):-
  C = o,
  one_aparto(A,B),
  neighCheck([B|T]).


removeNeighbours([P],[S]):- removeNeighbourLine(P,S).
removeNeighbours([P,_|PT],[S|ST]):- removeNeighbourLine(P,S), removeNeighbours(PT,ST).

removeNeighbourLine([P],[P]).
removeNeighbourLine([P,_|PT],[P|ST]):- removeNeighbourLine(PT,ST).

replaceNeighbourLines(L,R):-
    replace('x',1,L,R1),
    replace('o',2,R1,R).

replaceNeighbours(Ls, Rs) :-
    maplist(replaceNeighbourLines, Ls, Rs).

removeNeighboursRows(Ls,Rs):-
    maplist(removeNeighbourLine, Ls, Rs).


valid_numbAndNeigh(Size,[H|[]]):- H in 1..Size.
valid_numbAndNeigh(Size,[H,N|T]):-
  H in 1..Size,
  N = x,
  valid_numbAndNeigh(Size,T).

valid_numbAndNeigh(Size,[H,N|T]):-
  H in 1..Size,
  N = o,
  valid_numbAndNeigh(Size,T).


valid_neighbourLines([H|[]]):- H = x.
valid_neighbourLines([H|[]]):- H = o.
valid_neighbourLines([H,N|T]):-
  H = x,
  N = o,
  valid_neighbourLines(T).

valid_neighbourLines([H,N|T]):-
  H = o,
  N = o,
  valid_neighbourLines(T).

constraints(Size,[H|[]]):- valid_numbAndNeigh(Size,H).
constraints(Size, [H,N|T]):-
  valid_numbAndNeigh(Size,H),
  valid_neighbourLines(N),
  constraints(Size,T).



/********************* writing the result */
writeFullOutput(neighbours(size(N),grid(Grid))):-
  write('size '), write(N), write('x'), write(N), nl, writeGrid(Grid).

writeGrid([]).
writeGrid([E|R]):- writeGridLine(E), writeGrid(R).

writeGridLine([]):- nl.
writeGridLine([E|R]):- E='_', !, write(E), write(' '), writeGridLine(R).
writeGridLine([E|R]):- write(E), write(' '), writeGridLine(R).

/********************** reading the input */
readProblem(neighbours(size(N),grid(Grid))):-
  findKW(size), readInt(N), readInt(M), M=N, GridLength is N*2-1, length(Grid,GridLength),
  readGridLines(GridLength,Grid).

findKW(KW):- string_codes(KW,[H|T]), peek_code(H), readKW([H|T]), !.
findKW(_):- peek_code(-1), !, fail.
findKW(KW):- get_code(_), findKW(KW).

readKW([]):- get_code(_).
readKW([H|T]):- get_code(H), readKW(T).

readGridLines(N,[A]):- length(A,N), readGridLine(A).
readGridLines(N,[A,B|T]):- length(A,N), readGridLine(A), length(B,N), readNeighborLine(B), readGridLines(N,T).

readGridLine([N]):- readInt(I), makeHint(I,N).
readGridLine([N,X|T]):- readInt(I), makeHint(I,N), get_code(M), translate(M,X), !, readGridLine(T).

readNeighborLine([X]):- get_code(M), translate(M,X), !.
readNeighborLine([X,o|T]):- get_code(M), translate(M,X), get_code(_), get_code(_), get_code(_), !, readNeighborLine(T).

makeHint(X,X):- X>0.
makeHint(0,_).

translate(-1,'ERROR: EOF').
translate(120,'x').
translate(32,'o').
translate(X,X).
translate(X,E):- whitespace(X), get_code(Y), translate(Y,E).
translate(X,E):- string_codes(E,[X]).

whitespace(10). whitespace(12). whitespace(32).

readInt(N):- get_code(M), handleCode(M,N).

handleCode(M,N):- is_number_code(M,N1), !, continueInt(N1,N).
handleCode(-1,_):- !, fail. /* EOF */
handleCode(_,N):- readInt(N).

continueInt(O,N):- get_code(M), is_number_code(M,M1), !, H is 10*O+M1, continueInt(H,N).
continueInt(N,N).

is_number_code(N, N1):- N>=48, N<58, N1 is N-48.
is_number_code(95,0).

/*********************** global control: starting the algorithm and the reading */
run:- inputFile(IF), see(IF), outputFile(F), tell(F), findKW(puzzles), readInt(N),  write('puzzles '), write(N), nl, solveProblems(N), told, seen, !.
run:- told, seen. /* close the files */

solveProblems(0).
solveProblems(N):- N>0, readProblem(P), doSolve(P, S), writeFullOutput(S), !, N1 is N-1, solveProblems(N1).

:- nl,nl,write(' try running "?- run."'), nl,nl,nl.

:- run.
:- halt.

/*
mintest

[[_,x,_,x,_,o,_],[o,o,o,o,o,o,o],[_,o,_,x,_,x,_],[x,o,x,o,x,o,x],[_,x,_,x,_,o,_],[o,o,o,o,o,o,o],[4,o,_,x,_,x,3]]
[[3,x,2,x,1,o,4],[o,o,o,o,o,o,o],[1,o,4,x,3,x,2],[x,o,x,o,x,o,x],[2,x,3,x,4,o,1],[o,o,o,o,o,o,o],[4,o,1,x,2,x,3]]

[[_,x,_,x,_,o,_],[_,o,_,x,_,x,_],[_,x,_,x,_,o,_],[4,o,_,x,_,x,3]]

[[3,1,2,1,1,2,4],[2,2,2,2,2,2,2],[1,2,4,1,3,1,2],[1,2,1,2,1,2,1],[2,1,3,1,4,2,1],[2,2,2,2,2,2,2],[4,2,1,1,2,1,_]]
[[_,1,_,1,_,2,_],[2,2,2,2,2,2,2],[_,2,_,1,_,1,_],[1,2,1,2,1,2,1],[_,1,_,1,_,2,_],[2,2,2,2,2,2,2],[4,2,_,1,_,1,3]]
[[_,x,_,o,_,x,_,o,_],[x,o,x,o,x,o,o,o,x],[_,x,_,o,_,o,_,o,_],[o,o,o,o,o,o,o,o,o],[1,o,5,o,_,x,_,o,_],[o,o,o,o,x,o,x,o,x],[_,x,_,x,_,o,_,o,_],[x,o,x,o,x,o,o,o,o],[_,x,_,o,_,x,_,x,_]]

7x7 hard
[[_,o,_,x,_,o,_,o,_,o,_,x,_],[x,o,o,o,o,o,x,o,o,o,o,o,o],[_,o,_,o,_,x,_,o,_,o,4,o,_],[o,o,x,o,o,o,x,o,o,o,o,o,o],[_,x,_,x,_,o,_,o,_,x,_,o,_],
[x,o,o,o,o,o,o,o,o,o,o,o,x],[_,o,_,x,_,o,_,o,1,o,7,o,_],[o,o,o,o,o,o,o,o,o,o,o,o,o],[_,x,_,o,_,o,_,x,_,x,_,o,_],[o,o,o,o,o,o,x,o,o,o,o,o,o],
[_,x,_,o,_,x,_,o,_,x,_,o,_],[o,o,o,o,o,o,x,o,o,o,o,o,o],[_,x,_,x,_,o,_,x,_,o,_,x,_]]

statistics(walltime, [TimeSinceStart | [TimeSinceLastCall]]),
 tester(5,[[_,x,_,o,_,x,_,o,_],[x,o,x,o,x,o,o,o,x],[_,x,_,o,_,o,_,o,_],[o,o,o,o,o,o,o,o,o],[1,o,5,o,_,x,_,o,_],[o,o,o,o,x,o,x,o,x],[_,x,_,x,_,o,_,o,_],[x,o,x,o,x,o,o,o,o],[_,x,_,o,_,x,_,x,_]]),
   statistics(walltime, [NewTimeSinceStart | [ExecutionTime]]),
   write('Execution took '), write(ExecutionTime), write(' ms.'), nl.
*/