///////             OS.cpp            /////////////////////////////////////
/*****************************************************
**		Lab 10+         CprE 308            Spring 99 **
**  Section: 4         Thursday 3-6                 **
**																	 **
**    Tim Downs Mullen        Chad Whipple          **
*****************************************************/

#include "os.h"
#include <stdio.h>
#include <dos.h>
#include <alloc.h>
#include <string.h>
#include <fstream.h>

#define TIMESLICE  3
#define STACKSIZE  1024
#define MAXPROCS 8

#define  EMPTY     0          //  process table entry is empty
#define  RUNNING   1          //  this is THE running thread
#define  READY     2          //  this thread is ready to run
#define  SLEEPING  3          //  sleeping until sleep_ticks = 0
#define  ZOMBIE    4          //  coming or going ... don't run it
#define  DONE      5

int code_segment;             //  CS address
int new_code_seg;             //  interrupt CS address
int CurrentThread;            //  global for currentthread running
int Suspend_interrupt=0;      //  OS_Suspend flag

clktime current_time;         //  clock structure

struct  ptable {
		char    Name[16];       //  thread name, in ASCII
		int     Status;         //  hold stack pointer for this thread
		int     SleepTicksLeft; //  if sleeping, this is when it wakes up
		int     CPUticks;       //  accumulated CPU clock ticks
		int     SliceTicksLeft; //  counts down from TIMESLICE to 0
		int     SP;             //  Stack Pointer
		int	  MemBlock;			//  Start of Memory Block for malloc/free
		int     Priority;       //  for future expansion.
} ProcessTable[MAXPROCS];


char *p_status(int stat)
{
			static char *what[6] = {"EMPTY   ", "RUNNING ", "READY   ",
											"SLEEPING", "ZOMBIE  ", "DONE    "};

			if(stat<0 || stat>5)
					 return "???";
			return what[stat];
}

void interrupt (*Old_Handler)(...);
void interrupt Clock_ISR(...);
//void interrupt (*Old_Handler_Suspend)(...);
//void interrupt Suspend_ISR(...);
void OS_KILL_KILL_KILL();


////////////////////////////////////////////////////////////////////////////
//                                                                        //
//
//Initializes the clock ISR and stores the old interrupt
// checks for small memory mode and returns 1
//else returns 0  on success
//                  //
////////////////////////////////////////////////////////////////////////////
int OS_Startup()
{
	int ds_flag; 	//for small code module checking
	int ss_flag;   //for small code module checking
	int i;         //happy forloop var

	char threadname[16] = "main";	//init for main threadname

	//for BDC conversion
	char hr, min, sec,
		temp1,
		temp2;

	 //grab this code's CS, Data Segment, and Stack Segment for error checking
	 //store in code_segment, ds_flag, and ss_flag respectively
	 asm
	 {
		mov code_segment, CS
		mov AX, DS
		mov ds_flag, AX
		mov AX, SS
		mov ss_flag, AX
	 }

	 //small code module check
	 if (ds_flag != ss_flag)
		{
			printf("\n\nNot small code mode, Piss off!!!\n\n");
			return(1);
		}


	// get the current time from DOS
	asm
	{
		MOV AH,2h
		INT 1Ah
		MOV hr,CH
		MOV min,CL
		MOV sec,DH
	 };

	 //Convert BCD to int
	 temp1 = hr;
	 temp2 = hr;
	 temp1 = (temp1 >> 4) * 10;     //convert tens
	 temp2 = (temp2 & 0x0f);        //convert ones
	 hr = temp1 + temp2;            //happy int value from BCD

	 temp1 = min;
	 temp2 = min;
	 temp1 = (temp1 >> 4) * 10;
	 temp2 = (temp2 & 0x0f);
	 min = temp1 + temp2;

	 temp1 = sec;
	 temp2 = sec;
	 temp1 = (temp1 >> 4) * 10;
	 temp2 = (temp2 & 0x0f);
	 sec = temp1 + temp2;



	 // Fill in the time structure here
	 current_time.hours   = hr;
	 current_time.minutes = min;
	 current_time.seconds = sec;

	 // Use getvect() to obtain the old contents of the clock Interrupt vector
	 Old_Handler = getvect(8);
	 // Set the vector to point to out ISR
	 setvect(8, Clock_ISR);
	 //obtain application old soft interrupt 0x60
	 //Old_Handler_Suspend = getvect(0x60);

	 //setup main in process table
	 // copy main into 16byte name buffer
	 for (i=0;i<16;i++)
		{
		  ProcessTable[0].Name[i] = threadname[i];
		}
	 ProcessTable[0].Status = RUNNING;
	 ProcessTable[0].CPUticks = 0;
	 ProcessTable[0].SliceTicksLeft = TIMESLICE;
	 ProcessTable[0].SleepTicksLeft = 0;

	 //sets all threads status to EMPTY
	 for(i=1;i<MAXPROCS;i++)
		{
			ProcessTable[i].Status = EMPTY;
		}


	 return(0);
}

