#include <stdlib.h>
#include <string.h>

#include"fs_s256.h"
#include "module.h"

// 10-24-2000 added LBA formatting. Submit to main tree

// Set to one to compile in check disk.

#define SHELLBUFSIZE 1024
unsigned char shell_buf[SHELLBUFSIZE];

char working_buf[100];      // used by lex: must be global


typedef struct dispatcher {
	char *cmd;
	int  (*proc)( int argc, char **argv);
	char *helpstr;
} DISPATCHER;

DISPATCHER *lex(void);
int doquit(int agc, char **agv);
int dohelp(int agc, char **agv);
int dodskop(int agc, char **agv);
int dodskcl(int agc, char **agv);
int doselect(int agc, char **agv);

int domkdir(int agc, char **agv);
int dormdir(int agc, char **agv);
int dorm(int agc, char **agv);
int dodeltree(int agc, char **agv);
int domv(int agc, char **agv);
int docwd(int agc, char **agv);
int dols(int agc, char **agv);
int dotype(int agc, char **agv);
int pc_seedir(char *path);
int domkfs(int agc, char **agv);
int dofillfile(int agc, char **agv);
int dosetattr(int agc, char **agv);

#define DOFORMAT
#ifdef DOFORMAT
int doformat(int agc, char **agv);
#if (FAT32)
int domkfat32(int agc, char **agv);
#endif
#endif

void prompt_user(char *prompt, char *buf);

int DoLoad(int agc, char **agv);
int DoGetFile(int agc, char **agv);

#ifdef _USE_MMC_
int DoUSeNewMMC(int agc, char **agv);
#endif

/* From rtfsinit.c */
void print_device_names(void);


extern char Prompt[20];
//////////////////

DISPATCHER cmds[] =   {
	{ "", dohelp, ""},
	{ "CD", docwd, "CD PATH or CD to display PWD " },
	{ "DELETE",dorm, "DELETE PATH" },
	{ "DELTREE", dodeltree, "DELTREE PATH"},
	{ "DIR", dols, "DIR PATH" },

#ifdef DOFORMAT
	{ "FORMAT", doformat,"FORMAT (routine will prompt for arguments)"},
#endif

	{ "HELP", dohelp, "HELP" },
	{ "MKDIR", domkdir, "MKDIR PATH" },
	{ "RENAME",domv, "RENAME filename NEWNAME" },
	{ "RMDIR", dormdir, "RMDIR PATH" },
	{ "TYPE",dotype,"TYPE filename"},
	{ "SETATTR", dosetattr, "SETATTR D:PATH RDONLY|HIDDEN|SYSTEM|ARCHIVE|NORMAL"},
	{ "FILLFILE", dofillfile,"FILLFILE filename PATTERN NTIMES"},
	{ "LOAD", DoLoad, "LOAD" },
//	{ "LOAD1", DoLoad1, "LOAD1" },
	{ "GET", DoGetFile, "GET filename" },
#ifdef _USE_MMC_
	{ "NEWMMC", DoUSeNewMMC, "NEWMMC" },
#endif
	{ "QUIT", 0, "QUIT" },
};

int CmdNumber=sizeof(cmds)/sizeof(DISPATCHER);

// ********************************************************************
// THIS IS THE MAIN PROGRAM FOR THE TEST SHELL
// ********************************************************************
int Argc=0;
char *Argv[20];

void  DoCommand(void)
{
  DISPATCHER *pcmd;
	dohelp(0, 0);
	do {
		pcmd = lex();
		if(pcmd) {
			if (!pcmd->proc) break;
			pcmd->proc(Argc-1, Argv+1);
		}
		else break;
	}while(1);
}


int _Gets(char *str)
{ int cnt=0;
  int data;
  unsigned cnt0=0; 

	do {
		if(Kbhit()){
			data=Getch();
			if(data == '\r'){
				*str=0;
				Putch(data);
				Putch('\n');
				break;
			}
			else if(data == '\b'){
				if(cnt){
					str--;
					cnt--;
					Putch(data);
					Putch(' ');
					Putch('\b');
				}
			}
			else {
				Putch(data);
				*str++=data;
				cnt++;
			}
		}
		else {
			cnt0++;
			if(cnt0>2000){
				cnt0=0;
				RefreshWDT();
			}
		}	
	}while(1);
	return cnt;
}

