/*

Directory Opus 4
Original GPL release version 4.12
Copyright 1993-2000 Jonathan Potter

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

All users of Directory Opus 4 (including versions distributed
under the GPL) are entitled to upgrade to the latest version of
Directory Opus version 5 at a reduced price. Please see
http://www.gpsoft.com.au for more information.

The release of Directory Opus 4 under the GPL in NO WAY affects
the existing commercial status of Directory Opus 5.

*/

#include "diskop.h"

void main(argc,argv)
int argc;
char *argv[];
{
	struct DOpusRemember *memkey=NULL;
	struct VisInfo *vis;
	char **dummy_args,*port,*opbuf,*stringname;
	struct StringData *stringdata;
	int arg;

	if (!(DOpusBase=(struct DOpusBase *)OpenLibrary("dopus.library",18)))
#ifdef __SASC_60
		__exit(0);
#else
		_exit(0);
#endif

	if ((vis=LAllocRemember(&memkey,sizeof(struct VisInfo),MEMF_CLEAR)) &&
		(dummy_args=LAllocRemember(&memkey,sizeof(char *)*16,MEMF_CLEAR)) &&
		(opbuf=LAllocRemember(&memkey,80,MEMF_CLEAR)) &&
		(stringname=LAllocRemember(&memkey,80,MEMF_CLEAR)) &&
		(stringdata=LAllocRemember(&memkey,sizeof(struct StringData),MEMF_CLEAR))) {

		IntuitionBase=DOpusBase->IntuitionBase;
		GfxBase=DOpusBase->GfxBase;
		IconBase=OpenLibrary("icon.library",0);

		if (argc==0) {
			struct WBStartup *startup;
			int arg;

			startup=(struct WBStartup *)argv;
			for (arg=0;arg<startup->sm_NumArgs && arg<16;arg++) {
				dummy_args[arg]=startup->sm_ArgList[arg].wa_Name;
				++argc;
			}
			argv=dummy_args;

			if (IconBase) {
				struct DiskObject *dobj;
				char *str;

				if (dobj=GetDiskObject(argv[0])) {
					if (str=FindToolType(dobj->do_ToolTypes,"OPERATION")) {
						LStrnCpy(opbuf,str,80);
						argv[1]=opbuf;
						if (argc<2) argc=2;
					}
					FreeDiskObject(dobj);
				}
			}
		}

		if (argc>1) {
			if (argc>2 && argv[2][0]=='&') {
				arg=3;
				port=&argv[2][1];
			}
			else {
				arg=2;
				port=NULL;
			}
			get_vis_info(vis,port);

			stringdata->default_table=default_strings;
			stringdata->string_count=STR_STRING_COUNT;
			stringdata->min_version=STRING_VERSION;

			if (vis->vi_language)
				lsprintf(stringname,"DOpus:Modules/S/DM_Disk_%s.STR",vis->vi_language);
			else stringname[0]=0;

			if (ReadStringFile(stringdata,stringname)) {
				string_table=stringdata->string_table;

				switch (argv[1][0]) {
					case 'f':
					case 'F':
						diskop_format(vis,port,argc-arg,&argv[arg]);
						break;
					case 'd':
					case 'D':
						diskop_diskcopy(vis,port,argc-arg,&argv[arg]);
						break;
					case 'i':
					case 'I':
						diskop_install(vis,argc-arg,&argv[arg]);
						break;
				}
			}
			FreeStringFile(stringdata);
		}

		if (IconBase) CloseLibrary(IconBase);
	}

	LFreeRemember(&memkey);

	CloseLibrary((struct Library *)DOpusBase);
#ifdef __SASC_60
	__exit(0);
#else
	_exit(0);
#endif
}