/////////////////////////////////////////////////////////////////////////////
//Resets clock interrupt to the original vector	                           //
/////////////////////////////////////////////////////////////////////////////
void OS_Shutdown()
{
	  setvect(8, Old_Handler);
}

/////////////////////////////////////////////////////////////////////////////
// allocates new stack for thread, 'fakes' an interrupt to store all values for
// subsequent calls to this thread                                        //
////////////////////////////////////////////////////////////////////////////
int OS_CreateThread(char * threadname, int address)
{
 int save;
 int NewStack;
 int i;

 char Thread = MAXPROCS;
 char * cp;
 cp =  (char *)malloc(STACKSIZE);

 if(cp != NULL)
 {
	// find empty thread
	for(i=1;i<MAXPROCS;i++)
		{
			if(ProcessTable[i].Status == EMPTY)
				{
					Thread = i;
					i = MAXPROCS;
				}
		}

	//Testing for number of Threads Created
	if (Thread == MAXPROCS)
		{
			printf("\n\n****Memory Overflow, Too Many Threads, Loser***\n\n");
			return(-1);
		}
	 //copies the name of the Thread
	strncpy(ProcessTable[Thread].Name,threadname, 15);
	ProcessTable[Thread].Status = ZOMBIE;
	ProcessTable[Thread].CPUticks = 0;
	ProcessTable[Thread].SliceTicksLeft = 0;
	ProcessTable[Thread].SleepTicksLeft = 0;
	ProcessTable[Thread].MemBlock=(int)cp;

	cp=cp+STACKSIZE;
	asm
	{
		mov save, SP
		mov sp, cp

		mov BX, offset OS_KILL_KILL_KILL
		push BX

		pushf
		pop AX
		or AX, 0200h
		push AX

		push CS
		MOV  ax, address
		push ax

		push AX
		push BX
		push CX
		push DX
		push ES
		push DS
		push SI
		push DI

		push BP
		push SP

		mov NewStack, SP
		mov SP, save
	}//end asm
	ProcessTable[Thread].SP = NewStack;
 }//end if
 else
 {
	printf("\n\n****error on MALLOC()***\n\n");
	return(-1);
 } //end else

 return Thread;
}

//////////////////////////////////////////////////////////////////////
//Sets status of given thread to READY                              //
//////////////////////////////////////////////////////////////////////
void OS_StartThread(int pid)
{
	if (ProcessTable[pid].Status == ZOMBIE)
		{
			ProcessTable[pid].Status = READY;
		}
	else
	 {
		printf("\n\n***Night of the living dead buddy,");
		printf(" thread needs to be ZOMBIE or atleast not empty***\n\n");
	 }
}

///////////////////////////////////////////////////////////////////////////
//Suspends current Running Thread by setting slice ticks left equal to 0 //
///////////////////////////////////////////////////////////////////////////
void OS_Suspend()
{
	ProcessTable[CurrentThread].SliceTicksLeft = 0;
	Suspend_interrupt = 1;

	//Set soft interrupt to point to Clcok_ISR
	//setvect(0x60, Clock_ISR);

	asm
	{
		INT 08h
	}

}
///////////////////////////////////////////////////////////////////////////
//terminates thread
//frees up allocated memory and ProcessTable status = empty
//
//mine is not to wonder why,
//mine is but to do or die,
// gungho gungho gunho
// kill kill kill
///////////////////////////////////////////////////////////////////////////
void OS_KILL_KILL_KILL()
{
 int temp_thread = CurrentThread;

 free((void *)ProcessTable[temp_thread].MemBlock);
 ProcessTable[temp_thread].Status = EMPTY;
 OS_Suspend();
 }
