// IOI '97 Stack
// Simulation Module Definition File - simmod.cpp
// Dennis Burford
//

#include "stacklib.h"

void stackprimopen(char *filename, int *handle, int *error);
void stackprimclose(int handle, int *error);
void stackprimread(int *bytes, char *buffer, int handle, int *error);
void stackprimcreate(char *filename, int *error);
void stackprimappend(int handle, int *error);
void stackprimwrite(int *bytes, char *buffer, int handle, int *error);
void stackprimprint(char *string);
void stacklog (int *data, int bytes);

#define idGetX 100
 // int ();
 // width of storage space
#define idGetY 101
 // int ();
 // breadth of storage space
#define idGetZ 102
 // int ();
 // depth of storage space

#define idGetNextContainer 103
 // int ();
 // ID of next container

#define idGetNextAction 104
 // int ();
 // 1: store container 2: retrieve container

#define idGetNextStorageTime 105
 // int ();
 // Number of hours expected

#define idRefuseContainer 106
 // void ();
 // refuse incoming container

#define idStoreArrivingContainer 107
 // void (int x, int y);
 // store container on stack at (x,y)

#define idRemoveContainer 108
 // void (int x, int y);
 // removes the container at (x,y)

#define idMoveContainer 109
 // int (int x1, int y1, int x2, int y2);
 // move container from (x1,y1) to (x2,y2) 1: succes 0: failure

#define idInvalidDataFile 200

// Type Definitions

#define numtolog 6
typedef int logtype;
logtype stacklogged[numtolog];
#define bytestolog 12
#define LOGFILENAME "stack.out"
#define DATFILENAME "stack.dat"
typedef char boolean;
#define false 0
#define true 1
boolean stackinitialized = false;

int filefound = 0;

typedef struct ccontainer
{
  int id;
  int expected_time;
};

#ifdef __cplusplus
#define container ccontainer
#else
#define container struct ccontainer
#endif

container NULLcontainer;
/*
{
 int id;
 refused_container *next;
}; */

// Data

int moves;                              // for book-keeping
int refused;

int max_count, actions;                 // file counters
// ifstream dataFile;                      // files for input/output
// ofstream logFile;
int dataFilehandle;
int logFilehandle;

#define maxarea 100
#define maxrefusedcontainers 300
#define maxdepth 10

int _width,_breadth,_depth;                // dimensions of storage

int current_action;                     // container properties
container next;

//Stack<container> *space;                // storage space
//container *space; // 2Darray of containers...
container space[maxarea][maxdepth];

void setspace(int x, int y, container val)
{ if (x >= maxarea) return;
  if (y >= maxdepth) return;
  space[x][y] = val; };

void clearspace(int x, int y)
{ if (x >= maxarea) return;
  if (y >= maxdepth) return;
  space[x][y] = NULLcontainer; };

container getspace(int x, int y)
{ if (x >= maxarea) return NULLcontainer;
  if (y >= maxdepth) return NULLcontainer;
  return space[x][y]; };

int _heights[maxarea];                           // height map of storage

int refusedlist[maxrefusedcontainers];  // keeping track of refusals
int refusedlistlength = 0;

//
// Refused-Container-List Routines
//

void NewRefused(int id)                 // cont id. was refused
{
/*  refused_container *r;

  r = new refused_container;
  r->id = id;
  r->next = NULL;

  if (FirstRefused==NULL) FirstRefused = r;
  if (LastRefused != NULL) LastRefused->next = r;
  LastRefused = r; */
  if (refusedlistlength < maxrefusedcontainers)
	refusedlist[refusedlistlength++] = id;
}

int WasRefused(int id)                  // was cont id. refused ?
{ int i;
//  for (r=FirstRefused; (r != NULL)&&(r->id != id); r = r->next);
  for (i = 0; i < refusedlistlength; i++)
	if (refusedlist[i]==id) return 1;

  return 0;
//  return (r->id == id);
}

//
// 'Private' functions
//

