lookup(Key, Qref, Client, Id, {Pkey, _}, Successor, Store) ->
    case key:between(Key, Pkey, Id) of
        true ->
            Result = storage:lookup(Key, Store),
            Client ! {Qref, Result};
        false ->
            {_, Spid} = Successor,
            Spid ! {lookup, Key, Qref, Client}
    end.



notify({Nkey, Npid}, Id, Predecessor, Store) ->
    case Predecessor of
        nil ->
            Keep = handover(Store, Nkey, Npid),
            {Predecessor, Keep};
        {Pkey, _} ->
            case key:between(Nkey, Pkey, Id) of
                true ->
                    Keep = handover(Store, Nkey, Npid),
                    {{Nkey, Npid}, Keep};
                false ->
                    Npid ! {status, Predecessor},
                    {{Nkey, Npid}, Store}
            end
    end.



handover(Store, Nkey, Npid) ->
    {Keep, Leave} = storage:split(Nkey, Store),
    Npid ! {handover, Leave},
    Keep.


node(Id, Predecessor, Successor, Store) ->
    receive
        {key, Qref, Peer} ->
            Peer ! {Qref, Id},
            node(Id, Predecessor, Successor, Store);
        {notify, New} ->
            {Pred, Store2} = notify(New, Id, Predecessor, Store),
            node(Id, Pred, Successor, Store2);
        {request, Peer} ->
            request(Peer, Predecessor),
            node(Id, Predecessor, Successor, Store);
        {status, Pred} ->
            Succ = stabilize(Pred, Id, Successor),
            node(Id, Predecessor, Succ, Store);
        stabilize ->
            stabilize(Successor),
            node(Id, Predecessor, Successor, Store); %%node(Id, Predecessor, Successor, Store);
        print ->
            io:format("node ~w, pred ~w, succ ~w~n", [{Id,self()},Predecessor, Successor]),
            node(Id, Predecessor, Successor, Store);
        probe ->
            io:format("node ~w, probe received~n", [Id]),
            create_probe(Id, Successor),
            node(Id, Predecessor, Successor, Store);
        {probe, Start, TStart, Nodes} when Start == Id ->
            remove_probe(Start, TStart, Nodes),
            node(Id, Predecessor, Successor, Store);
        {probe, Start, TStart, Nodes} ->
            forward_probe(Id, Start, TStart, Nodes, Successor),
            node(Id, Predecessor, Successor, Store);
        {handover, Elements} ->
            Merged = storage:merge(Store, Elements),
            node(Id, Predecessor, Successor, Merged);
        {add, Key, Value, Qref, Client} ->
            io:format("Id: ~w Attempting to add key~n",[Id]),
            Added = add(Key, Value, Qref, Client, Id, Predecessor, Successor, Store),
            io:format("Id: ~w added key: ~w, Value:~w ", [Id, Key,Value]),
            node(Id, Predecessor, Successor, Added);
        {lookup, Key, Qref, Client} ->
            lookup(Key, Qref, Client, Id, Predecessor, Successor, Store),
            node(Id, Predecessor, Successor, Store);
        stop ->
            ok;
        Error ->
            io:format("node ~w, strange message ~w~n", [Id, Error]),
            node(Id, Predecessor, Successor, Store)
    end.


notify({Nkey, Npid}, Id, Predecessor, Store) ->
    case Predecessor of
        nil ->
            Keep = handover(Store, Nkey, Npid),
            {Predecessor, Keep};
        {Pkey, _} ->
            case key:between(Nkey, Pkey, Id) of
                true ->
                    Keep = handover(Store, Nkey, Npid),
                    {{Nkey, Npid}, Keep};
                false ->
                    Npid ! {status, Predecessor},
                    {{Nkey, Npid}, Store}
            end
    end.


add(Key, Value, Qref, Client, Id, {Pkey, _}, {_, Spid}, Store) ->
    io:format("1~n"),
    case key:between(Key, Pkey, Id) of
        true ->
            io:format("2~n"),
            Client ! {Qref, ok},
            io:format("Id: ~w added: ~w to storage~n", [Id, Key]),
            storage:add(Store, Key, Value);
        false ->
            io:format("3~n"),
            Spid ! {add, Key, Value, Qref, Client},
            io:format("4~n"),
            Store
    end.