///////////////////////////////////////////////////////////////////////////
//converts input millisecond time into clock ticks
//note: resolution is currently 55ms
//modifies ProcessTable SleepTicks Left
// then suspends
///////////////////////////////////////////////////////////////////////////
void OS_Sleep(int mil)
{
	mil = (int)(mil/55);
	ProcessTable[CurrentThread].SleepTicksLeft = mil;
   ProcessTable[CurrentThread].Status = SLEEPING;
	// Set status to ?????????
	OS_Suspend();
}

void OS_PrintProcessTable()
{
		  struct ptable *pt;
		  int     i;

		  printf("\n------------------------%02d:%02d:%02d---------------------------------\n",
								current_time.hours, current_time.minutes, current_time.seconds);
		  printf("PID  NAME                STATUS   SLEEP      CPU    SLICE    SP\n");
		  printf("-----------------------------------------------------------------\n");for(i=0; i<MAXPROCS; i++) {
					 pt = &ProcessTable[i];
					 printf("%3d  %-16s    ", i, pt->Name);
					 printf("%-7s    ", p_status(pt->Status));
					 printf("%-7d  %-4d     %-4d", pt->SleepTicksLeft,
								pt->CPUticks, pt-> SliceTicksLeft);
					 printf("  %04x\n", pt->SP);
		  }
		  printf("-----------------------------------------------------------------\n\n");

}
////////////////////////////////////////////////////////////////
// This is the clock ISR                                      //
// it is happy because it gets to count the
//18.2 ticks per second that it gets interrupted
//this is a pain in the ass because of the extra .2 ticks
//the grovie solution for this was a similar bastardization
//of the calander screw up with extra days and we implemented
//a "leap tick"
//BUT WAIT THATS NOT ALL!!!!!!!
//look what else you get:
//keeps track of CPU ticks spent in thread (yes main is a thread)
//round-robin thread switching
//AND it doesn't do any of this superkalifragalistic switching
//if the interrupted occurs outside of our code segment
////////////////////////////////////////////////////////////////

void interrupt Clock_ISR(...)
{
	static unsigned long tick = 0;
	static int leap = 1;
	static int tmpSP;
	int i;

	//check for suspend interruption and don't increment ticks if that is the case
	if (Suspend_interrupt == 0)
	{
		ProcessTable[CurrentThread].CPUticks++;
		ProcessTable[CurrentThread].SliceTicksLeft--;

		tick++;

		for(i=0; i<MAXPROCS;i++)
		  {
			 if(ProcessTable[i].Status==SLEEPING)
				{
					ProcessTable[i].SleepTicksLeft--;
					if (ProcessTable[i].SleepTicksLeft<=0)
						 ProcessTable[i].Status=READY;
				}
		  }


		//increment time structure
		if ((tick % 18) == 0)
		{
			if ((leap % 6) == 0)
				leap = 1;
		else
			{
				//keep track of time structure
				current_time.seconds ++;
				//check seconds
				if  (current_time.seconds > 59)
				{
					current_time.seconds = 0;
					current_time.minutes ++;
					}
				//check minutes
				if  (current_time.minutes > 59)
				{
					current_time.minutes = 0;
					current_time.hours ++;
					}
				// check hours
				if  (current_time.hours > 23) current_time.hours = 0;
			}//end else
			leap ++;
		 }//end time if
	 }//end Suspend if


	if (ProcessTable[CurrentThread].SliceTicksLeft <= 0)//checks time left
	{
		asm
		{
			mov AX, [BP+20]
			mov new_code_seg, AX
		}

		//interrupt CS check
		if (code_segment == new_code_seg)
		{
				//push BP for next return interrupt and save stack pointer
				asm
				{
					push BP
					mov tmpSP, SP
				}
				ProcessTable[CurrentThread].SP = tmpSP;

				if(ProcessTable[CurrentThread].Status == RUNNING)
					ProcessTable[CurrentThread].Status = READY;

				//search for next ready Thread and set time slice
				do
				 {
					CurrentThread = (CurrentThread+1)%MAXPROCS;
				 }while(ProcessTable[CurrentThread].Status != READY);
				tmpSP = ProcessTable[CurrentThread].SP;
				ProcessTable[CurrentThread].SliceTicksLeft=TIMESLICE;

				//get new threads stack pointer and old Base Pointer
				asm
				{
					mov SP, tmpSP
					pop BP
				}
		 }//end if CS test
	}//end if timeslice
	//return old_handler for suspend
	if (Suspend_interrupt == 1)
	{
		Suspend_interrupt = 0;
		//Set soft interrupt to point to old interrupt
		//setvect(0x60, Old_Handler_Suspend);
	}
	else Old_Handler();
}