void bye()
{ int error;
//  logFile.close();
//  stackprimclose(logFilehandle,&error); // should be closed anyway
//  dataFile.close();
  stackprimclose(dataFilehandle,&error);
  stacklogged[0] = idInvalidDataFile;
  stacklogged[1] = error;
  stacklog(stacklogged,bytestolog);
  stackprimprint("Invalid Data File....\n\r$");
//  exit(1);
}

void NextContainer()
{ int bytes,error;
  bytes = 2;
  // stackprimprint("NextContainer:\n\r$");
  if (actions < max_count)              // still more actions to do
  {
	// stackprimprint(" actions < max_count:\n\r$");
	do
	{
//        dataFile >> current_action;          // read new action details
//        dataFile >> next.id;
//        dataFile >> next.expected_time;
		// stackprimprint(" do:\n\r$");
		if (filefound)
		{
		  // stackprimprint("  file found:\n\r$");
		  stackprimread(&bytes,(char *)&current_action,dataFilehandle,&error);
		  stackprimread(&bytes,(char *)&next.id,dataFilehandle,&error);
		  stackprimread(&bytes,(char *)&next.expected_time,dataFilehandle,&error);
		}
		else
		{
			// stackprimprint("  !filefound:\n\r$");
			switch(actions+1)  // actions counted from 0 upwards...
			{ case 1 : current_action =     1;
						  next.id =            1;
						  next.expected_time = 7;
						  break;
			  case 2 : current_action =     1;
						  next.id =            2;
						  next.expected_time = 7;
						  break;
			  case 3 : current_action =     1;
						  next.id =            3;
						  next.expected_time = 7;
						  break;
			  case 4 : current_action =     1;
						  next.id =            4;
						  next.expected_time = 7;
						  break;
			  case 5 : current_action =     1;
						  next.id =            5;
						  next.expected_time = 7;
						  break;
			  case 6 : current_action =     1;
						  next.id =            6;
						  next.expected_time = 8;
						  break;
			  case 7 : current_action =     1;
						  next.id =            7;
						  next.expected_time = 9;
						  break;
			  case 8 : current_action =     2;
						  next.id =            1;
						  next.expected_time = 0;
						  break;
			  case 9 : current_action =     1;
						  next.id =            8;
						  next.expected_time = 8;   // Check that equal times are allowed: time = 8
						  break;
			  case 10: current_action =     2;
						  next.id =            2;
						  next.expected_time = 0;
						  break;
			  case 11: current_action =     2;
						  next.id =            3;
						  next.expected_time = 0;
						  break;
			  case 12: current_action =     2;
						  next.id =            4;
						  next.expected_time = 0;
						  break;
			  case 13: current_action =     2;
						  next.id =            5;
						  next.expected_time = 0;
						  break;
			  case 14: current_action =     2;
						  next.id =            6;
						  next.expected_time = 0;
						  break;
			  case 15: current_action =     2;
						  next.id =            8;
						  next.expected_time = 0;
						  break;
			  case 16: current_action =     2;
						  next.id =            7;
						  next.expected_time = 0;
						  break;
			}
		}

		actions++;
	// stackprimprint("  got action:\n\r$");
	// can't retrieve refused container
	} while ((current_action == 2) && WasRefused(next.id) && actions < max_count);
  }

  else if (actions == max_count)
  {
	// stackprimprint(" actions==max_count:\n\r$");
//       logFile << "Total moves: " << moves<< "-> " << -moves << endl;
//  logFile << "Total refusals: " << refused<< "-> " << -5*refused << endl;
//       logFile << "Total points: " << -moves + -5*refused << endl;
//       stackprimwrite(&bytes,(char *)&moves,logFilehandle,&error);
//  logFile.close(); // should be closed already
//       stackprimclose(logFilehandle,&error);
//       dataFile.close();
	 if (filefound) stackprimclose(dataFilehandle,&error);
	 next.id = 0;
	 next.expected_time = 0;
	 actions++;             // Don't do this section more than once
  }
 // stackprimprint("returning from NextContainer:\n\r$");
}