void get_vis_info(vis,portname)
struct VisInfo *vis;
char *portname;
{
	vis->vi_fg=1; vis->vi_bg=0;
	vis->vi_shine=2; vis->vi_shadow=1;
	vis->vi_font=NULL;
	vis->vi_screen=NULL;
	vis->vi_stringcol[0]=1; vis->vi_stringcol[1]=0;
	vis->vi_activestringcol[0]=1; vis->vi_activestringcol[1]=0;
	vis->vi_flags=VISF_WINDOW;
	vis->vi_language=NULL;

	if (dopus_message(DOPUSMSG_GETVIS,(APTR)vis,portname)) return;

	if (IntuitionBase->LibNode.lib_Version>35) {
		struct DrawInfo *drinfo;
		struct Screen *pub;

		if (pub=LockPubScreen(NULL)) {
			drinfo=GetScreenDrawInfo(pub);
			vis->vi_shine=drinfo->dri_Pens[SHINEPEN];
			vis->vi_shadow=drinfo->dri_Pens[SHADOWPEN];
			vis->vi_fg=drinfo->dri_Pens[TEXTPEN];
			vis->vi_bg=drinfo->dri_Pens[BACKGROUNDPEN];
			FreeScreenDrawInfo(pub,drinfo);
			UnlockPubScreen(NULL,pub);
		}
	}
}

dopus_message(cmd,data,portname)
int cmd;
APTR data;
char *portname;
{
	struct MsgPort *port,*replyport;
	struct DOpusMessage msg;

	Forbid();
	if (portname && portname[0] &&
		(port=FindPort(portname)) &&
		(replyport=LCreatePort(NULL,0))) {
		msg.msg.mn_Node.ln_Type=NT_MESSAGE;
		msg.msg.mn_Node.ln_Name=NULL;
		msg.msg.mn_ReplyPort=replyport;
		msg.msg.mn_Length=(UWORD)sizeof(struct DOpusMessage);
		msg.command=cmd;
		msg.data=data;
		PutMsg(port,(struct Message *)&msg);
		Permit();
		WaitPort(replyport);
		GetMsg(replyport);
		LDeletePort(replyport);
		return(1);
	}
	Permit();
	return(0);
}

void fill_out_req(req,vis)
struct RequesterBase *req;
struct VisInfo *vis;
{
	req->rb_fg=vis->vi_fg;
	req->rb_bg=vis->vi_bg;
	req->rb_shine=vis->vi_shine;
	req->rb_shadow=vis->vi_shadow;
	req->rb_font=vis->vi_font;
	req->rb_flags&=~RBF_WINDOWCENTER;
	if (vis->vi_screen) {
		if (vis->vi_flags&VISF_WINDOW) {
			req->rb_screen=((struct Window *)vis->vi_screen)->WScreen;
			req->rb_window=(struct Window *)vis->vi_screen;
			req->rb_flags|=RBF_WINDOWCENTER;
		}
		else req->rb_screen=vis->vi_screen;
	}
	else req->rb_screen=NULL;
}

struct Gadget *addreqgadgets(reqbase,gadgets,mask,count)
struct RequesterBase *reqbase;
struct TagItem **gadgets;
int mask,*count;
{
	int gad;
	struct Gadget *gadget=NULL,*newgadget,*firstgadget;

	for (gad=0;;gad++) {
		if (!gadgets[gad]) break;
		if (!(mask&(1<<gad))) {
			if (!(newgadget=(struct Gadget *)
				AddRequesterObject(reqbase,gadgets[gad]))) return(NULL);
			if (gadget) gadget->NextGadget=newgadget;
			else firstgadget=newgadget;
			gadget=newgadget;
			++*count;
		}
	}
	AddGadgets(reqbase->rb_window,firstgadget,NULL,gad,reqbase->rb_shine,reqbase->rb_shadow,1);
	return(firstgadget);
}

int error_rets[]={1,0};

check_error(reqbase,str,gadtxt)
struct RequesterBase *reqbase;
char *str;
int gadtxt;
{
	struct DOpusSimpleRequest req;
	char *error_gads[3];

	req.text=str;
	error_gads[0]=string_table[gadtxt];
	error_gads[1]=string_table[STR_CANCEL];
	error_gads[2]=NULL;
	req.gads=error_gads;
	req.rets=error_rets;
	req.hi=reqbase->rb_shine;
	req.lo=reqbase->rb_shadow;
	req.fg=reqbase->rb_fg;
	req.bg=reqbase->rb_bg;
	req.strbuf=NULL;
	req.flags=SRF_RECESSHI;
	if (reqbase->rb_flags&RBF_BORDERS) req.flags|=SRF_BORDERS;
	req.font=reqbase->rb_font;
	req.title="DOpus_Disk";
	return(DoSimpleRequest(reqbase->rb_window,&req));
}

