#ifndef T1MANAGER_GST
#include "t1manager.h"
#endif

#ifdef PARMDEBUG
extern void DebugBltTemplate(UWORD *SrcTemplate, WORD SrcX, WORD SrcMod, struct RastPort *rp, WORD DstX, WORD DstY, WORD SizeX, WORD SizeY, char ch);
#endif

/*
** Private tags, only useful for communication between T1manager and type1.library
** OT_Spec3 gets the font's internal name.
*/
#define  OT_Spec3       (OT_Level1 | 0x103)


/*************************************************************/
/* Library Bases */
/*************************************************************/

/* Opened automatically by SAS/C */
//extern struct Library *UtilityBase;
//extern struct Library *DOSBase;
//extern struct Library *GfxBase;

/* Opened "manually" */
struct Library *Type1Base = NULL;


/*************************************************************/
/* Global Variables */
/*************************************************************/
/* Font Install stuff */
// first word is number of following elements
UWORD availsizelist[] = {8, 5, 10, 12, 15, 30, 45, 60, 75};
static unsigned char fontfiledata[] = {0x0f, 0x03, 0x00, 0x00};


/*************************************************************/
/* T1_InstallFont routines */
/*************************************************************/
/**
 * Open type1.library, and OpenEngine() the type1.library.
 *
 * Load the font
 *
 * Determine the name to use for the .otag file
 * --enhancement: create Amiga font filename from the Font's internal name,
 *  appending a ".otag" to get otag filename.
 *
 * Obtain from the font engine the information that will be needed
 * to create the .otag file.
 *
 * Create the .otag file. The .otag file, will contain the full path to
 * the type1 font file.
 * --enhancement: get the path information from the file requester,
 *  so it may refer to assign's, rather than devices, allowing the user
 *  to, e.g. move the psfonts: directories to another hard drive w/o
 *  requiring re-installation of all fonts
 *
 * On success, should return an error code, so that listview will be
 * updated.
 **/