void initialize()
{
  int i,area,error,bytes;
  // stackprimprint("hello\n\r$");
  NULLcontainer.id = 0;
  NULLcontainer.expected_time = 0;
  bytes = 2;

//  logFile.open("stack.out");          // create log file
#ifndef NOLOG
  // stackprimprint("create logfile:\n\r$");
  stackprimcreate(LOGFILENAME,&error);
  // stackprimprint("open logfile:\n\r$");
  stackprimopen(LOGFILENAME,&logFilehandle,&error);
  // stackprimprint("close log file:\n\r$");
  stackprimclose(logFilehandle,&error);
#endif
//  dataFile.open("stack.dat");         // open data file
  // stackprimprint("open dat file:\n\r$");
  stackprimopen(DATFILENAME,&dataFilehandle,&error);

  if (error) // an error occurred opening file, so make up data
  {
	  // stackprimprint("error occured:\n\r$");
		filefound = 0;
		_width = 3;
		_breadth = 2;
		_depth = 3;

		max_count = 16;
  }
  else
  {
	  // stackprimprint("no error occured\n\r$");
		filefound = 1;
		//  dataFile >> _width >> _breadth >> _depth;// read in dimensions
		stackprimread(&bytes,(char *)&_width,dataFilehandle,&error);
		stackprimread(&bytes,(char *)&_breadth,dataFilehandle,&error);
		stackprimread(&bytes,(char *)&_depth,dataFilehandle,&error);
		if (_width+_breadth+_depth <= 0) bye();  // Invalid Data File
		//  dataFile >> max_count;              // number of actions
		stackprimread(&bytes,(char *)&max_count,dataFilehandle,&error);
  };
  area = _width*_breadth;               // area of storage space
  if (area > maxarea)
		{
			stackprimprint("Area too large..\n\r$");
			bye();
		};
  if (_depth > maxdepth)
		{
			stackprimprint("Depth too large..\n\r$");
			bye();
		};
//  space = new Stack<container>[area]; // create stack space
//  space = new container[area*_depth];
//  space = (container *)malloc(sizeof(container)*area*_depth);

//  _heights = new int[area];           // create height map
//  _heights = (int *)malloc(sizeof(int)*area);
	// stackprimprint("setting up:\n\r$");
	for (i=0; i< area; i++)               // clear height map
		_heights[i] = 0;

	moves = 0;                            // book-keeping
	refused = 0;
	current_action = 0;                   // undefined action
	actions = 0;                          // zero action counter
	// stackprimprint("calling nextcontainer:\n\r$");
	NextContainer();                      // read first container
	stackinitialized = 1;
	// stackprimprint("returning from initialize:\n\r$");
}

//
// 'Public' functions
//

int GetX()      // _width of storage space
{
  // stackprimprint("GetX\n\r$");
  if (!stackinitialized)             // If this is the 1st call
	 initialize();
  // stackprimprint("(initialized)\n\r$");
//  stacklogged[0] = idGetX;
//  stacklogged[1] = _width;
//  stacklog(stacklogged,bytestolog);
  return _width;
}

int GetY()      // _breadth of storage space
{
 if (!stackinitialized)
  initialize();

//  stacklogged[0] = idGetY;
//  stacklogged[1] = _breadth;
//  stacklog(stacklogged,bytestolog);
  return _breadth;
}

int GetZ()      // _depth of storage space
{
 if (!stackinitialized)
  initialize();

//  stacklogged[0] = idGetZ;
//  stacklogged[1] = _depth;
//  stacklog(stacklogged,bytestolog);
  return _depth;
}

// ID of next container
int GetNextContainer()
{
 if (!stackinitialized)
  initialize();

  stacklogged[0] = idGetNextContainer;
  stacklogged[1] = next.id;
  stacklog(stacklogged,bytestolog);
  return next.id;
}

// 1: store container 2: retrieve container
int GetNextAction()
{
 if (!stackinitialized)
  initialize();

  stacklogged[0] = idGetNextAction;
  stacklogged[1] = current_action;
  stacklog(stacklogged,bytestolog);
  return current_action;
}

// Number of hours expected
int GetNextStorageTime()
{
 if (!stackinitialized)
  initialize();

  stacklogged[0] = idGetNextStorageTime;
  stacklogged[1] = next.expected_time;
  stacklog(stacklogged,bytestolog);
  return next.expected_time;
}