ULONG do_checksum(sector)
ULONG *sector;
{
	ULONG sum;
	int i;

	for (sum=0,i=0;i<(TD_SECTOR>>2);i++) sum+=sector[i];
	return(sum);
}

do_writeblock(device_req,buffer,offset)
struct IOExtTD *device_req;
APTR buffer;
ULONG offset;
{
	device_req->iotd_Req.io_Command=CMD_WRITE;
	device_req->iotd_Req.io_Data=buffer;
	device_req->iotd_Req.io_Length=TD_SECTOR;
	device_req->iotd_Req.io_Offset=offset*TD_SECTOR;
	return((int)DoIO((struct IORequest *)device_req));
}

void inhibit_drive(device,state)
char *device;
ULONG state;
{
	struct MsgPort *handler;

	if (DOSBase->dl_lib.lib_Version<36) {
		if (handler=(struct MsgPort *)DeviceProc(device))
			SendPacket(handler,ACTION_INHIBIT,&state,1);
	}
	else Inhibit(device,state);
}

void border_text(reqbase,border,infobuf)
struct RequesterBase *reqbase;
Object_Border *border;
char *infobuf;
{
	struct RastPort *rp;

	rp=reqbase->rb_window->RPort;
	SetAPen(rp,reqbase->rb_bg);
	RectFill(rp,border->ob_left,border->ob_top,
		border->ob_left+border->ob_width-1,border->ob_top+border->ob_height-1);
	SetAPen(rp,reqbase->rb_fg);

	if (infobuf) {
		ObjectText(reqbase,
			border->ob_left,
			border->ob_top,
			border->ob_width,
			border->ob_height,
			infobuf,
			TEXTPOS_CENTER|TEXTPOS_F_NOUSCORE);
	}
}

struct DeviceNode *find_device(name)
char *name;
{
	struct RootNode *rootnode;
	struct DosInfo *dosinfo;
	struct DeviceNode *devnode;
	char matchname[32],devname[32];
	int a;

	if (!name) return(NULL);

	for (a=0;name[a];a++) {
		if (name[a]==':') break;
		matchname[a]=name[a];
	}
	matchname[a]=0;

	Forbid();

	rootnode=(struct RootNode *) DOSBase->dl_Root;
	dosinfo=(struct DosInfo *) BADDR(rootnode->rn_Info);
	devnode=(struct DeviceNode *) BADDR(dosinfo->di_DevInfo);

	while (devnode) {
		if (devnode->dn_Type==DLT_DEVICE && devnode->dn_Task) {
			BtoCStr((BPTR)devnode->dn_Name,devname,32);
			if (strcmp(devname,matchname)==0) {
				Permit();
				return(devnode);
			}
		}
		devnode=(struct DeviceNode *) BADDR(devnode->dn_Next);
	}

	Permit();
	return(NULL);
}

