/*
 * RANDOM
 */

 #include <stdio.h>
 #include <stdlib.h>
 #include <ctype.h>
 #include <time.h>
 #include <mem.h>
 #include "global.h"
 #include "script.h"
 #include "aspi_rw.h"
 #include "kbd.h"
 #include "dmem.h"
 #include "buf.h"
 #include "print.h"

 #define BLK_SIZE 512
 #define MAX_BLKS 120

 static FLAG auto_init = FALSE;

/***************************************************************************
 *
 * rand_aspi(...)
 *
 ***************************************************************************/

 FLAG rand_aspi(

  char		       *cmd,
  struct SCRIPT_OBJ    *script,
  unsigned long	 	num_req,
  unsigned int   	scsi_id_first,
  unsigned int   	scsi_id_last,
  unsigned int   	num_blks_min,
  unsigned int   	num_blks_max,
  unsigned long  	blk_num_first,
  unsigned long	 	blk_num_last,
  U16			tag,
  unsigned int   	pattern)
 {
  char		*aspi_cmd;
  unsigned int   scsi_id;
  unsigned long  blk_num;
  int		 rand_num;
  int		 i = 0;
  FILE		*file_log;
  FLAG		 read_only = FALSE;
  time_t	 t;
  FLAG		 ret_val = TRUE;
  unsigned int   num_blks;
  long		 ltemp;
  time_t	 time_st,time_end;
  static long	 time_total = 0;
  static U32	 num_blks_total = 0;

  //
  //
  //

  printf("ASPI Random Request Generator\n");
  printf("\tNumber of requests to be generated: %ld\n",num_req);
  printf("\tSCSI ID range: %u to %u\n",scsi_id_first,scsi_id_last);
  printf("\tBlock Number range: %lu to %lu\n",blk_num_first,blk_num_last);
  printf("\tNumber of Blocks Range per Request: %u to %u\n",num_blks_min,
	 num_blks_max);

  if ((blk_num_first - blk_num_last + 1) < num_blks_max)
    {
     error("Max number of Blocks can cause overflow of last Block");
     return (FALSE);
     }

  if (!script->loop
      &&
      (auto_init
       ||
       kbd_get_yn("Initialize blocks for speced range of SCSI IDs and Block Numbers")
       )
      )
    {
     aspi_cmd = "W";				/* Spec write		   */

     printf("%sInitializing...\n",auto_init?"Automatically ":"");

     ltemp = ((dmem_size()/BLK_SIZE) - 5) / (script->aspi_allow_reqs + 1);
     if (ltemp > MAX_BLKS)
	ltemp = MAX_BLKS;
     if (ltemp < 0)
	ltemp = 1;

     ltemp = 10;/* */

     for (scsi_id = scsi_id_first; scsi_id <= scsi_id_last; scsi_id++)
       {
	num_blks = ltemp;
	if ((blk_num_last - blk_num_first + 1) < num_blks)
	   num_blks = blk_num_last - blk_num_first + 1;

	for (blk_num = blk_num_first; ; blk_num += num_blks)
	  {
	   if ((blk_num + num_blks - 1) > blk_num_last)
	      num_blks = (blk_num + num_blks) - blk_num_last - 1;

	   if (!aspi_rw(aspi_cmd,scsi_id,blk_num,num_blks,tag,pattern))
	      return (FALSE);

	   if (i > 100)				// Modulo 100
	     {
	      printf(	"SCSI ID: %d, up to block %ld%c",
			scsi_id,
			(long)(blk_num + num_blks - 1),0x0D);
	      i = 0;
	      }
	   else
	      i += num_blks;

	   if ((blk_num + num_blks) >= blk_num_last)
	      break;
	   }
	printf("\nSCSI ID: %d initialized.\n",scsi_id);
	}

     aspi_flush();
     aspi_stats('c');				/* Clear stats		   */
     diag_msg("Done initializing...\n");
     }

  diag_msg("Generating requests...\n");

  //
  // Log file
  //

  if (diag_here(DIAG_LOG_FILE))
    {
     file_log = fopen("AE.LOG","w");
     t = time(NULL);
     fprintf(	file_log,
		"*VER_COMPAT %d\n*ECHO File produced by Random Request Log, %s\n"
		"*REQ_OUTSTANDING %d\n",
		MIN_VC_NUM,ctime(&t),script->aspi_allow_reqs);
     }

  //
  // Request loop
  //

  if (cmd[1] && (toupper(cmd[1]) == 'R'))	// Read-only, i.e. all cache
    {
     read_only = TRUE;				// Spec read-only
     aspi_cmd = "R";				// Spec read
     }

  //
  // Time statistics
  //

  time_st = time(NULL);

  for (i = 0; i < num_req; i++)
    {
     if (!read_only)
       {
	rand_num = random(2);
	if (!rand_num)				/* Write?		   */
	   if (toupper(cmd[2]) == 'V')		// Write verify?
	      aspi_cmd = "WV";			// Spec write verify
	   else					// Normal write?
	      aspi_cmd = "W";			// Spec normal write
	else					/*			   */
	   aspi_cmd = "R";			/* Spec read		   */
	}

     //
     // Don;t allow number of blocks to cause an overflow by going
     // beyond the last block specified.
     //

     scsi_id  = random(scsi_id_last - scsi_id_first + 1) + scsi_id_first;
     num_blks  = random(num_blks_max - num_blks_min + 1) + num_blks_min;
     blk_num  = random(blk_num_last - blk_num_first + 1) + blk_num_first;

     if ((blk_num + num_blks - 1) > blk_num_last)		// Overflow?
	num_blks = blk_num_last - blk_num + 1;			// Adjust

     if (diag_here(DIAG_VERBOSE))
	printf("Random ASPI command: %s.\n",aspi_cmd);

     if (diag_here(DIAG_LOG_FILE))
	fprintf(file_log,"*ASPI %s %u %lu %u %u %u\n",
		aspi_cmd,
		scsi_id,
		blk_num,
		num_blks,
		tag,
		pattern);

     num_blks_total += num_blks;

// Test to mask bits 4 and 5

  if (cmd[1] && (toupper(cmd[1]) == 'M'))	// Mask?
     do
       {
	if (cmd[2] && (cmd[2] == '4'))		// Bits 4-7?
	  {
	   blk_num &= 0xFFFFFF0F;
	   break;
	   }
	if (cmd[2] && (cmd[2] == '0'))		// Bits 0-3?
	  {
	   blk_num &= 0xFFFFFFF0;
	   break;
	   }
	if (cmd[2] && (cmd[2] == 'B'))		// Both bits 4 & 5 and bits 8 & 9?
	  {
	   blk_num &= 0xFFFFFF00;
	   break;
	   }
	if (cmd[2] && (cmd[2] == 'F'))		// Detect 0xFF?
	  {
	   if ((blk_num & 0x000000FF) == 0x000000FF)
	      blk_num &= 0xFFFFFF00;
	   break;
	   }
	}
	while (FALSE);


     if (!aspi_rw(aspi_cmd,scsi_id,blk_num,num_blks,tag,pattern))
	break;

     if (kbd_double_esc())
       {
	if (kbd_get_yn("ABORT Random Request Generator"))
	  {
	   diag_msg("User abort during generation of random requests.\n");
	   ret_val = FALSE;
	   break;
	   }
	}

     if (!(i & 0x0000000F))			// Modulo 16
	printf("Up to request %d%c",i,0x0D);
     }

  printf("\n");

  //
  // Time statistics
  //

  time_end = time(NULL);
  time_total += difftime(time_end,time_st);

  printf("Averages:\n");
  printf("\tTotal Kbytes: %ld\n\tTotal secs: %ld\n",
	 (num_blks_total/2),time_total);
  printf("\tTotal: %ld Kbytes/sec\n",
	 (num_blks_total/2)/time_total);

  if (diag_here(DIAG_LOG_FILE))
    {
     fprintf(file_log,"*ECHO End of Script file\n");
     fprintf(file_log,"*ABORT\n");
     fclose(file_log);
     }

  return (ret_val);
  }

/***************************************************************************
 *
 * rand_auto_init(...)
 *
 ***************************************************************************/

 void rand_auto_init(void)
 {
  auto_init = TRUE;
  }