// ********************************************************************
// get next command; process history log
void do_prompt(char *working_buf)
{
	Print(Prompt);
	_Gets(working_buf);
}

static char *Delimiter=" ,\r\t";
int CmdToArg(char *cmd)
{char *cmd1;

 	Argc=0;
	cmd1=strtok(cmd,Delimiter);
	while(cmd1){
		Argv[Argc]=cmd1;
//		Print("(%d)%s\r\n",argc++,cmd1);
		Argc++;
		cmd1=strtok(NULL,Delimiter);
	}
	return Argc;
}


DISPATCHER *lex(void)      /*__fn__*/
{ int i;

	do {
		do_prompt(working_buf);
		CmdToArg(working_buf);

		if(Argc>=1){
			for(i=0;i<CmdNumber;i++){
				if(!stricmp(Argv[0],cmds[i].cmd)){
					return &cmds[i];
				}
			}
		}
	}while(1);
}

int dohelp(int agc, char **agv)                             /*__fn__*/
{ int nprinted = 0,i;

	for(i=0;i<CmdNumber;i++){
		if(cmds[i].cmd)	Print("%s\r\n", cmds[i].helpstr);
		if (nprinted++ > 20) {
			Print("Press any key");
		    	Getch();
			Print("\r\n");
			nprinted = 0;
		}
	}
	return 1;
}


/* MKDIR PATH */
int domkdir(int agc, char **agv)                                /*__fn__*/
{
	if (agc == 1) {
		if (pc_mkdir(*agv))	return (1);
		else            return(0);
	}
	Print("Usage: MKDIR D:PATH\r\n");
	return (0);
}

/* RMDIR PATH */
int dormdir(int agc, char **agv)                                    /*__fn__*/
{

	Print("\r\n%s",*agv);DelayMs(0);
	if (agc == 1) {
		if (pc_rmdir(*agv))
			return (1);
		else	return(0);
	}
	Print("Usage: RMDIR D:PATH\r\n");
	return (0);
}

/* DELTREE PATH */
int dodeltree(int agc, char **agv)                                    /*__fn__*/
{

    if (agc == 1)
    {
        if (pc_deltree(*agv))
             return (1);
        else
            return(0);
    }
	 Print("Usage: DELTREE D:PATH\r\n");
	 return (0);
}

/* DELETE PATH *///delete file
char rmfil[EMAXPATH];
char rmpath[EMAXPATH];
char tfile[EMAXPATH];
int dorm(int agc, char **agv)                                       /*__fn__*/
{
	 DSTAT statobj;

	 if (agc == 1)
	 {
		  /* Get the path */
		  strcpy(&rmfil[0],*agv);
		  if (pc_gfirst(&statobj, &rmfil[0]))
		  {
				do
				{
					 /* Construct the path to the current entry */
					 pc_mfile((byte*) &tfile[0],(byte*) &statobj.fname[0], (byte*) &statobj.fext[0]);
					 pc_mpath((byte*)&rmpath[0],(byte*) &statobj.path[0],(byte*)&tfile[0] );
					 if (!pc_isdir(rmpath) && !pc_isvol(rmpath))
					 {
						  Print("deleting  --> %s\r\n",rmpath);
						  if (!pc_unlink( rmpath ) )
								Print("Can not delete:%s\r\n",rmpath);
					 }
				}  while(pc_gnext(&statobj));
				pc_gdone(&statobj);
		  }
		  return(1);
	 }
	 Print("Usage: DELETE D:PATH\r\n");
	 return(0);
}

/* RENAME PATH NEWNAME */
int domv(int agc, char **agv)                                      /*__fn__*/
{
	 int err;
	 if (agc == 2)
	 {
		  if (pc_mv(*agv , *(agv+1) ))
				 return (1);
		  else
		  {
				err=get_errno();
				if(err==PEEXIST)
					Print("File or directory already exists\r\n");
				else if(err==PENOSPC)
					Print("Write failed\r\n");
				else if(err==PENOENT)
					Print("Directory not found\r\n");


				return(0);
		  }
	 }

	 Print("Usage:  RENAME PATH NEWNAME \r\n");
    return (0);
}