BOOL T1_InstallFont(char *filename, char *destdrawer)
{
	struct GlyphEngine *engine = NULL;
	struct TagItem tags[10], minOTags[3], *OTags;
	int result;
	BOOL IsFixed;
	char *family;
	char *internalname;
	char *enginename = "type1";
	char fullfilename[256];
	BPTR lock;
	ULONG otagsize;
	struct MinList *otaglist;
	char otagfilename[100], *ch;
	char dirfilename[100];
	char fontfilename[100];
	char familyname[100];
	BPTR otagfile = NULL;
	BPTR fontfile = NULL;
	BPTR newdirlock = NULL;
	void *otagbuf;
	char buf[100], *src, *dest;

	/**
	 * Get the full filename of the file to install
	 **/
	if ((lock = Lock(filename, ACCESS_READ)) == NULL)
		return FALSE;			/* failure in Lock() */

	if (!(NameFromLock(lock, fullfilename, sizeof(fullfilename))))
	{
		UnLock(lock);
		return FALSE;			/* failure in NameFromLock() */
	}

	UnLock(lock);


	/**
	 * Now we open the font with type1.library
	 **/
	if (Type1Base = OpenLibrary("type1.library", 0L))
	{
		if ((engine = OpenEngine()) != NULL)
		{

/**
 * Tell the font engine what file we will need information from
 * This involves creating a temporary simple taglist containing the
 * necessary specification information (font's full filename),
 * and passing OT_OTagPath and OT_OTagList to SetInfoA().
 *
 * NOTE: for OT_OTagPath, we pass an empty string, since the otag
 * file hasn't been created yet.  We pass the in-memory, temporary,
 * minOTags with OT_OtagList.
 **/
			minOTags[0].ti_Tag = OT_SpecCount;
			minOTags[0].ti_Data = (ULONG) 1;

			minOTags[1].ti_Tag = OT_Spec1 | OT_Indirect;
			minOTags[1].ti_Data = (ULONG) fullfilename;

			minOTags[2].ti_Tag = TAG_DONE;
			minOTags[2].ti_Data = (ULONG) 0;

			tags[0].ti_Tag = OT_OTagPath;
			tags[0].ti_Data = (ULONG) "";

			tags[1].ti_Tag = OT_OTagList;
			tags[1].ti_Data = (ULONG) minOTags;

			tags[2].ti_Tag = TAG_DONE;
			tags[2].ti_Data = (ULONG) 0;
			if (result = SetInfoA(engine, tags))
			{
				CloseEngine(engine);
				engine = NULL;
				CloseLibrary(Type1Base);
				Type1Base = NULL;
				return FALSE;	/* failure in SetInfoA() */
			}

/**
 * Obtain some information from the font engine about the font.
 *
 * --enhancement:
 * Need to add many more inquiry tags here, and support them in
 * type1lib.c ObtainInfoA().  The information needed is
 * KernPair (possibly), OT_SpaceWidth, OT_YSizeFactor,
 * OT_SerifFlag, OT_StemWeight, OT_SlantStyle, OT_SpaceFactor.
 **/
			tags[0].ti_Tag = OT_IsFixed;
			tags[0].ti_Data = (ULONG) &IsFixed;

			tags[1].ti_Tag = OT_Family;
			tags[1].ti_Data = (ULONG) &family;

			tags[2].ti_Tag = OT_Spec3;
			tags[2].ti_Data = (ULONG) &internalname;

			tags[3].ti_Tag = TAG_DONE;
			tags[3].ti_Data = (ULONG) 0;

			if (result = ObtainInfoA(engine, tags))
			{
				MyErrorMsg1("Error while trying to install the font:\n'%s'\n",fullfilename);
				CloseEngine(engine);
				engine = NULL;
				CloseLibrary(Type1Base);
				Type1Base = NULL;
				return FALSE;	/* failure in ObtainInfoA() */
			}

			strcpy(familyname, family);

			/* Strip the font's internal name of spaces, dashes and underscores. */

			/* Or maybe not. JK */
			strncpy(buf,internalname,99);

/*			dest = buf;
			
			for (src = internalname; (src != NULL) && (*src != '\0'); src++)
				if ((*src != ' ') && (*src != '-') && (*src != '_'))
					*dest++ = *src;
			*dest = '\0';
*/
			strcpy(dirfilename, destdrawer);
			AddPart(dirfilename, buf, sizeof(dirfilename));
			strcpy(otagfilename, dirfilename);
			strcat(otagfilename, ".otag");
			strcpy(fontfilename, dirfilename);
			strcat(fontfilename, ".font");

			CloseEngine(engine);
			engine = NULL;
		}
		else
		{
			CloseLibrary(Type1Base);
			Type1Base = NULL;
			MyErrorMsg("Unable to open type1 font engine\n");
			return FALSE;		/* failure in OpenEngine() */
		}

		CloseLibrary(Type1Base);
		Type1Base = NULL;
	}
	else
	{
		MyErrorMsg("Unable to open 'type1.library'\n");
		return FALSE;			/* failure in OpenLibrary() */
	}


/**
 * Create the otags file in memory
 *
 * This is currently a multi-step procedure:
 *	Create a linked list containing the tag information and a size field
 *	that contains the size of OT_Indirect data
 *
 *	Allocate memory for the total size of the otag file.
 *
 *	Insert the linked list and OT_Indirect information into the memory.
 *	(while correcting the OT_Indirect ti_Data pointers)
 *
 *	Put the total size in the OT_FileIdent data field.
 *
 **/
	if ( (otaglist = NewOTagList()) &&
	     (AddOTag(otaglist, OT_FileIdent, 0, 0)) &&
	     (AddOTag(otaglist, OT_Engine, (ULONG) enginename, strlen(enginename) + 1)) &&
	     (AddOTag(otaglist, OT_Family, (ULONG) familyname, strlen(familyname) + 1)) &&
	     (AddOTag(otaglist, OT_AvailSizes, (ULONG) availsizelist, sizeof(availsizelist))) &&
	     (AddOTag(otaglist, OT_IsFixed, (ULONG) IsFixed, 0)) &&
//	     (AddOTag(otaglist, OT_YSizeFactor, (LONG)((805 << 16) | 1000), 0)) &&
//	     (AddOTag(otaglist, OT_SpaceWidth, (ULONG) SpaceWidth, 0)) &&
	     (AddOTag(otaglist, OT_SpecCount, 1L, 0)) &&
	     (AddOTag(otaglist, OT_Spec1 | OT_Indirect, (ULONG) fullfilename, strlen(fullfilename) + 1)) &&
	     (AddOTag(otaglist, TAG_DONE, 0, 0)) )
	{
		otagsize = SizeOTagList(otaglist);
		if (otagbuf = (void *)AllocMem(otagsize, MEMF_CLEAR))
		{
			DumpOTagList(otaglist, otagbuf);
			FreeOTagList(otaglist);
			OTags = (struct TagItem *) otagbuf;
			OTags[0].ti_Data = (ULONG) otagsize;
		}
		else
		{
			FreeOTagList(otaglist);
			return FALSE;		/* failure allocating otagbuf */
		}
	}
	else
	{
		/* Note: FreeOTagList is safe to call with a NULL argument */
		FreeOTagList(otaglist);
		return FALSE;			/* failure allocating otaglist */
	}


/**
 * Write the file to the previously determined otagfilename
 **/
// What about already existing files?

	if (otagfile = Open(otagfilename, MODE_NEWFILE))
	{
		Write(otagfile, otagbuf, otagsize);
		Close(otagfile);
		FreeMem(otagbuf, otagsize);
	}
	else
	{
		MyErrorMsg1("Error trying to create file:\n'%s'\n", dirfilename);
		FreeMem(otagbuf, otagsize);
		return FALSE;			/* failure creating otag file */
	}

// Create the .font file:
	if (fontfile = Open(fontfilename, MODE_NEWFILE))
	{
		Write(fontfile, fontfiledata, sizeof(fontfiledata));
		Close(fontfile);
	}
	else
	{
		MyErrorMsg1("Error trying to create file:\n'%s'\n", fontfilename);
		return FALSE;			/* failure creating font file */
	}

// Create the font directory: NEED ERROR CHECKING
// Note: passing NULL to UnLock is harmless...
	newdirlock = CreateDir(dirfilename);
	if (newdirlock)
		UnLock(newdirlock);
	else
	{
		MyErrorMsg1("Error trying to create directory:\n'%s'\n", dirfilename);
		return FALSE;			/* failure creating font dir */
	}

	return TRUE;
}



