/*****************************************************************************
 *  File:  AeFile.c++ 
 *
 *  File Manager
 *
 ****************************************************************************/
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <bstring.h>
#include <iostream.h>
#include <fstream.h>
#include <errno.h>

#include "AeFile.h"
#include "AeAsset.h"


AeFile::AeFile (const char * fullName)
{
    newNames (fullName);
}

    

AeFile::~AeFile()
{
    deleteNames ();
}


void
AeFile::newNames (const char * fullName)
{
    char * suffix;

    fFullName = (char *)malloc (strlen (fullName) + 1);
    strcpy (fFullName, fullName);
    
    parseFileString (fFullName, fDirName, fFileName, suffix);

    // don't bother saving the suffix
    if (suffix)
	free (suffix);
}


void
AeFile::deleteNames (void)
{
    if (fFullName)
    {
	free ((void *)fFullName); 
	fFullName = NULL;
    }

    if (fDirName)
    {
	free ((void *)fDirName);
	fDirName = NULL;
    }

    if (fFileName)
    {
	free ((void *)fFileName);
	fFileName = NULL;
    }
}


void
AeFile::SetFullName (const char * fullName)
{
    deleteNames ();
    newNames (fullName);
}


//
// This routine takes the named temporary file
// and makes it the current file.  It does this
// by first, backing up the current file and then
// moving the temp file into the new file.
// Note that the backup file will automatically
// remove any older backup files.
//
void
AeFile::SwapTmpFile (const char * tmpName)
{
    char *	buName;
    AeErr	err;

    if (buName = MakeBackupName ())
    {
	rename (fFullName, buName);
	if (err = rename (tmpName, fFullName))
	{
	    if (errno == EXDEV)
		err = copy (tmpName, fFullName);
	    
	    if (err)
		cerr << "error " << errno
		     << ": could not save file " << fFileName << '\n';
	}
	free (buName);
    }
}


AeErr
AeFile::copy (const char * fromName, const char * toName)
{
    #define kBufSize	8192

    ifstream	fromFile (fromName);
    ofstream	toFile (toName);
    char *	buf;
    AeErr	err = kAeNoErr;

    if ((buf = (char *)malloc (kBufSize)) == NULL)
	return kAeLowMemErr;

    if (fromFile && toFile)
    {
	while (fromFile)
	{
	    fromFile.read (buf, kBufSize);
	    toFile.write (buf, fromFile.gcount ());
	}
    }
    else
	err = kAeFileCantOpen;

    fromFile.close ();
    toFile.close ();
    free (buf);
    
    return err;
}


char *
AeFile::MakeBackupName (void)
{
    char * buName;

    if (buName = (char *)malloc (strlen(fFullName) + 1 + 1))
    {
	strcpy (buName, fFullName);
	strcat (buName, "~");
    }

    return buName;
}


//
// this routine allocates memory and initializes
// it with the prefix string of this file name.
// note that if the file has no suffix (ie. not '.'
// character, then it returns the entire file name.
//
char *
AeFile::MakeFilePrefix (void)
{
    char * prefix;
    char * c;
    int len;

    if ((c = strrchr(fFileName, '.')) == NULL)
	c = fFileName + strlen (fFileName);

    len = c - fFileName;

    // allocate and init the string
    prefix = (char *)malloc (len + 1);
    strncpy (prefix, fFileName, len);

    // make sure string is null terminated
    prefix[len] = '\0';

    return prefix;
}


char *
AeFile::MakeRelativePath (char * path)
{
    char * rPath;

    if (rPath = (char *)malloc (strlen(fDirName) + strlen(path) + 1))
    {
	strcpy (rPath, fDirName);
	strcat (rPath, path);
    }

    return rPath;
}


void
AeFile::ReportError (AeErr err)
{
    switch (err)
    {
	case kAeFileCantOpen:
	    cout << "error: cannot open file " << fFileName << '\n';
	    break;

	case kAeFileBadRead:
	    cout << "error: problem reading from file " << fFileName << '\n';
	    break;

	case kAeFileBadWrite:
	    cout << "error: problem writing to file " << fFileName << '\n';
	    break;

	default:
	    cout << "error: unknown problem with file " << fFileName << '\n';
	    break;
    }

    cout.flush ();
}