// refuse incoming container
void RefuseContainer()
{
 if (!stackinitialized)
  initialize();

  if (current_action == 1)              // refuse to *STORE* container
  {
//       logFile << "Refusal: -5" << endl;
	 refused++;
	 stacklogged[0] = idRefuseContainer;
	 stacklogged[1] = next.id;
	 stacklogged[2] = refused;
	 stacklog(stacklogged,bytestolog);

	 NewRefused(next.id);
	 NextContainer();
  }
}

// store container on stack at (x,y)
void StoreArrivingContainer(int x, int y)
{
 if (!stackinitialized)
  initialize();

  stacklogged[0] = idStoreArrivingContainer;
  stacklogged[1] = x;
  stacklogged[2] = y;
  stacklog(stacklogged,bytestolog);

  if (x>0 && y>0 && x<=_width && y<=_breadth)
	  if ((next.id > 0) && (_heights[x + y*_width] < _depth))
	  {
	//      space[x + y*_width].Push(next);
		setspace(x+y*_width,_heights[x+y*_width]++,next);
	//      _heights[x + y*_width]++;
		NextContainer();
	  }
}

// romoves the container at (x,y)
void RemoveContainer(int x, int y)
{
 if (!stackinitialized)
  initialize();

  stacklogged[0] = idRemoveContainer;
  stacklogged[1] = x;
  stacklogged[2] = y;
  // even if logging we must do this for evaluation...

  if (x>0 && y>0 && x<=_width && y<=_breadth)
	 if ((next.id > 0) && (_heights[x + y*_width] > 0))
	 {
//      space[x + y*_width].Pop();
		if (getspace(x+y*_width,_heights[x+y*_width]-1).id != next.id)
		 return;
// only log if the removal is actually going to take place...
		stacklog(stacklogged,bytestolog);

		clearspace(x+y*_width,_heights[x + y*_width]--);
		NextContainer();
	  }
}

// move container from (x1,y1) to (x2,y2)  1: succes 0: failure
int MoveContainer(int x1, int y1, int x2, int y2)
{
 if (!stackinitialized)
  initialize();

  stacklogged[0] = idMoveContainer;
  stacklogged[1] = x1;
  stacklogged[2] = y1;
  stacklogged[3] = x2;
  stacklogged[4] = y2;

  if (x1>0 && y1>0 && x1<=_width && y1<=_breadth)
  if (x2>0 && y2>0 && x2<=_width && y2<=_breadth)
  if ((_heights[x1 + y1*_width] > 0) && (_heights[x2 + y2*_width] < _depth))
  {
//      space[x2 + y2*_width].Push( space[x1 + y1*_width].Pop_And_Top());
	container tomove;
	tomove = getspace(x1+y1*_width,_heights[x1 + y1*_width]-1); // top of 1
	clearspace(x1+y1*_width,_heights[x1+y1*_width]--); // pop from 1
	setspace(x2+y2*_width,_heights[x2 + y2*_width]++,tomove); // push to 2

//      logFile << "Move: -1" << endl;
	moves++;

	stacklogged[5] = 1;
	stacklog(stacklogged,bytestolog);
	return 1;
  }

  stacklogged[5] = 0;
  stacklog(stacklogged,bytestolog);
  return 0;
}

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------

//--------------------------------------------------------------------------
// stackprimopen: opens file...
//   error codes: 1 = invalid function
//                2 = file not found
//                3 = path not found
//                4 = no handles available
//                5 = access denied
//               12= invalid access code
//--------------------------------------------------------------------------
void stackprimopen(char *filename, int *handle, int *error)
{ int localhandle;
  int localerror;
asm {
	mov ah, 3Dh       // open file
	mov al, 2             // 2 = read and write access
	mov dx, word ptr [filename]  // ds:dx = name - zero terminated string
	int 21h

	jc open_error
	mov localhandle,ax
	mov word ptr localerror,0
	jmp proc_end
	}
open_error:
asm {
	mov localerror,ax
}
proc_end:
	*handle = localhandle;
	*error = localerror;
}

