-module(talkToJava).
-export([start_link/0, start_link/1, stop/0]).
-export([init/1, terminate/2, handle_cast/2, 
	 handle_info/2, code_change/3, handle_call/3]).
-behaviour(gen_server).

-include("defs.hrl").

start_link() ->
    start_link([]).

start_link(_Args) ->
    ComputerName = net_adm:localhost(),
    NodeName = "javaNode@" ++ ComputerName,
    NodeAtom = list_to_atom(NodeName),
    gen_server:start_link({local, gui}, ?MODULE, [NodeAtom, dict:new()], []).

stop() ->
    gen_server:cast(gui, stop).

init([NodeAtom, TorrentIds]) ->
    timer:sleep(4000),
    {mailbox, NodeAtom} ! {self(), "startconnection"},
    gen_server:cast(msg_controller, {subscribe, gui, [{exit,-1}, {torrent_info,-1}, {torrent_status,-1}, 
                                                      {tracker_info,-1}, {seeders,-1}, {leechers,-1}, 
                                                      {uploaded,-1}, {downloaded,-1}, {left,-1},
						      {torrent_size,-1}, {pieces,-1},
                                                      {download_speed,-1}, {upload_speed,-1}, {filename,-1}, {default_path,-1}]}),
    {ok, {NodeAtom, TorrentIds}}.

terminate(_Reason, {_NodeAtom, _TorrentIds}) ->
    gen_server:cast(gui, stop).

handle_cast(stop, {_NodeAtom, _TorrentIds}) ->
    {stop, normal, {_NodeAtom, _TorrentIds}};

handle_cast({notify, default_path, {-1, Value}}, {NodeAtom, TorrentIds}) ->
    Target ! {self(), TorrentId, 12, Value};
    {noreply, {NodeAtom, TorrentIds}};

handle_cast({notify, _Tag, {-1, _Value}}, {NodeAtom, TorrentIds}) ->
    {noreply, {NodeAtom, TorrentIds}};

handle_cast({notify, Tag, {Id, Value}}, {NodeAtom, TorrentIds}) ->
						%Check if the key already exists
    case lists:member(Id, dict:fetch_keys(TorrentIds)) of
	false -> NewDict = dict:append(Id, dict:size(TorrentIds)+1, TorrentIds);
	true  -> NewDict = TorrentIds
    end,

    {ok, [TorrentId]} = dict:find(Id, NewDict),

    Target = {mailbox2, NodeAtom},

    %%receives from other erlang modules sends back to notice java
    case Tag of
    	torrent_info ->
	    Filename = Value#torrent.filename,
						%Seeders = Value#torrent.seeders,
						%Leechers = Value#torrent.leechers,
	    Size = Value#torrent.size,
	    Downloaded = Value#torrent.downloaded,
	    {Files,_} = Value#torrent.files,
						%Target ! {self(), TorrentId, 5, Seeders},
						%Target ! {self(), TorrentId, 6, Leechers},
	    Target ! {self(), TorrentId, 1, Size},
	    Target ! {self(), TorrentId, 7, Downloaded},
	    Target ! {self(), TorrentId, 0, Filename},
	    sendFiles(Files, NodeAtom, TorrentId);

	error -> 
	    Target ! {self(), TorrentId, 11, Value};

	filename ->
	    Target ! {self(), TorrentId, 0, Value};

	tracker_info ->
	    Uploaded = Value#tracker_info.uploaded,
	    Target ! {self(), TorrentId, 8, Uploaded};

	file_path ->
	    Files = Value#torrent.files,
	    Target ! {self(), TorrentId, 10, Files};

	torrent_status ->
	    case Value of
		finished -> {mailbox2, NodeAtom} ! {self(), TorrentId, 9, Value};
	        _ -> ok
	    end;

	torrent_size ->
	    Target ! {self(), TorrentId, 1, Value};
	download_speed ->
	    Target ! {self(), TorrentId, 3, Value};
	upload_speed ->
	    Target ! {self(), TorrentId, 4, Value};
	seeders ->
	    Target ! {self(), TorrentId, 5, Value};
	leechers ->
	    Target ! {self(), TorrentId, 6, Value};
	downloaded ->
	    Target ! {self(), TorrentId, 7, Value};
	uploaded ->
	    Target ! {self(), TorrentId, 8, Value};
	finished ->
	    Target ! {self(), TorrentId, 9, "Torrent finished downloading"}
    end,
    {noreply, {NodeAtom, NewDict}}.

handle_info(Info, {NodeAtom, TorrentIds}) ->
    case Info of
        %%receives from java
	{_, connok} ->
	    io:format("Message received: ~p~n", [connectionok]);   
	{_, exit} ->
	    io:format("Message received: ~p~n", [exited]),
	    gen_server:cast(msg_controller, {notify, exit, exit});
	{_, open,FileDir} ->
	    io:format("Message received: ~p~n", [FileDir]),
	    gen_server:cast(msg_controller, {notify, torrent_status, {-1, opened}}),
	    gen_server:cast(msg_controller, {notify, torrent_filepath,{-1, FileDir}});
	{_, Id, start} ->
	    io:format("Message received: ~p~n", [resumed]),
	    gen_server:cast(msg_controller, {notify, torrent_status,{getIdAtom(Id, TorrentIds), resume}});
	{_, Id, stop} ->
	    io:format("Message received: ~p~n", [stopped]),
       	    gen_server:cast(msg_controller, {notify, torrent_status,{getIdAtom(Id, TorrentIds), stopped}});
	{_, Id, pause} ->
	    io:format("Message received: ~p~n", [paused]),
	    gen_server:cast(msg_controller, {notify, torrent_status, {getIdAtom(Id, TorrentIds), paused}});
	{_, Id, delete} ->
	    io:format("Message received: ~p for id: ~p~n", [deleted, getIdAtom(Id, TorrentIds)]),
	    gen_server:cast(msg_controller, {notify, torrent_status, {getIdAtom(Id, TorrentIds), deleted}});
	{_, dir,DirList} ->
	    io:format("directory: ~p~n", [DirList]),
	    gen_server:cast(msg_controller, {notify, default_path,{-1, DirList}})
    end,
    {noreply, {NodeAtom, TorrentIds}}.

sendFiles([],_,_) ->
    ok;
sendFiles([[ToSend,_]|T], NodeAtom, TorrentId) ->
    {mailbox2, NodeAtom} ! {self(), TorrentId, 10, binary_to_list(hd(lists:reverse(ToSend)))},
    sendFiles(T, NodeAtom, TorrentId).

getIdAtom([], _Num, _TorrentIds) ->
    {error, not_found};
getIdAtom([H|T], Num, TorrentIds) ->
    case {ok, [Num]} == dict:find(H, TorrentIds) of
	true  -> H;
	false -> getIdAtom(T, Num, TorrentIds)
    end.

getIdAtom(Num, TorrentIds) ->
    getIdAtom(dict:fetch_keys(TorrentIds), Num, TorrentIds).

code_change(_, _, _) ->
    ok.

handle_call(_, _, _) ->
    ok.