#include "lib.h"
#include "types.h"

int data = 0;

int uEntry(void)
{
    printf("==============TEST FOR BASIC==============\n");
    int ret = fork();
    int i = 8;
    int pid = getpid();

    if (ret == 0)
    {
        data = 2;
        while (i != 0)
        {
            i--;
            printf("Child Process (pid:%d): Pong %d, %d;\n", pid, data, i);
            sleep(128);
        }
        exit();	
        printf("If exit() worked, you should not get here.\n");
    }
    else if (ret != -1)
    {
        data = 1;
        while (i != 0)
        {
            i--;
            printf("Parent Process (pid:%d): Ping %d, %d;\n", pid, data, i);
            sleep(128);
        }
    }
    printf("===========TEST FOR BASIC OVER===========\n\n");
    exit(); 	// if you wants to test you wait function, remove this line.
    /*
    ......
    */
    while (1)
        ;
    return 0;
}

uint32_t loadUMain(void) {
    int i = 0;
    int phoff = 0x34; // program header offset
    int offset = 0x1000; // .text section offset
    uint32_t elf = 0x200000; // physical memory addr to load
    uint32_t uMainEntry = 0x200000;
    Inode inode;
    int inodeOffset = 0;
    readInode(&sBlock, &inode, &inodeOffset, "/boot/initrd");
    for (i = 0; i < inode.blockCount; i++) {
        readBlock(&sBlock, &inode, i, (uint8_t *)(elf + i * sBlock.blockSize));
    }
    uMainEntry = ((struct ELFHeader *)elf)->entry; // entry address of the program
    phoff = ((struct ELFHeader *)elf)->phoff;
    offset = ((struct ProgramHeader *)(elf + phoff))->off;
    for (i = 0; i < 200 * 512; i++) {
        *(uint8_t *)(elf + i) = *(uint8_t *)(elf + i + offset);
    }
    enterUserSpace(uMainEntry);
}

struct ELFHeader {
    unsigned int   magic;
    unsigned char  elf[12];
    unsigned short type;
    unsigned short machine;
    unsigned int   version;
    unsigned int   entry;				//程序入口
    unsigned int   phoff;				//Program Header 偏移
    unsigned int   shoff;				//Section Header 偏移
    unsigned int   flags;
    unsigned short ehsize;			//此头长度
    unsigned short phentsize;		//程序头长度
    unsigned short phnum;				//程序头数
    unsigned short shentsize;		//节头长度
    unsigned short shnum;				//节头数
    unsigned short shstrndx;
};

struct ProgramHeader {
    unsigned int type;
    unsigned int off;       //这个段第一个字节在文件中的偏移
    unsigned int vaddr;     //这个段第一个字节在内存中的虚拟地址
    unsigned int paddr;     //应当加载到的物理内存地址
    unsigned int filesz;    //这个段在 elf 文件中的长度
    unsigned int memsz;     //这个段在内存中的长度
    unsigned int flags;
    unsigned int align;
};

void enterUserSpace(uint32_t entry) {
    uint32_t EFLAGS = 0;
    asm volatile("pushl %0":: "r" (USEL(SEG_UDATA))); // push ss
    asm volatile("pushl %0":: "r" (0x200000)); //TODO push esp, further modification
    asm volatile("pushfl"); //push eflags, sti
    asm volatile("popl %0":"=r" (EFLAGS));
    asm volatile("pushl %0"::"r"(EFLAGS|0x200));
    asm volatile("pushl %0":: "r" (USEL(SEG_UCODE))); // push cs
    asm volatile("pushl %0":: "r" (entry)); //TODO push eip, further modification
    asm volatile("pushl %0":: "r" (USEL(SEG_UDATA)));
    asm volatile("pushl %0":: "r" (USEL(SEG_UDATA)));
    asm volatile("pushl %0":: "r" (USEL(SEG_UDATA)));
    asm volatile("pushl %0":: "r" (USEL(SEG_UDATA)));
    asm volatile("popl %gs");
    asm volatile("popl %fs");
    asm volatile("popl %es");
    asm volatile("popl %ds");
    asm volatile("iret");
}

#define TIMER_PORT 0x40
#define FREQ_8253 1193182
#define HZ 100

void initTimer() {
    int counter = FREQ_8253 / HZ;
    outByte(TIMER_PORT + 3, 0x34);
    outByte(TIMER_PORT + 0, counter % 256);
    outByte(TIMER_PORT + 0, counter / 256);
}