//--------------------------------------------------------------------------
// stackprimcreate: creates a file
//              truncates it if it exists already
//--------------------------------------------------------------------------
void stackprimcreate(char *filename, int *error)
{ int localerror;
asm {
	mov ah, 3Ch       // create file
	mov cx, 0             // file attribute is normal
	mov dx, word ptr [filename]  // ds:dx = name - zero terminated string
	int 21h

	jc create_error
	mov word ptr localerror,0
	jmp proc_end
	}
create_error:
asm {
	mov localerror,ax
}
proc_end:
	*error = localerror;
}

//-------------------------------------------------------------------------
//      close (int handle, int *error)
//      error code: 6 = invalid handle
//-------------------------------------------------------------------------

void stackprimclose(int handle, int *error)
{ int localerror;
asm {
	mov ah, 3Eh       // close file
	mov bx, handle
	int 21h

	jnc close_successful

	mov localerror,ax
}
close_successful:
asm {
	mov word ptr localerror,0
}
	*error = localerror;
}

//-------------------------------------------------------------------------
// stackprimwrite (int *bytes, char *buffer, int handle, int *error)
//     error codes: 5 = access denied
//                  6 = invalid handle
//-------------------------------------------------------------------------

void stackprimwrite(int *bytes, char *buffer, int handle, int *error)
{ int localbytes;
  int localerror;
  localbytes = *bytes;
  localerror = *error;
asm {
	mov ah, 40h                     // read file or device
	mov cx, localbytes
	mov dx, word ptr [buffer]       // ds:dx = pointer to buffer
	mov bx, handle
	int 21h

	jc write_error
	mov ax, localbytes        // number of bytes successfully written
	mov word ptr localerror,0
	jmp proc_end
}
write_error:
asm {
	mov localerror,ax
}
proc_end:
	*bytes = localbytes;
	*error = localerror;
}

//-------------------------------------------------------------------------
// stackprimappend (int handle, int *error)
//     error codes: 5 = access denied
//                  6 = invalid handle
//-------------------------------------------------------------------------

void stackprimappend(int handle, int *error)
{ int localerror;
  localerror = *error;
asm {
	mov ah, 42h                     // move file pointer
	mov al, 2                       // move relative to end of file
	mov cx, 0                       // high order word of distance to move
	mov dx, 0                       // low order word of distance to move
	mov bx, handle
	int 21h

	jc append_error
	mov word ptr localerror,0
	jmp proc_end
}
append_error:
asm {
	mov localerror,ax
}
proc_end:
	*error = localerror;
}

//-------------------------------------------------------------------------
//      read (int *bytes, char *buffer, int handle, int *error)
//     error codes: 5 = access denied
//                  6 = invalid handle
//-------------------------------------------------------------------------

void stackprimread(int *bytes, char *buffer, int handle, int *error)
{ int localbytes;
  int localerror;
  localbytes = *bytes;
  localerror = *error;
asm {
	mov ah, 3Fh                     // read file or device
	mov cx, localbytes
	mov dx, word ptr [buffer]       // ds:dx = pointer to buffer
	mov bx, handle
	int 21h

	jc read_error
	mov ax, localbytes        // number of bytes successfully read
	mov word ptr localerror,0
	jmp proc_end
}
read_error:
asm {
	mov localerror,ax
}
proc_end:
	*bytes = localbytes;
	*error = localerror;
}

//-------------------------------------------------------------------------
//      print (char *string)
//              string is terminated by '$'
//-------------------------------------------------------------------------

void stackprimprint(char *string)
{
	asm {
		mov ah, 9h              // display string
		mov dx, word ptr [string]
		int 21h
		}
}

//--------------------------------------------------------------------------

void stacklog (int *data, int bytes)
{
#ifndef NOLOG
	int handle, error=0, i;
	stackprimopen (LOGFILENAME, &handle, &error);
	stackprimappend (handle, &error);
	if (!filefound) for (i=0; i<bytes; i++) data[i] = 0;
	stackprimwrite (&bytes, (char *)data, handle, &error);
	stackprimclose (handle, &error);
#endif
}