-module(nz).
-export([start_x/0, start_o/0, start_x_track_path/0,
         start_o_track_path/0]).

-record(state, {field=[0,0,0, 0,0,0, 0,0,0],
                track_path=false}).

start_x() ->
    place_mark(1, 2, false, #state{}).

start_x_track_path() ->
    place_mark(1, 2, false, #state{track_path=true}).

start_o() ->
    place_mark(2, 1, false, #state{}).

start_o_track_path() ->
    place_mark(2, 1, false, #state{track_path=true}).


game_finished([X,X,X, _,_,_, _,_,_]) when X =/= 0 ->
    true;
game_finished([_,_,_, X,X,X, _,_,_]) when X =/= 0 ->
    true;
game_finished([_,_,_, _,_,_, X,X,X]) when X =/= 0 ->
    true;
game_finished([X,_,_, X,_,_, X,_,_]) when X =/= 0 ->
    true;
game_finished([_,X,_, _,X,_, _,X,_]) when X =/= 0 ->
    true;
game_finished([_,_,X, _,_,X, _,_,X]) when X =/= 0 ->
    true;
game_finished([X,_,_, _,X,_, _,_,X]) when X =/= 0 ->
    true;
game_finished([_,_,X, _,X,_, X,_,_]) when X =/= 0 ->
    true;
game_finished(Field) ->
    lists:all(fun(Cell) ->
                      Cell =/= 0
              end, Field).

updated(List, Idx, Value) ->
    lists:sublist(List, Idx) ++
        [Value] ++
        lists:nthtail(Idx + 1, List).

place_mark(_CurrentMark, _NextMark, true, #state{field=Field}) ->
    dump_field(Field);
place_mark(CurrentMark, NextMark, _Finished, State = #state{field=Field,
                                                            track_path=TrackPath}) ->
    lists:foreach(fun(Idx) ->
                          NewField = updated(Field, Idx, CurrentMark),
                          case TrackPath of
                              true -> dump_field(Field);
                              false -> do_nothing
                          end,
                          place_mark(NextMark, CurrentMark, game_finished(NewField),
                                     State#state{field = NewField})
                  end, empty(Field)).

empty(Field) ->
    [Idx || {Idx, Cell} <- lists:zip(lists:seq(0, 8), Field),
            Cell =:= 0].

dump_field(Field) ->
    lists:foreach(fun(Row) ->
                          io:format("+-+-+-+~n", []),
                          io:format("|~c|~c|~c|~n", lists:map(fun mark/1, Row))
                  end, chunks(Field, 3)),
    io:format("+-+-+-+~n~n", []).

chunks(List, Len) when length(List) =< Len ->
    [List];
chunks(List, Len) ->
    {Pre, Suf} = lists:split(Len, List),
    [Pre | chunks(Suf, Len)].

mark(Cell) ->
    lists:nth(Cell + 1, " xo").