struct ProcessTable {
    uint32_t stack[MAX_STACK_SIZE];         // 内核堆栈
    struct StackFrame regs;                 // 陷阱帧，保存上下文
    uint32_t stackTop;                      // 保存内核栈顶信息
    uint32_t prevStackTop;                  // 中断嵌套时保存待恢复的栈顶信息
    int state;                              // 进程状态：STATE_RUNNABLE、STATE_RUNNING、STATE_BLOCKED、STATE_DEAD
    int timeCount;                          // 当前进程占用的时间片
    int sleepTime;                          // 当前进程需要阻塞的时间片
    uint32_t pid;                           // 进程的唯一标识
    char name[32];                          // not used
};

struct StackFrame {
    uint32_t gs, fs, es, ds;
    uint32_t edi, esi, ebp, xxx, ebx, edx, ecx, eax;
    uint32_t irq, error;
    uint32_t eip, cs, eflags, esp, ss;
};

struct ProcessTable pcb[MAX_PCB_NUM];

/*
 * Schedules the next process to run
 * 
 * Returns:
 *   pid_t - The process ID of the scheduled process
 *           Returns -1 if no process is available for scheduling
 */
uint32_t schedule() {
    // TODO: Select the next process and perform context switching
    return -1;
}

/*
#define SYS_WRITE 0
#define SYS_FORK 1
#define SYS_EXEC 2
#define SYS_SLEEP 3
#define SYS_EXIT 4
#define SYS_GETPID 5

#define STD_OUT 0

#define MAX_BUFFER_SIZE 256
*/
void idle()
{
    // (SYS_FORK, 0, 0, 0, 0, 0)
    int32_t ret = syscall(1, 0, 0, 0, 0, 0);

    if (ret == 0)
    {
        // child: exec
        // (SYS_EXEC, Begin_Sector, Sector_Num, 0, 0, 0)
        syscall(2, (uint32_t)201, (uint32_t)(200), 0, 0, 0);
    }
    else
    {
        // parent: run only when no other process is Runnable
        // LOG: enter idle
        char buffer[] = "I'm the user idle!\nFirst fork: First entering the idle process\n";
        // (SYS_WRITE, STD_OUT, Buffer, Output_Size, 0, 0)
        syscall(0, 0, (uint32_t)buffer, sizeof(buffer) - 1, 0, 0);

        while (1)
        {
            // waitForInterrupt();
            // What's the function of `waitForInterrupt`?
            // Why we commented it out ?
            // you can also try a `putChar('i');` here
        };
    }
}

void initIdle(void)
{
    // init idle and make it a user process, while it's text is the text of kernel

    // 1. idle's kernel stack
    pcb[0].stackTop = (uint32_t)&(pcb[0].stackTop) - sizeof(struct StackFrame);
    /*
    WHY `- sizeod(struct StackFrame)` ?
        : We need to fake a frame later.
        ------------------------------------------
            struct ProcessTable {
                uint32_t stack[MAX_STACK_SIZE];
                struct StackFrame regs;				<- (uint32_t) & (pcb[i].stackTop) - sizeof(struct StackFrame)
                uint32_t stackTop;					<- (uint32_t) & (pcb[i].stackTop)
                uint32_t prevStackTop;
                ...
            };
        ------------------------------------------
    */
    pcb[0].prevStackTop = (uint32_t)&(pcb[0].stackTop);

    // 2. some status and message of process 0 control
    pcb[0].state = STATE_RUNNING;
    pcb[0].timeCount = MAX_TIME_COUNT;
    pcb[0].sleepTime = 0;
    pcb[0].pid = 0;
    // DO: for wait()
    pcb[0].ppid = -1;
    pcb[0].childCount = 0;
    // DO OVER

    // 3. init segment selectors
    pcb[0].regs.ss = USEL(SEG_IDLE_DATA);
    pcb[0].regs.cs = USEL(SEG_IDLE_CODE);
    pcb[0].regs.ds = USEL(SEG_IDLE_DATA);
    pcb[0].regs.es = USEL(SEG_IDLE_DATA);
    pcb[0].regs.fs = USEL(SEG_IDLE_DATA);
    pcb[0].regs.gs = USEL(SEG_IDLE_DATA);

    // 4. init important env registers
    pcb[0].regs.esp = 0x1fffff;
    pcb[0].regs.eip = (uint32_t)idle;
    pcb[0].regs.ebp = 0x1fffff;
    pcb[0].regs.eflags = 0x202;

    // 5. fake `iret`
    // 		: pretend you had get interrupted into kernel from user idle process
    current = 0;
    uint32_t tmp = pcb[current].stackTop;
    pcb[current].stackTop = pcb[current].prevStackTop;
    tss.esp0 = pcb[current].stackTop;
    asm volatile("movl %0, %%esp" ::"m"(tmp));
    asm volatile("popl %%gs\n\t"	  // 恢复 GS
                 "popl %%fs\n\t"	  // 恢复 FS
                 "popl %%es\n\t"	  // 恢复 ES
                 "popl %%ds\n\t"	  // 恢复 DS
                 "popal\n\t"		  // 恢复通用寄存器（EAX, EBX...）
                 "addl $4, %%esp\n\t" // intr
                 "addl $4, %%esp\n\t" // error node
                 "iret"				  // 中断返回
                 ::
                     : "memory", "cc");

    while (1)
        ;
    return;
}

