megoldase(Sudoku_feladat, Sudoku_megoldas) :-
	arg(1, Sudoku_feladat, M),
    arg(2, Sudoku_feladat, Sudoku),
	Meret_squared is M * M,
	Sikeres is 1,
	vegignez(0, 0, Meret_squared, Sudoku, Sikeres, Sudoku_feladat, Sudoku_megoldas),
	(Sikeres =:= 0 ->
		write('bukta')
		;
		Asd is 2
	),
	!.


vegignez(Meret, Meret, Meret, _, Sikeres, _, Sudoku_megoldas) :- !. %visszatér ha az uolsó sorutolsó oszlopát is megnézte
vegignez(Aktualis_sor, Meret, Meret, Sudoku, Sikeres, Sudoku_feladat, Sudoku_megoldas) :- %sor végére ért akkor kezdi a következo sort az elejérol
	Aktualis_sor1 is Aktualis_sor + 1,
	(Aktualis_sor1 = Meret ->
		vegignez(Aktualis_sor1, Meret, Meret, Sudoku, Sikeres, Sudoku_feladat, Sudoku_megoldas)
		;
		vegignez(Aktualis_sor1, 0, Meret, Sudoku, Sikeres,Sudoku_feladat, Sudoku_megoldas)),
		!.
vegignez(Aktualis_sor, Aktualis_oszlop, Meret, Sudoku, Sikeres, Sudoku_feladat, Sudoku_megoldas) :- %végignéz egy sort
	ertekek(Sudoku_feladat, Aktualis_sor - Aktualis_oszlop, Lista),
	cellabolSzam(Sudoku, Aktualis_sor, Aktualis_oszlop, Keresett_szam),
	(Keresett_szam \= [] ->
		(member(Keresett_szam, Lista) -> %teszteli, hogy benne van e a megengedett listában a már beírt szám

		Lehet_jo is 1

		;

		Sikeres is 0

		)
		;

		Lehet_jo is 1
	),


	megoldasbolSzam(Sudoku_megoldas, Aktualis_oszlop, Aktualis_sor, Megoldas_megfelelo_eleme),
	(member(Megoldas_megfelelo_eleme, Lista) -> %megnézi, hogy a megoldásban szereplo szám az benne van e a listában

		Lehet_jo is 1


		%TODO: itt kell beleírni a sudoku_megoldas-ba a kivalasztott szamot. Ezzel tartja a sudoku szabalyait.

		;

		Sikeres is 0

	),

	nth0(Aktualis_sor,Sudoku,Egy_sor),
	nth0(Aktualis_oszlop, Egy_sor, Elem),
	checkItemSouth(Elem, South_Item),
	checkItemWest(Elem, West_Item),
	West_oszlop is Aktualis_oszlop - 1,
	South_sor is Aktualis_sor + 1,


    (West_Item = [w], South_Item = [s] ->
		megoldasbolSzam(Sudoku_megoldas, West_oszlop, Aktualis_sor, Megoldas_west_eleme),
		megoldasbolSzam(Sudoku_megoldas, Aktualis_oszlop, South_sor, Megoldas_south_eleme),
		Uj_valtozo_w is Megoldas_megfelelo_eleme + Megoldas_west_eleme,
		Uj_valtozo_s is Megoldas_megfelelo_eleme + Megoldas_south_eleme,
		((Uj_valtozo_w rem 2) =\= 0 , (Uj_valtozo_s rem 2) =\= 0 ->

			Lehet_jo is 1,
			Aktualis_oszlop1 is Aktualis_oszlop +1,
			vegignez(Aktualis_sor, Aktualis_oszlop1, Meret, Sudoku, Sikeres, Sudoku_feladat, Sudoku_megoldas)

			;

			Sikeres is 0

		)
		;
		(West_Item = [w] ->
		megoldasbolSzam(Sudoku_megoldas, West_oszlop, Aktualis_sor, Megoldas_west_eleme),
			Uj_valtozo is Megoldas_megfelelo_eleme + Megoldas_west_eleme,
			((Uj_valtozo rem 2) =:= 0 ->

				Sikeres is 0

				;


				Aktualis_oszlop1 is Aktualis_oszlop +1,
				vegignez(Aktualis_sor, Aktualis_oszlop1, Meret, Sudoku, Sikeres, Sudoku_feladat, Sudoku_megoldas)

			)
        ;
		(South_Item = [s] ->
			megoldasbolSzam(Sudoku_megoldas, Aktualis_oszlop, South_sor, Megoldas_south_eleme),
			Uj_valtozo is Megoldas_megfelelo_eleme + Megoldas_south_eleme,
			((Uj_valtozo rem 2) =:= 0 ->

				Sikeres is 0

				;

				Lehet_jo is 1,
				Aktualis_oszlop1 is Aktualis_oszlop +1,
				vegignez(Aktualis_sor, Aktualis_oszlop1, Meret, Sudoku, Sikeres, Sudoku_feladat, Sudoku_megoldas)
			)
		;
		Lehet_jo is 1
	),

	Aktualis_oszlop1 is Aktualis_oszlop +1,
	vegignez(Aktualis_sor, Aktualis_oszlop1, Meret, Sudoku, Sikeres, Sudoku_feladat, Sudoku_megoldas)
	)),
	!.