char **get_device_list(key,alike)
struct DOpusRemember **key;
char *alike;
{
	struct RootNode *rootnode;
	struct DosInfo *dosinfo;
	struct DeviceNode *devnode,*alikenode=NULL;
	int count=1;
	char **listtable,devname[32];

	if (alike) alikenode=find_device(alike);

	Forbid();

	rootnode=(struct RootNode *) DOSBase->dl_Root;
	dosinfo=(struct DosInfo *) BADDR(rootnode->rn_Info);
	devnode=(struct DeviceNode *) BADDR(dosinfo->di_DevInfo);

	while (devnode) {
		if (devnode->dn_Type==DLT_DEVICE && devnode->dn_Task &&
			devnode->dn_Startup>512) {
			if (!alikenode || like_devices(devnode,alikenode))
				++count;
		}
		devnode=(struct DeviceNode *) BADDR(devnode->dn_Next);
	}

	if (listtable=LAllocRemember(key,count*4,MEMF_CLEAR)) {
		devnode=(struct DeviceNode *) BADDR(dosinfo->di_DevInfo);
		count=0;
		while (devnode) {
			if (devnode->dn_Type==DLT_DEVICE && devnode->dn_Task &&
				devnode->dn_Startup>512) {
				if (!alikenode || like_devices(devnode,alikenode)) {
					BtoCStr((BPTR)devnode->dn_Name,devname,32);
					strcat(devname,":");
					if (listtable[count]=LAllocRemember(key,strlen(devname)+1,0))
						strcpy(listtable[count],devname);
					++count;
				}
			}
			devnode=(struct DeviceNode *) BADDR(devnode->dn_Next);
		}
		sort_device_list(listtable);
	}

	Permit();
	return(listtable);
}

void sort_device_list(table)
char **table;
{
	int count,gap,i,j;
	char *temp;

	for (count=0;table[count];count++);

	for (gap=count/2;gap>0;gap/=2)
		for (i=gap;i<count;i++)
			for (j=i-gap;j>=0;j-=gap) {
				if (LStrCmpI(table[j],table[j+gap])<=0) break;
				temp=table[j];
				table[j]=table[j+gap];
				table[j+gap]=temp;
			}
}

check_disk(reqbase,device_req,name,prot)
struct RequesterBase *reqbase;
struct IOExtTD *device_req;
char *name;
int prot;
{
	char errorbuf[80];

	FOREVER {
		device_req->iotd_Req.io_Command=TD_CHANGESTATE;
		DoIO((struct IORequest *)device_req);
		if (device_req->iotd_Req.io_Actual) {
			lsprintf(errorbuf,string_table[STR_NODISKPRESENT],name);
			if (!(check_error(reqbase,errorbuf,STR_RETRY))) return(0);
		}
		else break;
	}
	if (prot) {
		FOREVER {
			device_req->iotd_Req.io_Command=TD_PROTSTATUS;
			DoIO((struct IORequest *)device_req);
			if (device_req->iotd_Req.io_Actual) {
				lsprintf(errorbuf,string_table[STR_DISKWRITEPROTECTED],name);
				if (!(check_error(reqbase,errorbuf,STR_RETRY))) return(0);
			}
			else break;
		}
	}
	return(1);
}

check_abort(window)
struct Window *window;
{
	struct IntuiMessage *msg;
	int abort=0;

	while (msg=(struct IntuiMessage *)GetMsg(window->UserPort)) {
		if (msg->Class==IDCMP_MOUSEBUTTONS && msg->Code==MENUDOWN)
			abort=1;
		ReplyMsg((struct Message *)msg);
	}
	return(abort);
}

check_blank_disk(reqbase,device,action)
struct RequesterBase *reqbase;
char *device,*action;
{
	BPTR lock;
	struct InfoData __aligned info;
	struct FileInfoBlock __aligned fib;
	struct Process *myproc;
	APTR wsave;
	char blank=0,*message,diskname[40],sizebuf[20];
	int ret=1;

	if (!(message=AllocMem(400,MEMF_CLEAR))) return(1);

	myproc=(struct Process *)FindTask(NULL);
	wsave=myproc->pr_WindowPtr;
	myproc->pr_WindowPtr=(APTR)-1;

	if (lock=Lock(device,ACCESS_READ)) {
		Info(lock,&info);
		switch (info.id_DiskType) {
			case ID_UNREADABLE_DISK:
			case ID_NOT_REALLY_DOS:
				blank=1;
				break;
			default:
				Examine(lock,&fib);
				strcpy(diskname,fib.fib_FileName);
				if (!(ExNext(lock,&fib))) blank=1;
				break;
		}
		UnLock(lock);
	}
	else blank=1;

	myproc->pr_WindowPtr=wsave;

	if (!blank && action) {
		getsizestring(sizebuf,info.id_NumBlocksUsed*info.id_BytesPerBlock);

		lsprintf(message,string_table[STR_DISK_NOT_BLANK],
			device,diskname,sizebuf,action);

		if (!(check_error(reqbase,message,STR_PROCEED))) ret=0;
	}
	FreeMem(message,400);
	return(ret);
}

