// File:	LOOKDiskMonitor.C
// Author:	W. R. Carithers
//              Mike Rooney
// Description:	Implementation of the SSTF disk head scheduling monitor.
//

#include <stdlib.h>

#include <iostream>

#include "LOOKDiskMonitor.h"

//
// Constructor
//
// Must initialize all monitor variables, and allocate the request queue.
//
//

LOOKDiskMonitor::LOOKDiskMonitor( int procs, int cyls, DiskMonitor::motor_t mot ) :
	in_use( false ),
	curr_cyl( 0 ),
	waiting( 0 ),
        direction( 1 ),
	next_in( procs - 1 ),
	next_out( 0 ),
	DiskMonitor(procs,cyls,mot) {

	//
	// We can't have more than 'procs' waiting processes, so we
	// are safe in dimensioning the request queue to that number.
	// (Note that the DiskMonitor variable is n_procs, initialize
	// by the subconstructor above).
	//

	available = new Condition[ cyls ];
}

//
// Destructor
//

LOOKDiskMonitor::~LOOKDiskMonitor( void ) {

	// release our dynamically allocated request queue

	delete [ ] available;

}

//
// Name:	Acquire(n,cyl)
//
// Description:	Initiate a request from process 'n' for cylinder 'cyl'.
//

void LOOKDiskMonitor::Acquire( int n, int cyl ) {
	double entry_time;
	double serve_time;

	enter();

	//
	// Arrival time for this request.
	//

	entry_time = vtime;

	if( debugging ) {
		cout << "<<< acq: " << n << " wants " << cyl;
		cout << (in_use ? ", IN USE" : ", AVAIL");
		cout << ", curr_cyl " << curr_cyl;
		cout << ", waiting " << waiting;
	}

	//
	// If the disk is in use, we must wait.
	//
	// Wait on the current cylinder.
	//
	if( in_use ) {

		waiting += 1;	// one more in the queue

		//next_in = (next_in + 1) % n_procs;  // circular increment
		wait( available[cyl] );	    // block this process

		waiting -= 1;	// we're back!
	}

	//
	// At this point, we know that we can access the disk.
	// Simulate moving the heads to our desired cylinder position.
	//

	busy( abs(curr_cyl - cyl) );
	curr_cyl = cyl;

	//
	// Record our service time.
	//

	serve_time = vtime;

	req_count[n] += 1;
	req_wait[n] += serve_time - entry_time;

	//
	// Mark the disk as in use.
	//

	in_use = true;

	if( debugging ) {
		cout << endl;
	}

	leave();
}

//
// Name:	Release(n)
//
// Description:	Release the disk so that another process can use it.
//

void LOOKDiskMonitor::Release( int n ) {
	enter();

	if( debugging ) {
		cout << ">>> rel: " << n << ", dir ";
		cout << ", curr_cyl " << curr_cyl;
		cout << ", waiting " << waiting;
	}

	//
	// No longer busy.
	//

	in_use = false;

	//
	// If someone is waiting, wake up the next process.
	//
	// Check in the current direction to see if anyone is
        // waiting. If so, satisfy their request and continue
        // in the same direction. Otherwise, change direction

	if( waiting > 0 ) {
          bool found = false;

          if (direction == 1) {
            for (int i = curr_cyl; i < n_cyls; i++) {
              if ( queue(available[i]) ) {
                signal( available[i] );
                found = true;
                break;
              }
            }
            if (!found) {
              direction = -1;
            }
          } else {
            for (int i = curr_cyl; i >= 0; i--) {
              if ( queue(available[i]) ) {
                signal( available[i] );
                found = true;
                break;
              }
            }
            if (!found) {
              direction = 1;
            }
          }
        }


	if( debugging ) {
		cout << endl;
	}

	leave();
}