struct MinList *NewOTagList(void)
{
	struct MinList *otaglist;

	if (otaglist = (struct MinList *)AllocMem(sizeof(struct MinList), MEMF_CLEAR))
		NewList((struct List *)otaglist);

	return otaglist;
}



int AddOTag(struct MinList *list, ULONG tag, ULONG data, ULONG size)
{
	struct otagnode *node;

	if (!(node = AllocMem(sizeof(struct otagnode), MEMF_CLEAR)))
		return 0;

	node->ti_Tag = tag;
	node->ti_Data = data;
	node->size = size;
	AddTail( (struct List *)list, (struct Node *)node );

	return 1;
}


ULONG SizeOTagList(struct MinList *list)
{
	struct otagnode *node;
	ULONG size = 0;

	for (node = (struct otagnode *)(list->mlh_Head); node->MyNode.mln_Succ; node = (struct otagnode *)node->MyNode.mln_Succ)
		size += 2 * sizeof(ULONG) + node->size;

	return size;
}


/**
 * Create an otag file in memory
 * first pass through the list, and copy the ti_Tag and ti_Data values
 * Then pass again, and copy the OT_Indirect information over, modifying
 * the corresponding memory ti_Data pointers accordingly.
 **/
void DumpOTagList(struct MinList *list, UBYTE *buf)
{
	struct otagnode *node;
	ULONG *cur;
	UBYTE *ptr;

	cur = (ULONG *)buf;
	for (node = (struct otagnode *)(list->mlh_Head); node->MyNode.mln_Succ; node = (struct otagnode *)node->MyNode.mln_Succ)
	{
		*(cur++) = node->ti_Tag;
		cur++;	/* don't bother setting ti_Data here */
	}

	ptr = (UBYTE *)cur;
	cur = (ULONG *)buf;
	for (node = (struct otagnode *)(list->mlh_Head); node->MyNode.mln_Succ; node = (struct otagnode *)node->MyNode.mln_Succ)
	{
		cur++;		/* Advance to ti_Data field */

		if (node->size > 0)		/* Store indirect data */
		{
			*(cur++) = (ULONG) (ptr - buf);
			CopyMem((void *)node->ti_Data, ptr, node->size);
			ptr += node->size;
		}
		else				/* Copy the ti_Data */
		{
			*(cur++) = (ULONG) node->ti_Data;
		}
	}

	return;
}