asm volatile("movl %0, %%esp" ::"m"(tmp));
asm volatile("popl %%gs\n\t"      // 恢复 GS
             "popl %%fs\n\t"      // 恢复 FS
             "popl %%es\n\t"      // 恢复 ES
             "popl %%ds\n\t"      // 恢复 DS
             "popal\n\t"          // 恢复通用寄存器（EAX, EBX...）
             "addl $4, %%esp\n\t" // intr
             "addl $4, %%esp\n\t" // error node
             "iret"               // 中断返回
             ::
                 : "memory", "cc");

static inline void waitForInterrupt() {
    asm volatile("hlt");
}
...
while(1) {
    waitForInterrupt();
}

pid_t fork();

int sleep(uint32_t time);

int exit();

void sysPrint(struct StackFrame *sf) {
    ...
    for (i = 0; i < size; i++) {
        asm volatile("movb %%es:(%1), %0":"=r"(character):"r"(str+i));
        if(character == '\n') {
            displayRow ++;
            displayCol = 0;
            if(displayRow == 25) {
                displayRow = 24;
                displayCol = 0;
                scrollScreen();
            }
        } else {
            data = character | (0x0c << 8);
            pos = (80*displayRow + displayCol) * 2;
            asm volatile("movw %0, (%1)"::"r"(data),"r"(pos+0xb8000));
            displayCol ++;
            if(displayCol == 80) {
                displayRow ++;
                displayCol = 0;
                if(displayRow == 25){
                    displayRow = 24;
                    displayCol = 0;
                    scrollScreen();
                }
            }
        }
        asm volatile("int $0x20"); // 测试系统调用嵌套时间中断
    }
    ...
}

    tmpStackTop = pcb[current].stackTop;
    pcb[current].stackTop = pcb[current].prevStackTop;
    tss.esp0 = (uint32_t)&(pcb[current].stackTop);
    asm volatile("movl %0, %%esp"::"m"(tmpStackTop)); // switch kernel stack
    asm volatile("popl %gs");
    asm volatile("popl %fs");
    asm volatile("popl %es");
    asm volatile("popl %ds");
    asm volatile("popal");
    asm volatile("addl $8, %esp");
    asm volatile("iret");

        i = (current + 1) % MAX_PCB_NUM;
        while (i != current) {
            if (i != 0 && pcb[i].state == STATE_RUNNABLE)
                break;
            i = (i + 1) % MAX_PCB_NUM;
        }
        if (pcb[i].state != STATE_RUNNABLE)
            i = 0;
        current = i;
        /* echo pid of selected process */
        pcb[current].state = STATE_RUNNING;
        pcb[current].timeCount = 1;
        ....

void sysFork(struct StackFrame *sf);
void sysExec(struct StackFrame *sf);
void sysSleep(struct StackFrame *sf);
void sysExit(struct StackFrame *sf);
void sysGetPid(struct StackFrame *sf);
...

    printf("==============TEST 1 FOR WAIT=============\n");
    ret = fork();
    i = 4;
    pid = getpid();
    int ppid = getppid();
    if (ret == 0)
    {
        data = 2;
        while (i != 0)
        {
            i--;
            printf("Child Process (pid:%d, ppid:%d): Pong %d, %d;\n", pid, ppid, data, i);
            sleep(128);
        }
        exit();
        printf("If exit() worked, this message wouldn't appear.\n");
    }
    else if (ret != -1)
    {
        int wait_ret = 114514;
        wait_ret = wait();
        printf("first wait() returns: %d\n", wait_ret);
        wait_ret = wait();
        printf("second wait() returns: %d\n", wait_ret);
        data = 1;
        while (i != 0)
        {
            i--;
            printf("Parent Process (pid:%d, ppid:%d): Ping %d, %d;\n", pid, ppid, data, i);
            sleep(128);
        }
    }
    printf("===========TEST 1 FOR WAIT OVER===========\n\n");