#include <dos.h>
#include <stdlib.h>
#include <fstream.h>
#include <stdio.h>
#include <mem.h>
#include <conio.h>

#define PHIL_COUNT 6
#define ITERATION_NUMBER 10

#define TRUE 1
#define FALSE 0

#define TIMER_INTR 0x1C
#define TIMER_HANDLER_ON setvect(TIMER_INTR, timerHandler)
#define TIMER_HANDLER_OFF setvect(TIMER_INTR, oldTimerHandler)

#define TIME 100

#define THINK 0
#define WAIT  1
#define EAT   2

#define FORK_FREE -1

#define FORKS_FREE(x) (*(forksState[x].left_fork) == FORK_FREE) && (*(forksState[x].right_fork) == FORK_FREE)
#define TAKE_FORKS(x) *(forksState[x].left_fork) = x; *(forksState[x].right_fork) = x
#define PUT_FORKS(x) *(forksState[x].left_fork) = FORK_FREE; *(forksState[x].right_fork) = FORK_FREE

#define LOGD(x, y) printf("%d %d\n", x, y); log << x << " " << y << endl

int currentProcess = 0;

int iterationCount = 0;

int forks[PHIL_COUNT];
int philosophers[PHIL_COUNT];

ofstream log("log.txt");

struct Context
{
    unsigned int rax, rbx, rcx, rdx; // 0  2  4  6
    unsigned int rsi, rdi, rbp, rsp; // 8 10 12 14
    unsigned int rcs, rds, res, rss; //16 18 20 22
    unsigned int rip, rflags, a, b;  //24 26 28 30
} processContextArray[PHIL_COUNT];

unsigned int processContextArrayOffset;

struct ForksState
{
   int* left_fork;
   int* right_fork;
} forksState[PHIL_COUNT];

void interrupt (far* oldTimerHandler) (...);

void printState() {
    log << "Philosophers : ";
    for (int i = 0; i < PHIL_COUNT; i++)
    {
        switch(philosophers[i])
        {
            case THINK: log << "THINKS ";
                break;
            case WAIT: log << "WAITS ";
                break;
            case EAT: log << "EATS ";
                break;
        }
    }

    log << endl << "Forks state  : ";
    for (int j = 0; j < PHIL_COUNT; j++)
    {
        char fork_state;
        if (forks[j] == FORK_FREE) log << "FREE ";
        else log << "BUSY ";
    }
    log << endl << "-----------------" << endl;
}

void interrupt timerHandler(...)
{
    printState();
    asm {
        mov  si, [currentProcess];
        mov  cl, 5
        shl  si, cl
        mov  ax, [processContextArrayOffset]
        add  si, ax
        pop  ax
        mov  [si+12], ax
        pop  ax
        mov  [si+10], ax
        pop  ax
        mov  [si+ 8], ax
        pop  ax
        mov  [si+18], ax
        pop  ax
        mov  [si+20], ax
        pop  ax
        mov  [si+ 6], ax
        pop  ax
        mov  [si+ 4], ax
        pop  ax
        mov  [si+ 2], ax
        pop  ax
        mov  [si+ 0], ax
        pop  ax
        mov  [si+24], ax
        pop  ax
        mov  [si+16], ax
        pop  ax
        mov  [si+26], ax
        mov  ax, sp
        mov  [si+14], ax
        mov  ax, ss
        mov  [si+22], ax
    }

    currentProcess++;
    if(currentProcess >= PHIL_COUNT) currentProcess = 0;

    asm {
        mov  [currentProcess], ax
        mov  si, ax
        mov  cl, 5
        shl  si, cl
        mov  ax, [processContextArrayOffset]
        add  si, ax
        mov  ax, [si+22]
        mov  ss, ax
        mov  ax, [si+14]
        mov  sp, ax
        mov  ax, [si+26]
        push ax
        mov  ax, [si+16]
        push ax
        mov  ax, [si+24]
        push ax
        mov  ax, [si+ 0]
        push ax
        mov  ax, [si+ 2]
        push ax
        mov  ax, [si+ 4]
        push ax
        mov  ax, [si+ 6]
        push ax
        mov  ax, [si+20]
        push ax
        mov  ax, [si+18]
        push ax
        mov  ax, [si+ 8]
        push ax
        mov  ax, [si+10]
        push ax
        mov  ax, [si+12]
        push ax
    }
    oldTimerHandler();
}

void simulatePhilosopher()
{
    while (iterationCount < ITERATION_NUMBER) {
        delay(random(TIME));
        philosophers[currentProcess] = WAIT;

        int forksTaken = FALSE;
        while(forksTaken == FALSE)
        {
            delay(random(TIME));

            TIMER_HANDLER_OFF;

            if (FORKS_FREE(currentProcess))
            {
                TAKE_FORKS(currentProcess);

                philosophers[currentProcess] = EAT;
                forksTaken = TRUE;
            }
            TIMER_HANDLER_ON;
        }
        delay(random(TIME));

        TIMER_HANDLER_OFF;
        {
            PUT_FORKS(currentProcess);
            philosophers[currentProcess] = THINK;
            iterationCount++;
        }
        TIMER_HANDLER_ON;
    }
}

int main()
{
    randomize();
    unsigned int rd, rc, re, rs, ri, f;
    asm {
        mov  ax, cs
        mov  [rc], ax
        mov  ax, ds
        mov  [rd], ax
        mov  ax, es
        mov  [re], ax
        mov  ax, ss
        mov  [rs], ax
        mov  [ri], offset simulatePhilosopher
        pushf
        pop  ax
        mov  [f], ax
    }

    for (int i = 0; i < PHIL_COUNT; i++)
    {
        forks[i] = FORK_FREE;
        philosophers[i] = THINK;

        forksState[i].left_fork = &(forks[i]);
        if (i < PHIL_COUNT - 1) forksState[i].right_fork = &(forks[i+1]);
        else forksState[i].right_fork = &(forks[0]);

        memset(&processContextArray[i],0,sizeof(Context));
        processContextArray[i].rcs = rc;
        processContextArray[i].rds = rd;
        processContextArray[i].res = re;
        processContextArray[i].rss = rs;
        processContextArray[i].rflags = f;
        processContextArray[i].rip = ri;
    }

    processContextArrayOffset = (unsigned)&processContextArray;

    oldTimerHandler = getvect(TIMER_INTR);
    TIMER_HANDLER_ON;

    simulatePhilosopher();

    TIMER_HANDLER_OFF;
    log.close();
    return 0;
}