void FreeOTagList(struct MinList *list)
{
	struct otagnode *work_node, *next_node;

	if (list == NULL)
		return;

	work_node = (struct otagnode *)(list->mlh_Head);
	while (next_node = (struct otagnode *)(work_node->MyNode.mln_Succ))
	{
		FreeMem(work_node, sizeof(struct otagnode));
		work_node = next_node;
	}
	FreeMem(list, sizeof(struct MinList));
}


/*************************************************************/
/* DoAllAssigns */
/*************************************************************/
 /*
  * This routine accepts a path string that may include a device name.  From
  * that string, this routine locks the object named in the path and calls
  * the function passback_func() on the lock.  DoAllAssigns() should work on
  * paths with assigns and multiassigns, as well as a filesystem-based device
  * (i.e., df0:, work:, ram:, etc.)
  */
BOOL DoAllAssigns(char *dos_path, BOOL (*passback_func) (BPTR lock, void (*passfunc) (char *filename, int filesize)), void (*passfunc) (char *filename, int filesize))
{
	struct DevProc *dp = NULL;
	struct MsgPort *old_fsport;
	BPTR lock, old_curdir;
	char *rest_of_path;
	LONG err;

	while (dp = GetDeviceProc(dos_path, dp)) {

		/*
		 * I need to cut the device name from the front of dos_path
		 * so I can give that substring to Lock().
		 */
		rest_of_path = strchr(dos_path, ':');

		if (rest_of_path == NULL)

			/*
			 * there was no device name to cut off, use the whole
			 * string.
			 */
			rest_of_path = dos_path;
		else
			/* increment string pointer to just past the colon. */
			rest_of_path++;

		old_fsport = SetFileSysTask(dp->dvp_Port);	/* in case dp->dvp_Lock
								 * is NULL */

		/*
		 * Lock() locks relative to the current directory and falls
		 * back to the root of the current file system if
		 * dp->dvp_Lock is NULL
		 */
		old_curdir = CurrentDir(dp->dvp_Lock);

		lock = Lock(rest_of_path, SHARED_LOCK);

		/*
		 * reset the process' default filesystem port and current dir
		 * to their initial values for clean up later
		 */
		SetFileSysTask(old_fsport);
		CurrentDir(old_curdir);

		if (lock) {
			if (!(*passback_func) (lock, passfunc)) {
				UnLock(lock);
				FreeDeviceProc(dp);
				return FALSE;
			}

			UnLock(lock);
		}
	}

	err = IoErr();

	if ((err == ERROR_NO_MORE_ENTRIES) || (err == 0))

		/*
		 * at present, a bug in DOS prevents this case, so
		 * DoAllAssigns() always returns FALSE
		 */
		return TRUE;
	else
		return FALSE;
}


/*************************************************************/
/* Add parts of fonts: assign to an array of string pointers */
/* input: lock == directory lock */
/*************************************************************/
BOOL AddFontdir(BPTR lock, void (*passfunc) (char *filename, int filesize))
{
	extern char *fontdirparts[];
	extern int sizefontdirparts;
	extern int numfontdirparts;
	char fontdir[120];

	if (NameFromLock(lock, fontdir, sizeof(fontdir)))
	{
		if ((numfontdirparts + 1) < sizefontdirparts)
		{
			if (fontdirparts[numfontdirparts] = (char *) AllocVec(1 + strlen(fontdir), 0l))
			{
				strcpy(fontdirparts[numfontdirparts], fontdir);
				numfontdirparts++;
				fontdirparts[numfontdirparts] = NULL;
				return TRUE;
			}
		}
	}

	return FALSE;
}


/*************************************************************/
/* Free the strings in fontdirparts */
/*************************************************************/
void FreeFontdirparts(void)
{
	extern char *fontdirparts[];
	int i;

	if (fontdirparts != NULL)
	{
		for (i=0; fontdirparts[i] != NULL; i++)
			FreeVec(fontdirparts[i]);
	}
}