/* CD PATH */
int docwd(int agc, char **agv)                                      /*__fn__*/
{
    char lbuff[100];

	if (agc == 1) {
		if (pc_set_cwd(*agv))	return(1);
		else {
			Print("?\r\n");
			return(0);
		}
	}
	else {
		if (pc_pwd(*agv,lbuff))	{
			Print("%s\r\n", lbuff);
			return(1);
		}
		else {
			Print("?\r\n");
			return(0);
		}
	}
}


/* DIR PATH */
int dols(int agc, char **agv)                                      /*__fn__*/
{
  int fcount;
  char *ppath;
  dword blocks_total, blocks_free;
  dword nfree;

//Print("\r\ndols:0");

	 ppath = 0;

	if (agc == 1){
		ppath = *agv;
	}
	else {
//Print("\r\ndols:before pc_pwd");
	  /* get the working dir of the default dir */
		if (pc_pwd("",(char *)shell_buf)) {
			ppath = (char *)shell_buf;
			Print("\r\nDirectory of %s\r\r\n\n",shell_buf);
			/* If not the root add a \\ */
			if (!(ppath[1] == '\\' && ppath[2] == '\0')) strcat(ppath, "\\");
#if (VFAT)
			strcat(ppath, "*");
#else
			strcat(ppath, "*.*");
#endif
		}
	}
//Print("\r\n---------");
	 /* These two lines added to make DIR A: display DIR A:*.* */
/*
	 if (ppath[1] == ':' && ppath[2] == '\0')
		  strcat(ppath,"*.*");
*/
//Print("\r\ndols:");

	if (ppath) {
		/* ======================================== */
		/* These two lines added to make DIR A: display DIR A:*.* */
		if (ppath[1] == ':' && ppath[2] == '\0')
				strcat(ppath,"*.*");
		/* End.. of change */
		/* ======================================== */
		/* Now do the dir */
//Print("\r\nNow do the dir");
		fcount = pc_seedir(ppath);
		/* And print the bytes remaining */
		pc_free(ppath, &blocks_total, &blocks_free);
		Print("Total %d File(s)   %ld KBytes free\r\n", fcount,blocks_free/2 );
	}
	else
		  Print("Usage: DIR PATH\r\n");

	return(1);

}


/* List directory, and return number of matching file */
int pc_seedir(char *path)                                          /*__fn__*/
{ char *dirstr;
  int fcount = 0;
  DSTAT statobj;

	/* Get the first match */
	if (pc_gfirst(&statobj, path)) {
		do{
			fcount++;

//			Print("%-8s.%-3s", &(statobj.fname[0]), &(statobj.fext[0]));
			if(strcmp(statobj.fext,"   "))
				Print("%-8s.%-3s", statobj.fname, statobj.fext);
//				Print("%s.%s", statobj.fname, statobj.fext);
			else 	Print("%-12s", statobj.fname);
			if (statobj.fattribute & AVOLUME){
				Print("   <Volume> ");
				goto bypass;
			}
			else if (statobj.fattribute & ADIRENT)
				Print("  <SUB-DIR> ");
			else
				Print(" %10ld ", statobj.fsize);
			Print("%02d-%02d-%4d",(statobj.fdate >> 5 ) & 0xf,
			        (statobj.fdate & 0x1f),1980+((statobj.fdate >> 9) & 0xff)); /* Date */
			Print(" %02d:%02d",(statobj.ftime >> 11) & 0x1f ,(statobj.ftime >> 5) & 0x3f);    /* timr */
bypass:
#if (VFAT)
			Print(" - %s", statobj.lfname);
#endif
			Print("  \r\n");
		}while(pc_gnext(&statobj));
		pc_gdone(&statobj); /* Call gdone to free up internal resources used by statobj */
	}
	return(fcount);
}

/* CAT PATH */

/* GETATTR PATH*/
int dosetattr(int agc, char **agv)                                    /*__fn__*/
{
byte attr;

    attr = 0;
    if (agc == 2)
    {
		  if (!pc_get_attributes(*agv, &attr))
        {
				Print("Can't get attributes\r\n");
            return(0);
		  }

        if (strcmp(*(agv+1),"RDONLY")==0)
				attr |= ARDONLY;
        else if (strcmp(*(agv+1),"HIDDEN")==0)
            attr |= AHIDDEN;
        else if (strcmp(*(agv+1),"SYSTEM")==0)
            attr |= ASYSTEM;
        else if (strcmp(*(agv+1),"ARCHIVE")==0)
            attr |= ARCHIVE;
        else if (strcmp(*(agv+1),"NORMAL")==0)
            attr =  ANORMAL;
        else
            goto usage;

        if (pc_set_attributes(*agv, attr))
            return(0);
		  else
        {
				Print("Set attributes failed\r\n");
            return(0);
        }
    }
usage:
	 Print("Usage: SETATTR D:PATH RDONLY|HIDDEN|SYSTEM|ARCHIVE|NORMAL\r\n");

	 return (0);
}