void set_env(action,gadget,count,list)
char *action;
struct Gadget *gadget;
int count;
struct DOpusListView *list;
{
	int file,listid='LIST';
	UWORD len;
	char envname[80],null=0;

	lsprintf(envname,"ENV:DOpus_%s.prefs",action);
	if (!(file=Open(envname,MODE_NEWFILE))) return;

	while (gadget && count--) {
		if (gadget->Activation&GACT_TOGGLESELECT) {
			Write(file,&gadget->GadgetID,sizeof(UWORD));
			Write(file,&gadget->GadgetType,sizeof(UWORD));
			switch (gadget->GadgetType) {
				case GTYP_BOOLGADGET:
					Write(file,&gadget->Flags,sizeof(UWORD));
					break;
				case GTYP_STRGADGET:
					len=strlen(((struct StringInfo *)gadget->SpecialInfo)->Buffer)+1;
					Write(file,&len,sizeof(UWORD));
					Write(file,((struct StringInfo *)gadget->SpecialInfo)->Buffer,len);
					if (len%2) Write(file,&null,1);
					break;
			}
		}
		else ++count;
		gadget=gadget->NextGadget;
	}
	while (list) {
		Write(file,&listid,sizeof(ULONG));
		Write(file,list->items[list->itemselected],
			(len=(strlen(list->items[list->itemselected])+1)));
		if (len%2) Write(file,&null,1);
		list=list->next;
	}
	Close(file);
}

void get_env(action,firstgadget,count,list)
char *action;
struct Gadget *firstgadget;
int count;
struct DOpusListView *list;
{
	int file,size,a,b,*lbuf;
	char envname[80],*nptr;
	struct Gadget *gadget;
	UWORD gadgettype,gadgetid,len,*buf;

	lsprintf(envname,"ENV:DOpus_%s.prefs",action);
	if (!(file=Open(envname,MODE_OLDFILE))) return;

	Seek(file,0,OFFSET_END);
	size=Seek(file,0,OFFSET_BEGINNING);

	if (!(buf=(UWORD *)AllocMem(size,MEMF_CLEAR))) {
		Close(file);
		return;
	}

	Read(file,(char *)buf,size);
	Close(file);

	for (a=0;a<size/2;) {
		lbuf=(int *)&buf[a];
		if (lbuf[0]=='LIST') {
			a+=2;
			nptr=(char *)&buf[a];
			if (list) {
				for (b=0;list->items[b];b++) {
					if (LStrCmpI(nptr,list->items[b])==0) {
						list->itemselected=b;
						break;
					}
				}
				list=list->next;
			}
			b=strlen(nptr)+1;
			if (b%2) ++b;
			a+=b/2;
			continue;
		}
		gadgetid=buf[a++];
		gadgettype=buf[a++];
		gadget=firstgadget;
		while (gadget) {
			if (gadget->GadgetID==gadgetid && gadget->GadgetType==gadgettype)
				break;
			gadget=gadget->NextGadget;
		}
		if (!count--) gadget=NULL;
		switch (gadgettype) {
			case GTYP_BOOLGADGET:
				if (gadget) gadget->Flags=buf[a];
				++a;
				break;
			case GTYP_STRGADGET:
				len=buf[a++];
				if (gadget) strcpy(((struct StringInfo *)gadget->SpecialInfo)->Buffer,(char *)&buf[a]);
				if (len%2) ++len;
				a+=len/2;
				break;
		}
	}
	FreeMem(buf,size);
}

