//////////////////////////////Event.d/////////////////////
module Event;
import std.uuid;
import std.datetime;
import std.random;


struct Event
{
private:

    string date;
    string time;
    int p0;
    int p1;
    int p2;
    UUID id;

public:
    @property string Time() { return time; }
    @property string Date() { return date; }

    @property int P0() { return p0; }
    @property void P0(int p0) { this.p0 = p0;}

    @property int P1() { return p1; }
    @property void P1(int p1) { this.p1 = p1;}

    @property int P2() { return p2; }
    @property void P2(int p2) { this.p2 = p2;}

    @property UUID ID() { return id;}



}

Event CreateEvent()
{
    Event event;
    event.id = randomUUID();
    auto currentDateTime = Clock.currTime();
    event.date = (cast(std.datetime.Date)currentDateTime).toSimpleString();
    event.time = (cast(std.datetime.TimeOfDay)currentDateTime).toString();
    event.p0 = uniform!int();
    event.p1 = uniform!int();
    event.p2 = uniform!int();
    return event;
}

///////////////////////////Logger.d/////////////////////

module Logger;
import Event;
import std.stdio;
import std.conv;
import std.algorithm;
import std.string;

enum LoggerLevel
{
    One, Two, Three
}

interface ILoggable
{
    void Write(Event event);
}

class AbstractLogger : ILoggable
{
protected:
    string fileName;
    File file;
private:
    this(string fileName)
    {
        this.fileName = fileName;
        file.open(fileName, "a");
    }
public:

    void Write(Event event)
    {
    }
    ~this()
    {
        file.flush();
        file.close();
    }
}

class LoggerOne : AbstractLogger
{
    override void Write(Event event)
    {
        file.writeln();
        file.write(format("|%s |%s ", event.ID, event.Time));
    }
protected:
    this(string filename)
    {
        super(filename);
    }

}

class LoggerTwo : LoggerOne
{
    override void Write(Event event)
    {
        super.Write(event);
        file.write(format("|%s |%s ", event.Date, event.P0));
    }
protected:
    this(string filename)
    {
        super(filename);
    }
}

class LoggerThree : LoggerTwo
{
    override void Write(Event event)
    {
        super.Write(event);
        file.write(format("|%s |%s ", event.P1, event.P2));
    }
protected:
    this(string filename)
    {
        super(filename);
    }
}


class LoggerFactory
{
    AbstractLogger[LoggerLevel] cash;
    string fileName;

    AbstractLogger CreateInstance(LoggerLevel level)
    {
        final switch(level)
        {
            case LoggerLevel.One: return new LoggerOne(fileName);
            case LoggerLevel.Two: return new LoggerTwo(fileName);
            case LoggerLevel.Three: return new LoggerThree(fileName);
        }
    }
public:



    this(string fileName)
    {
        this.fileName = fileName;
    }

    AbstractLogger GetLogger(LoggerLevel level)
    {
        if(!canFind(cash.keys, level))
        {
            cash[level] = CreateInstance(level);
            return cash[level];
        }
        else
        {
            return cash[level];
        }
    }

}


///////////////////////main.d////////////////////
import Logger;
import Event;

import std.stdio;
import std.concurrency;
import std.conv;
import core.thread;
import std.datetime;
import std.string;
import std.algorithm;


enum Command
{
    Pause, Resume, Faster, Slower, Exit, LevelOne, LevelTwo, LevelThree, Stat
}

class InputThread
{
protected:
    Tid loggerThread;
    Tid eventThread;
    alias Func = void delegate();

    Func[string] CommandMap;

    bool stop = false;
    void StopThreads()
    {
        stop = true;
        SendMessage(Command.Exit, loggerThread);
        SendMessage(Command.Exit, eventThread);
    }

    Func GetCommand(string command)
    {
        return CommandMap.get(command, delegate() { writeln("Error Command");});
    }

    void ReadCommand()
    {
        string command = removechars(readln(), "\n");
        GetCommand(command)();
    }

    static void SendMessage(Command event, Tid thread)
    {
        thread.send(event);
    }

public:
    this(Tid loggerThread, Tid eventThread)
    {
        this.loggerThread = loggerThread;
        this.eventThread = eventThread;
        CommandMap["time"] = () => writeln(cast(std.datetime.TimeOfDay)Clock.currTime());
        CommandMap["date"] = () => writeln(cast(std.datetime.Date)Clock.currTime());
        CommandMap["exit"] = () => StopThreads();
        CommandMap["slower"] = () => SendMessage(Command.Slower, eventThread);
        CommandMap["faster"] = () => SendMessage(Command.Faster, eventThread);
        CommandMap["pause"] = () => SendMessage(Command.Pause, eventThread);
        CommandMap["resume"] = () => SendMessage(Command.Resume, eventThread);
        CommandMap["level0"] = () => SendMessage(Command.LevelOne, loggerThread);
        CommandMap["level1"] = () => SendMessage(Command.LevelTwo, loggerThread);
        CommandMap["level2"] = () => SendMessage(Command.LevelThree, loggerThread);
        CommandMap["stat"] = () => SendMessage(Command.Stat, loggerThread);
    }

    void Routine()
    {
        while(!stop)
        {
            ReadCommand();
        }
    }

}





class LoggerThread
{

public:
    static void Routine()
    {
        auto loggers = new LoggerFactory("log.txt");
        auto loggerLevel = LoggerLevel.One;
        bool stop = false;
        int stat = 0;
        while(!stop)
        {
            receive(
                (Command val)
                {
                    switch(val)
                    {
                        case Command.Exit: stop = true; break;
                        case Command.Stat: writeln(stat); break;
                        case Command.LevelOne: {
                            loggerLevel = LoggerLevel.One;
                        } break;
                        case Command.LevelTwo: {
                            loggerLevel = LoggerLevel.Two;
                        } break;
                        case Command.LevelThree: {
                            loggerLevel = LoggerLevel.Three;
                        } break;
                        default:
                    }
                },
                (Event event)
                {
                    loggers.GetLogger(loggerLevel).Write(event);
                    stat++;
                }
            );
        }
        writeln("Logger thread end");
    }
}

class EventThread
{
public:
    static void Routine(Tid loggerThread)
    {
        bool stop = false;
        bool pause = false;
        int interval = 1000;
        int defaultValue = interval;
        while(!stop)
        {
            receiveTimeout(
                           dur!("msecs")(interval),
                           delegate (Command val) {
                               switch(val)
                               {
                                   case Command.Exit : stop = true; break;
                                   case Command.Pause : pause = true; break;
                                   case Command.Faster : interval /= 10; break;
                                   case Command.Slower : interval *= 10; break;
                                   case Command.Resume : pause = false; break;
                                   default:
                               }
                           }
            );
            if(!pause)
            {
                loggerThread.send(CreateEvent());
            }
        }
        writeln("End event thread");
    }
}

int main(string[] argv)
{
    auto loggerThreadID = spawn({ LoggerThread.Routine();});
    auto eventThreadID = spawn(function(Tid loggerThreadID) { EventThread.Routine(loggerThreadID); }, loggerThreadID);
    auto inputThread = new InputThread(loggerThreadID, eventThreadID);
    inputThread.Routine();
    readln();
    return 0;
}