/* DEVINFO */

void prompt_user(char *prompt, char *buf)
{
	Print(prompt);
	_Gets(buf);
}

#ifdef DOFORMAT

int doformat(int agc, char **agv)                                    /*__fn__*/
{ char buf[10];
  char working_buffer[100];
  DDRIVE *pdr;
  int driveno;
  char temp[10];
  int disksize;
  dword partition_list[3];
  char path[10];
  DEV_GEOMETRY geometry;
  int n;

	 path[0]='A';
	 path[1]=':';
	 path[2]=0;

	 driveno = pc_parse_raw_drive(path);
	 if (driveno == -1 || !(pdr = pc_drno_to_drive_struct(driveno))) {
inval:
		  Print("Invalid drive.\r\n");
		  return(-1);
	 }

	if ( !(pdr->drive_flags&DRIVE_FLAGS_VALID) )	  goto inval;

//               int driveno, BOOLEAN ok_to_automount, BOOLEAN raw_access_requested, BOOLEAN call_crit_err
// call it twice to clear change conditions
//    if (!check_media(driveno, FALSE, TRUE, FALSE))
	if (!check_media(driveno, FALSE, TRUE, FALSE))  {
        	Print("Check media failed.\r\n");
		return(-1);
	}

    /* This must be called before calling the later routines */
	if (!pc_get_media_parms(path, &geometry)) {
		Print("get media geometry failed.\r\n");
		return(-1);
	}

	 /* Call the low level media format. Don't do this if formatting a
		 volume that is the second partition on the drive */
	Print("Press Y to format media\r\n");
	n=Getch();
	if (n=='Y' || n=='y'){
		Print("Calling media format\r\n");
        	if (!pc_format_media(path, &geometry)) {
        		Print("Media format failed.\r\n");
        		return(-1);
        	}
    	}

	/* Partition the drive if it needs it */
	if ( pdr->drive_flags & DRIVE_FLAGS_PARTITIONED )    {
        	Print("Press Y to partition media\r\n");
		n=Getch();
		if (n=='Y' || n=='y'){
			if (geometry.dev_geometry_lbas)	{
				do {
	     				Print("Press Y to USE LBA formatting, N to use CHS\r\n");
				    	n=Getch();
				    	if(n=='n' || n=='N' || n=='y' || n=='Y') break;
				}while (1);
				if (n == 'N' || n=='n')	{
					geometry.dev_geometry_lbas = 0;
				}
			}

			if (geometry.dev_geometry_lbas)	{
				Print("The drive is contains %ld lbas\r\n", geometry.dev_geometry_lbas);
    	       			prompt_user("Select the number of lbas for the first partition :", working_buffer);
        	   		partition_list[0]  = (dword)atol(working_buffer);
	           		partition_list[1]  = 0;

    	       			if (partition_list[0] != geometry.dev_geometry_lbas)  {
						Print("There are %ld lbas remaining \r\n",
	                   				geometry.dev_geometry_lbas - partition_list[0]);
					  	prompt_user("Select the number of lbas for the second partition :", working_buffer);
        	       				partition_list[1]  = (dword)atol(working_buffer);
				   		partition_list[2]  = 0;
	            		}
	           		if ((partition_list[0] == 0) || ((dword)(partition_list[0]+partition_list[1])  > geometry.dev_geometry_lbas))   {
        	       			prompt_user("Bad input press return to exit", working_buffer);
					return(-1);
	            		}
			}
			else {
				Print("The drive contains %d cylinders\r\n", geometry.dev_geometry_cylinders);
        			prompt_user("Select the number of cyls for the first partition :", working_buffer);
        			partition_list[0]  = (word)atoi(working_buffer);
				partition_list[1]  = 0;

        			if (partition_list[0] != geometry.dev_geometry_cylinders) {
					Print("There are %d cylinders remaining \r\n",
                			geometry.dev_geometry_cylinders - partition_list[0]);
            				prompt_user("Select the number of cyls for the second partition :", working_buffer);
            				partition_list[1]  = (dword)atol(working_buffer);
					partition_list[2]  = 0;
        			}
	           		if ((partition_list[0] == 0) || ((dword)(partition_list[0]+partition_list[1])  > geometry.dev_geometry_cylinders)){
					 prompt_user("Bad input press return to exit", working_buffer);
            	    			return(-1);
	            		}
			}
            		if (!pc_partition_media(path, &geometry, &partition_list[0])) {
               			prompt_user("Media partition failed press return to exit", working_buffer);
               			return(-1);
            		}
		}
	}

	/* Put the DOS format */
	Print("Press Y to format the volume\r\n");
	n=Getch();
	if (n == 'Y' || n== 'y') {
		if (!pc_format_volume(path, &geometry))  {
			Print("Format voulme failed\r\n");
			return(-1);
		}
		else {
			Print("Format success.\r\n");
		}
	}
	return (0);
}
#endif