checkItemSouth([], []) :- !.
	checkItemSouth([H|T], Result) :-
    (H = 's' -> append([], [H], Result);
        checkItemSouth(T, Result)).

checkItemWest([], []) :- !.
	checkItemWest([H|T], Result) :-
    (H = 'w' -> append([], [H], Result);
        checkItemWest(T, Result)).


megoldasbolSzam(Sudoku_megoldas, Oszlop, Sor, Keresett) :-
	Uj_oszlop is Oszlop + 1,
	nth0(Sor,Sudoku_megoldas,Egy_sor),
	nth1(Uj_oszlop,Egy_sor,Keresett).


cellabolSzam(Sudoku, Aktualis_sor, Aktualis_oszlop, Keresett_szam) :-
	nth0(Aktualis_sor,Sudoku,Egy_sor),
	Uj_oszlop_szam is Aktualis_oszlop + 1,
	nth1(Uj_oszlop_szam,Egy_sor,Elem),
	checkItem(Elem, Keresett_szam).

ertekek(Sudoku_Full, Row1-Col1, Vals) :-
    % Extract and set parameters
    arg(1, Sudoku_Full, N),
    arg(2, Sudoku_Full, Sudoku),
    FromRow is Row1 - (Row1 rem N),
    FromCol is Col1 - (Col1 rem N),

    % Get the Row
    nth0(Row1,Sudoku,Result_Row),

    % Get the Column
    getColumn(Sudoku, Col1, Result_Column),

    % Get the NxN Block
    getBlock(Sudoku, FromRow, FromCol, N, N, Result_Block),

    % Get the Item
    nth0(Col1, Result_Row, Result_Item),

    % Unify
    append(Result_Row, Result_Column, Temp_All),
    append(Temp_All, Result_Block, All),
    flatten2(All, All_Flatten),
    removeV(All_Flatten, [], All_Best),

    % Create list of numbers
    N_Squared is N*N,
    num2list(N_Squared, Numbers),

    % Extract number for Result_Item, if it's a number
    checkItem(Result_Item, Item_Number),
    checkItemOdd(Result_Item, Odd_Item),
    checkItemEven(Result_Item, Even_Item),

    (number(Item_Number) ->
        % Check how many times is Item in Allitems
        countNumber(All_Best, Item_Number, 0, Occurrence),
        % If occurrence is more than 3, fuck it.
        (Occurrence > 3 ->
            Vals = [];
        %Else
        % Check if odd or even fucks it.
            (Odd_Item = [o], Even_Item = [e] ->
                Vals = [];
             Odd_Item = [o], (Item_Number rem 2) =:= 0 ->
                Vals = [];
             Even_Item = [e], (Item_Number rem 2) =:= 1 ->
                Vals = [];
             Vals = [Item_Number]
             )
        );

        (Odd_Item = [o], Even_Item = [e] ->
             num2listOdd(N_Squared, OddNumbers),
             num2listEven(N_Squared, EvenNumbers),
             append(All_Best, OddNumbers, All_Final_Temp),
             append(All_Final_Temp, EvenNumbers, All_Final);
        Odd_Item = [o] ->
            num2listEven(N_Squared, OddNumbers),
            append(All_Best, OddNumbers, All_Final);
        Even_Item = [e] ->
            num2listOdd(N_Squared, EvenNumbers),
            append(All_Best, EvenNumbers, All_Final);
        All_Final = All_Best),

        checkAllNumbers(Numbers, All_Final, [], Result_Final),
        (var(Result_Final) -> Vals = [];
        Vals = Result_Final)),
        !.