#if 0
AeFile::resolvePath (char * path)
{
    char *	c;

    c = strstr (path, "/..");

    len = c - path;

    
}
#endif


AeErr
AeFile::getFileData (char *fname, char * & fData, int & fSize)
{
    FILE *	file = NULL;
    int     	rv;
    AeErr       err;

    fData = NULL;

    if (!(file = fopen(fname, "r")))
    {
        err = kAeFileCantOpen;
	goto Error;
    }

    fseek (file, 0, SEEK_END);
    fSize = ftell (file);
    rewind (file);

    fData = (char*)malloc (fSize);
    FailNIL (fData);
	
    rv= fread (fData, fSize, 1, file);
    if (rv != 1)
    {
        err = kAeFileBadRead;
	goto Error;
    }

    fclose (file);

    return kAeNoErr;


Error:
    if (fData)
	free (fData);

    if (file)
	fclose (file);
    
    ReportError (err);

    return err;
}


//
// This routine separates the prefix and the suffix parts
// the the string into their own strings.  It assumes that
// the last dot in the string separates the prefix from the
// suffix.
//
// The directory string will end with a '/'.
// The file string will be complete (ie. include the suffix).
// The suffix string will NOT contain the '.'.
//
// Strings will always be allocated even if they are empty.
// The caller is responsible for free string memory.
//
void
AeFile::parseFileString (const char * pStr,
			 char *& pDir,
			 char *& pFile,
			 char *& pSuffix)
{
    const char *	p;
    const char *	pEnd = pStr + strlen (pStr);
    const char *	pSlash = pStr;			// default to empty directory string
    const char * 	pDot = pEnd - 1;		// default to empty suffix string
    Boolean		foundDot = False;
    int			len;

    // scan the string from the end to the beginning
    p = pEnd - 1;

    while (p != pStr)
    {
	if (*p == '.' && !foundDot)
	{
	    foundDot = True;
	    pDot = p;
	}

	if (*p == '/')
	{
	    pSlash = p + 1;	   // point to just after the slash
	    break;
	}

	p--;
    }

    // allocate the directory string.
    // note if we didn't find a slash then the directory
    // string will have zero length which is what we want.
    len = pSlash - pStr;
    if (pDir = (char *)malloc (len + 1))
    {
	strncpy (pDir, pStr, len);
	pDir[len] = '\0';
    }


    // allocate the suffix string.
    // note if we didn't find a dot then the suffix
    // string will have zero length which is what we want.
    len = pEnd - pDot - 1;			// don't include dot
    if (pSuffix = (char *)malloc (len + 1))
    {
	strncpy (pSuffix, pDot + 1, len);    	// don't include dot	
	pSuffix[len] = '\0';
    }


    len = pEnd - pSlash;       			// change pEnd to pDot+1 to get prefix
    if (pFile = (char *)malloc (len + 1))
    {
	strncpy (pFile, pSlash, len);
	pFile[len] = '\0';
    }
}


#ifndef NDEBUG
Boolean
AeFile::Test (void)
{
    char *	dir;
    char *	file;
    char *	suffix;

    // test multiple slashes and multiple dots
    parseFileString ("aa/bb/cc.dd.ee", dir, file, suffix);
    assert (!strcmp (dir, "aa/bb/"));
    assert (!strcmp (file, "cc.dd.ee"));
    assert (!strcmp (suffix, "ee"));
    free (dir);
    free (file);
    free (suffix);

    // test no slashes
    parseFileString ("aa.bb", dir, file, suffix);
    assert (!strcmp (dir, ""));
    assert (!strcmp (file, "aa.bb"));
    assert (!strcmp (suffix, "bb"));
    free (dir);
    free (file);
    free (suffix);

    // test no dots
    parseFileString ("aa/bb", dir, file, suffix);
    assert (!strcmp (dir, "aa/"));
    assert (!strcmp (file, "bb"));
    assert (!strcmp (suffix, ""));
    free (dir);
    free (file);
    free (suffix);

    // test no dots or slashes
    parseFileString ("aa", dir, file, suffix);
    assert (!strcmp (dir, ""));
    assert (!strcmp (file, "aa"));
    assert (!strcmp (suffix, ""));
    free (dir);
    free (file);
    free (suffix);

    return True;
}
#endif