int dotype(int agc, char **agv)                                 /*__fn__*/
{
	PCFD in_fd;
	word nread;
	DSTAT statobj;
	int i,line,newline=1;
	long lineno=0;

	if (agc < 1) {
		Print("Usage: TYPE file_name\r\n");
		return(0);
	}
	if ((in_fd = pc_open(*agv,(word) (PO_BINARY|PO_RDONLY),(word) (PS_IWRITE | PS_IREAD) ) ) < 0) {
		Print("Can't open %s\r\n", *agv);
		return(0);
	}
	line=0;
	while (1) {
		nread = (word)pc_read(in_fd,(byte*)shell_buf, 1024);
		if (nread > 0 && nread != (word)~0) {
			for(i=0;i<nread;i++){
				if(newline){
					newline=0;
					lineno++;
					Print("[%lu]",lineno);
				}
				Putch(shell_buf[i]);
				if(shell_buf[i]=='\n'){
					line++;
					newline=1;
					if(line>=24) {
						line=0;
						Print("Anykey to continue...('q' to stop)");
						if('q'==Getch()) goto EndType;;
						Puts("\r\n");
					}
				}
			}
		}//if (nread > 0 && nread != (word)~0)
		else 	break;
	}//while (1)
EndType:
	pc_close(in_fd);
	return(1);
}

int dofillfile(int agc, char **agv)                                 /*__fn__*/
{
    PCFD out_fd;
    char  workbuf[255];
    word bufflen;
    int ncopies;

	if(agc<3) goto ERROR;

	ncopies = atoi( agv[2] );
	if (!ncopies)  {
		Print("NTIMES is Invalid., Check your pattern (try quotes)\r\n");
		return(0);
	}

	if ((out_fd = pc_open(agv[0],(word) (PO_BINARY|PO_WRONLY|PO_CREAT|PO_TRUNC),(word) (PS_IWRITE | PS_IREAD) ) ) < 0) {
		Print("Cant open %s\r\n", *agv);
		return(0);
	}
	strcpy(workbuf, agv[1]);
	strcat(workbuf, "\r\n");
	bufflen = strlen(workbuf);
	if(agc==4) {
		  int i;
		  int c=atoi(*(agv+1))%256;

		  for(i=0;i<255;i++)workbuf[i]=c;
		  bufflen=255;
	}

	while (ncopies--) {
		if (pc_write(out_fd,(byte*)workbuf,(word)bufflen) != (int)bufflen){
			Print("Write failure\r\n");
			pc_close(out_fd);
			return(0);
		}
	}

	pc_close(out_fd);
	return(1);

ERROR:
	Print("Usage: FILLFILE PATH PATTERN number\r\n");
	return(0);
}

void LoadFile(void);
void LoadFile1(void);
int DoLoad(int agc, char **agv)
{
	LoadFile();
	return 1;
}

#ifdef _USE_MMC_
extern long MAXSIZE;
int DoUSeNewMMC(int agc, char **agv)
{
	if (!pc_ertfs_init()){
		Print("pc_ertfs_init failed");
	}
	else {
		Print("[MaxSize=%lu]",MAXSIZE);
	}
}
#endif