void fix_listview(reqbase,list)
struct RequesterBase *reqbase;
struct DOpusListView *list;
{
	list->window=reqbase->rb_window;
	list->flags|=DLVF_LEAVE|DLVF_SLOW;
	list->sliderwidth=8;
	list->slidercol=reqbase->rb_fg;
	list->sliderbgcol=reqbase->rb_bg;
	list->textcol=reqbase->rb_fg;
	list->boxhi=reqbase->rb_shine;
	list->boxlo=reqbase->rb_shadow;
	list->arrowfg=reqbase->rb_fg;
	list->arrowbg=reqbase->rb_bg;
	list->itemfg=reqbase->rb_fg;
	list->itembg=reqbase->rb_bg;
}

void select_device(list,exclude)
struct DOpusListView *list;
char *exclude;
{
	int def=-1,item;

	for (item=0;list->items[item];item++) {
		if (!exclude || LStrCmpI(list->items[item],exclude)) {
			if (list->items[item][0]=='D' &&
				list->items[item][1]=='F' &&
				list->items[item][3]==':') {
				def=item;
				break;
			}
			if (def==-1) def=item;
		}
	}
	if (def==-1) def=0;
	list->itemselected=def;
	list->topitem=def;
}

like_devices(node,likenode)
struct DeviceNode *node,*likenode;
{
	struct DosEnvec *envec,*likeenvec;
	struct FileSysStartupMsg *startup,*likestartup;

	startup=(struct FileSysStartupMsg *)BADDR(node->dn_Startup);
	likestartup=(struct FileSysStartupMsg *)BADDR(likenode->dn_Startup);
	envec=(struct DosEnvec *)BADDR(startup->fssm_Environ);
	likeenvec=(struct DosEnvec *)BADDR(likestartup->fssm_Environ);

	if (envec->de_SizeBlock!=likeenvec->de_SizeBlock ||
		envec->de_Surfaces!=likeenvec->de_Surfaces ||
		envec->de_BlocksPerTrack!=likeenvec->de_BlocksPerTrack ||
		((envec->de_HighCyl-envec->de_LowCyl))!=
			((likeenvec->de_HighCyl-likeenvec->de_LowCyl)))
		return(0);
	return(1);
}

open_device(device,handle)
char *device;
struct DeviceHandle *handle;
{
	struct DeviceNode *devnode;
	char devicename[40];

	handle->startup=NULL;
	handle->dosenvec=NULL;
	handle->device_port=NULL;
	handle->device_req=NULL;

	if (!device || !(devnode=find_device(device))) return(0);

	handle->startup=(struct FileSysStartupMsg *)BADDR(devnode->dn_Startup);
	handle->dosenvec=(struct DosEnvec *)BADDR(handle->startup->fssm_Environ);
	BtoCStr((BPTR)handle->startup->fssm_Device,devicename,40);

	if (!(handle->device_port=LCreatePort(NULL,0))) return(0);
	if (handle->device_req=(struct IOExtTD *)
		LCreateExtIO(handle->device_port,sizeof(struct IOExtTD))) {
		if (!(OpenDevice(devicename,handle->startup->fssm_Unit,
			(struct IORequest *)handle->device_req,handle->startup->fssm_Flags)))
			return(1);
		LDeleteExtIO((struct IORequest *)handle->device_req);
		handle->device_req=NULL;
	}
	return(0);
}

void close_device(handle)
struct DeviceHandle *handle;
{
	if (handle->device_req) {
		CloseDevice((struct IORequest *)handle->device_req);
		LDeleteExtIO((struct IORequest *)handle->device_req);
		handle->device_req=NULL;
	}
	if (handle->device_port) {
		LDeletePort(handle->device_port);
		handle->device_port=NULL;
	}
}

void drive_motor(req,state)
struct IOExtTD *req;
int state;
{
	req->iotd_Req.io_Command=TD_MOTOR;
	req->iotd_Req.io_Length=state;
	DoIO((struct IORequest *)req);
}

void show_sel_item(list)
struct DOpusListView *list;
{
	while (list) {
		if (list->itemselected<list->topitem ||
			list->itemselected>(list->topitem+list->lines-1)) {
			list->topitem=list->itemselected;
			RefreshListView(list,1);
		}
		list=list->next;
	}
}