/*************************************************************/
/* Add installed Type1 fonts in dir to listview */
/* input: lock == directory lock */
/*************************************************************/
BOOL ScanDir(BPTR lock, void (*passfunc) (char *filename, int filesize))
{
	struct ExAllControl *myeac;
	struct ExAllData *myead;
	APTR buffer;
	BOOL done;
	struct FileInfoBlock *myfib;
	BPTR old_curdir;

	if (myfib = AllocDosObject(DOS_FIB, NULL))
	{
		if (Examine(lock, myfib) == DOSTRUE)
		{
			if (myfib->fib_DirEntryType > 0)
			{
				if (buffer = AllocVec(EXALLBUFSIZE, MEMF_PUBLIC))
				{
					if (myeac = AllocDosObject(DOS_EXALLCONTROL, NULL))
					{
						old_curdir = CurrentDir(lock);
						myeac->eac_LastKey = 0L;
						do
						{
							done = ExAll(lock, buffer, EXALLBUFSIZE - 200, ED_SIZE, myeac);
							myead = (struct ExAllData *)buffer;
							while (myead)
							{
								(*passfunc)(myead->ed_Name, myead->ed_Size);
								myead = myead->ed_Next;
							}
						} while (done != 0);
						CurrentDir(old_curdir);
						FreeDosObject(DOS_EXALLCONTROL, myeac);
						FreeVec(buffer);
						FreeDosObject(DOS_FIB, myfib);
						return TRUE;
					}
					FreeVec(buffer);
				}
			}
		}
		FreeDosObject(DOS_FIB, myfib);
	}
	return FALSE;
}


void DeleteBitmaps(char *filename, int filesize)
{
	char *ch;

	if (filename)
	{
		for (ch = filename; *ch != '\0'; ch++)
			if ((*ch < '0') || (*ch > '9'))
				break;

		/* Filename is numeric */
		if ((ch != filename) && (*ch == '\0'))
			DeleteFile(filename);
	}
}


void CheckFile(char *filename, int filesize)
{
	BPTR filehandle;
	char *ch, *filebuf;

	/* Check for .otag files */
	ch = filename;
	while (*ch != '\0') ch++;
	ch -= 5;
	if (strcmp(ch, ".otag") == 0)
	{
		if (filehandle = Open(filename, MODE_OLDFILE))
		{
			if (filebuf = (char *)AllocVec(filesize, 0L))
			{
				Read(filehandle, filebuf, filesize);
				if (IsOtagType1(filebuf))
					AddFontToListview(filename, filebuf);
				FreeVec(filebuf);
			}
			Close(filehandle);
		}
	}
}


/*************************************************************/
/* IsOtagType1 */
/*************************************************************/
/*
 * This routine determines whether the otag data in buf is a
 * type1.library otag file.
 */
BOOL IsOtagType1(char *buf)
{
	char *engine;
	BOOL retvalue = FALSE;

	if (*((LONG *)(buf + 8)) == OT_Engine)
	{
		engine = buf + *((long *)(buf + 12));
		if (strcmp(engine, "type1") == 0)
			retvalue = TRUE;
	}

	return retvalue;
}


