-module(circle_loop).
-compile(export_all).
%-export([start/0]).

-define(PROCESS_COUNT, 1000000).

main([_A]) ->
     start().

start() ->
    io:format("Starting...~n"),
    MyPid = self(),
    statistics(runtime),
    statistics(wall_clock),
    register(first_process, spawn(fun() -> thread_loop(0, ?PROCESS_COUNT, MyPid) end)),
    %io:format("Tail pid: ~p~n", [self()]),
    start_loop(),
    io:format("Exiting...~n").

start_loop() ->
    receive
        {message, Text} ->
            {_, Time3} = statistics(runtime),
            {_, Time4} = statistics(wall_clock),

            io:format("Blob reached tail! Length: ~p~n", [size(Text)]),
            io:format("  Blob reached time (runtime): ~p ms (time per process: ~p us)~n", [Time3, Time3 * 1000 / ?PROCESS_COUNT]),
            io:format("  Blob reached time (wall clock): ~p ms (time per process: ~p us)~n", [Time4, Time4 * 1000 / ?PROCESS_COUNT]),
            first_process ! shutdown,
            start_loop();
        created ->
            {_, Time1} = statistics(runtime),
            {_, Time2} = statistics(wall_clock),

            io:format("Process circle done~n"),
            io:format("  Time (runtime) to create: ~p ms (time per process: ~p us)~n", [Time1, Time1 * 1000 / ?PROCESS_COUNT]),
            io:format("  Time (wall clock) to create: ~p ms (time per process: ~p us)~n", [Time2, Time2 * 1000 / ?PROCESS_COUNT]),

            {ok, Data} = file:read_file("/home/elf/projects/erlang/1K.bin"),
            % first_process ! {message, "shout"},
            first_process ! {message, Data},
            start_loop();
        shutdown ->
            io:format("Shutdown reached tail. Exiting~n")
                
    end.


thread_loop(N, Max, Tail) ->
    %io:format("inited. Tail: ~p~n", [Tail]),
    if
        N < Max ->
            %io:format("Spawning process (Tail: ~p)~n", [Tail]),
            thread_message_loop(spawn(fun() ->
                                              thread_loop(N + 1, Max, Tail)
                                      end));
        true ->
            io:format("Stop spawning, next will be tail~n"),
            Tail ! created,
            thread_message_loop(Tail)
    end.


thread_message_loop(Next) ->
    receive
        {message, Text} ->
            %io:format("~p: Received message: ~p~nSending to ~p~n~n", [self(), Text, Next]),
            Next ! {message, Text},
            thread_message_loop(Next);
        shutdown ->
            Next ! shutdown
    end.