checkAllNumbers([], _, Acc, Result) :-
    Result = Acc,
    !.
checkAllNumbers([H|T], All, Acc, Result) :-
    (\+ member(H, All) ->
        append(Acc, [H], Temp),
        checkAllNumbers(T, All, Temp, Result);
    checkAllNumbers(T, All, Acc, Result)).

getColumn([], _, []) :- !.
getColumn([H|T], ColNum, Res):-
    getColumn(T, ColNum, Temp),
    nth0(ColNum, H, Col),
    append(Temp, [Col], Res).

getBlockCol(_, _, ToCol, ToCol, Acc, Result) :-
    Result = Acc,
    !.
getBlockCol([H|T], FromCol, ToCol, Current, Acc, Result) :-
    NewCurr is Current + 1,
    (Current >= FromCol -> append(Acc, [H], Temp),
    getBlockCol(T, FromCol, ToCol, NewCurr, Temp, Result);
    getBlockCol(T, FromCol, ToCol, NewCurr, Acc, Result)).

getBlock(_, _, _, _, 0, _) :- !.
getBlock(Sudoku, FromRow, FromCol, N, Current, Result) :-
    NewCurrent is Current - 1,
    getBlock(Sudoku, FromRow, FromCol, N, NewCurrent, Temp),
    RowToExtract is FromRow + Current - 1,
    nth0(RowToExtract,Sudoku,CurrentRow),
    ToCol is FromCol + N,
    getBlockCol(CurrentRow, FromCol, ToCol, 0, [], MyRes),
    append(Temp, MyRes, Result).

num2list(N, List) :-
    num2list(1, N, List).
num2list(N, N, [N]) :- !.
num2list(N0, N, [N0| List]) :-
    N0 < N,
    N1 is N0 + 1,
    num2list(N1, N, List).

num2listEven(N, List) :-
    num2listEven(2, N, List).
num2listEven(N0, N, [N0| List]) :-
    N0 < N,
    N1 is N0 + 2,
    num2listEven(N1, N, List).
num2listEven(_, _, []) :- !.

num2listOdd(N, List) :-
    num2listOdd(1, N, List).
num2listOdd(N0, N, [N0| List]) :-
    N0 < N,
    N1 is N0 + 2,
    num2listOdd(N1, N, List).
num2listOdd(M, _, [M]) :- !.


checkItem([], []) :- !.
checkItem([H|T], Result) :-
    eval(H, NewH),
    (number(NewH) -> append([], NewH, Result);
    checkItem(T, Result)).

checkItemOdd([], []) :- !.
checkItemOdd([H|T], Result) :-
    (H = 'o' -> append([], [H], Result);
        checkItemOdd(T, Result)).

checkItemEven([], []) :- !.
checkItemEven([H|T], Result) :-
    (H = 'e' -> append([], [H], Result);
        checkItemEven(T, Result)).

countNumber([], _, Count, Result) :-
    Result is Count,
    !.
countNumber([H|T], Item, Count, Result) :-
    (number(H), H =:= Item ->
        Temp is Count + 1,
        countNumber(T, Item, Temp, Result);
        countNumber(T, Item, Count, Result)).

flatten2([], []) :- !.
flatten2([L|Ls], FlatL) :-
    flatten2(L, NewL),
    flatten2(Ls, NewLs),
    append(NewL, NewLs, FlatL).
flatten2(L, [L]).

removeV([], Acc, Result) :-
    Result = Acc,
    !.
removeV([H|T], Acc, Result) :-
    eval(H, NewH),
    append(Acc, [NewH], Temp),
    removeV(T, Temp, Result).

eval(v(X), Result) :-
    Result = X.

eval(X, Result) :-
    Result = X.

nth0(0, [Head|_], Head) :- !.

nth0(N, [_|Tail], Elem) :-
    nonvar(N),
    M is N-1,
    nth0(M, Tail, Elem).

nth0(N,[_|T],Item) :-       % Clause added KJ 4-5-87 to allow mode
    var(N),         % nth0(-,+,+)
    nth0(M,T,Item),
    N is M + 1.


nth1(1, [Head|_], Head) :- !.

nth1(N, [_|Tail], Elem) :-
    nonvar(N),
    M is N-1,           % should be succ(M, N)
    nth1(M, Tail, Elem).

nth1(N,[_|T],Item) :-       % Clause added KJ 4-5-87 to allow mode
    var(N),         % nth1(-,+,+)
    nth1(M,T,Item),
    N is M + 1.