/*************************************************************/
/* RenderPreview */
/*************************************************************/
BOOL RenderPreview(char *filename, ULONG pointheight, struct RastPort *rp, LONG leftedge, LONG topedge, LONG width, LONG height, char *previewstring)
{
	struct GlyphEngine *engine;
	struct TagItem *OTags, tags[5];
	BPTR OTFile;
	struct FileInfoBlock __aligned fib;
	char *filebuf = NULL;
	char *ch;
	int i, x, y, dx, dy;
	BOOL result;
	struct GlyphMap *glyph;
	PLANEPTR Template = 0;

/**
 * Read the otag file into memory, and verify that it is a type1 font otag file
 **/
	result = FALSE;
	if (OTFile = Open(filename, MODE_OLDFILE))
	{
		if (ExamineFH(OTFile, &fib))
		{
			if (filebuf = (char *)AllocVec(fib.fib_Size, 0L))
			{
				if (Read(OTFile, filebuf, fib.fib_Size) == fib.fib_Size)
				{
					if (IsOtagType1(filebuf))
						result = TRUE;
					else
						MyErrorMsg("This font isn't a postscript\ntype1 font!\n");
				}
				else
					MyErrorMsg1("Error reading from .otag file\n'%s'\n", filename);
			}
		}

		Close(OTFile);
	}
	else
		MyErrorMsg1("Error opening .otag file\n'%s'\n", filename);

	if (!result)
	{
		if (filebuf)
			FreeVec(filebuf);

		return FALSE;
	}

/**
 * Patch indirect pointers in the otag list
 **/
	OTags = (struct TagItem *)filebuf;
	for (i=0; i < OTags[0].ti_Data/sizeof(struct TagItem); i++)
	{
		if (OTags[i].ti_Tag == TAG_DONE)
			break;
		if (OTags[i].ti_Tag & OT_Indirect)
			OTags[i].ti_Data += (ULONG) OTags;
	}

/**
 * Now we open the font with type1.library
 **/
	result = FALSE;
	if (Type1Base = OpenLibrary("type1.library", 0L))
	{
		if (engine = OpenEngine())
		{
			tags[0].ti_Tag = OT_OTagPath;
			tags[0].ti_Data = (ULONG) filename;

			tags[1].ti_Tag = OT_OTagList;
			tags[1].ti_Data = (ULONG) OTags;

			tags[2].ti_Tag = OT_PointHeight;
			tags[2].ti_Data = (ULONG) pointheight << 16;

			tags[3].ti_Tag = OT_DeviceDPI;
			tags[3].ti_Data = (ULONG) (72 << 16) | 72;

			tags[4].ti_Tag = TAG_DONE;
			tags[4].ti_Data = (ULONG) 0;
			result = !SetInfoA(engine, tags);

			if (result)
			{
				x = leftedge + 4;
				y = topedge + (height / 2);

				tags[1].ti_Tag = TAG_DONE;
				tags[1].ti_Data = (ULONG) 0;

				if (Template = AllocRaster(width, height))
				{
					ULONG drawmodestorage;
					int num_chars_obtained = 0;

					drawmodestorage = GetDrMd(rp);
					SetDrMd(rp, COMPLEMENT);
					for (ch=previewstring; *ch != '\0'; ch++)
					{
						tags[0].ti_Tag = OT_GlyphCode;
						tags[0].ti_Data = (ULONG) *ch;
						(void) SetInfoA(engine, tags);

						tags[0].ti_Tag = OT_GlyphMap;
						tags[0].ti_Data = (ULONG) &glyph;
						result = !ObtainInfoA(engine, tags);

						if (result)
						{
							num_chars_obtained++;

							dx = x - glyph->glm_X0 + glyph->glm_BlackLeft;
							dy = y - glyph->glm_Y0 + glyph->glm_BlackTop;

							if ((dx + glyph->glm_BlackWidth - leftedge) > width)
								break;

							for (i = (glyph->glm_BMRows * glyph->glm_BMModulo/4) - 1; i >= 0; i--)
								((ULONG *) Template)[i] = ((ULONG *) glyph->glm_BitMap)[i];

#ifdef PARMDEBUG
							if (*ch == 'f') DebugBltTemplate( ((char *) Template) + (glyph->glm_BlackTop * glyph->glm_BMModulo) + (glyph->glm_BlackLeft >> 3),
									glyph->glm_BlackLeft & 0xf,
									glyph->glm_BMModulo,
									rp,
									dx,
									dy,
									glyph->glm_BlackWidth,
									glyph->glm_BlackHeight, *ch);
#endif

							if ((glyph->glm_BlackWidth != 0) || (glyph->glm_BlackHeight != 0))
							{
								BltTemplate( ((char *) Template) + (glyph->glm_BlackTop * glyph->glm_BMModulo) + (glyph->glm_BlackLeft >> 3),
									glyph->glm_BlackLeft & 0xf,
									glyph->glm_BMModulo,
									rp,
									dx,
									dy,
									glyph->glm_BlackWidth,
									glyph->glm_BlackHeight);
								WaitBlit();
							}

							x += glyph->glm_X1 - glyph->glm_X0;
						}

					}

					if (num_chars_obtained == 0)
						MyErrorMsg("Error reading font - perhaps it needs to\nbe removed and reinstalled?\n");

					WaitBlit();
					FreeRaster(Template, width, height);
					SetDrMd(rp, drawmodestorage);
				}
			}
			else
				MyErrorMsg("Error in type1.library\n");

			CloseEngine(engine);
		}

		CloseLibrary(Type1Base);
		Type1Base = NULL;
	}
	else
		MyErrorMsg("Unable to open 'type1.library'\n");

	FreeVec(filebuf);
	return result;
}