/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/*
 * The contents of this file are subject to the Netscape Public
 * License Version 1.1 (the "License"); you may not use this file
 * except in compliance with the License. You may obtain a copy of
 * the License at http://www.mozilla.org/NPL/
 *
 * Software distributed under the License is distributed on an "AS
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * rights and limitations under the License.
 *
 * The Original Code is mozilla.org code.
 *
 * The Initial Developer of the Original Code is Netscape
 * Communications Corporation.  Portions created by Netscape are
 * Copyright (C) 1998 Netscape Communications Corporation. All
 * Rights Reserved.
 *
 * Contributor(s): 
 */

#include "nspr.h"
#include "nsInstall.h"
#include "nsInstallFileOpEnums.h"
#include "nsInstallFileOpItem.h"
#include "ScheduledTasks.h"

#ifdef _WINDOWS
#include <windows.h>
#include "nsWinShortcut.h"
#endif

#ifdef XP_MAC
#include "Aliases.h"
#include "Gestalt.h"
#include "Resources.h"
#include "TextUtils.h"
#include "script.h"
#include "MoreFilesExtras.h"
#include "nsILocalFileMac.h"
#endif

/* Public Methods */

MOZ_DECL_CTOR_COUNTER(nsInstallFileOpItem);

nsInstallFileOpItem::nsInstallFileOpItem(nsInstall*     aInstallObj,
                                         PRInt32        aCommand,
                                         nsIFile*       aTarget,
                                         PRInt32        aFlags,
                                         PRInt32*       aReturn)
:nsInstallObject(aInstallObj),
 mTarget(aTarget)
{
    MOZ_COUNT_CTOR(nsInstallFileOpItem);

    *aReturn      = nsInstall::SUCCESS;
    mIObj         = aInstallObj;
    mCommand      = aCommand;
    mFlags        = aFlags;
    mSrc          = nsnull;
    mParams       = nsnull;
    mStrTarget    = nsnull;
    mShortcutPath = nsnull;
    mDescription  = nsnull;
    mWorkingPath  = nsnull;
    mParams       = nsnull;
    mIcon         = nsnull;
}

nsInstallFileOpItem::nsInstallFileOpItem(nsInstall*     aInstallObj,
                                         PRInt32        aCommand,
                                         nsIFile*       aSrc,
                                         nsIFile*       aTarget,
                                         PRInt32*       aReturn)
:nsInstallObject(aInstallObj),
 mSrc(aSrc),
 mTarget(aTarget)
{
  MOZ_COUNT_CTOR(nsInstallFileOpItem);

  *aReturn    = nsInstall::SUCCESS;
  mIObj       = aInstallObj;
  mCommand    = aCommand;
  mFlags      = 0;
  mParams     = nsnull;
  mStrTarget  = nsnull;
  mAction     = ACTION_NONE;
  mShortcutPath = nsnull;
  mDescription  = nsnull;
  mWorkingPath  = nsnull;
  mParams       = nsnull;
  mIcon         = nsnull;
}

nsInstallFileOpItem::nsInstallFileOpItem(nsInstall*     aInstallObj,
                                         PRInt32        aCommand,
                                         nsIFile*       aTarget,
                                         PRInt32*       aReturn)
:nsInstallObject(aInstallObj),
 mTarget(aTarget)
{
  MOZ_COUNT_CTOR(nsInstallFileOpItem);

  *aReturn    = nsInstall::SUCCESS;
  mIObj       = aInstallObj;
	mCommand    = aCommand;
	mFlags      = 0;
	mSrc        = nsnull;
  mParams     = nsnull;
	mStrTarget  = nsnull;
  mAction     = ACTION_NONE;
  mShortcutPath = nsnull;
  mDescription  = nsnull;
  mWorkingPath  = nsnull;
  mParams       = nsnull;
  mIcon         = nsnull;
}

nsInstallFileOpItem::nsInstallFileOpItem(nsInstall*     aInstallObj,
                                         PRInt32        aCommand,
                                         nsIFile*       a1,
                                         nsString&      a2,
                                         PRInt32*       aReturn)
:nsInstallObject(aInstallObj)
{
    MOZ_COUNT_CTOR(nsInstallFileOpItem);

    *aReturn      = nsInstall::SUCCESS;
    mIObj         = aInstallObj;
    mCommand      = aCommand;
    mFlags        = 0;
    mAction       = ACTION_NONE;
    mShortcutPath = nsnull;
    mDescription  = nsnull;
    mWorkingPath  = nsnull;
    mParams       = nsnull;
    mIcon         = nsnull;

    switch(mCommand)
    {
        case NS_FOP_DIR_RENAME:
        case NS_FOP_FILE_RENAME:
            mSrc = a1;
            mTarget     = nsnull;
            mParams     = nsnull;
            mStrTarget  = new nsString(a2);

            if (mSrc == nsnull || mStrTarget == nsnull)
                *aReturn = nsInstall::OUT_OF_MEMORY;

            break;

        case NS_FOP_FILE_EXECUTE:
        default:
            mSrc        = nsnull;
            mTarget = a1;
            mParams     = new nsString(a2);
            mStrTarget  = nsnull;

    }
}

nsInstallFileOpItem::nsInstallFileOpItem(nsInstall*     aInstallObj,
                                         PRInt32        aCommand,
                                         nsIFile*       aTarget,
                                         nsIFile*       aShortcutPath,
                                         nsString&      aDescription,
                                         nsIFile*       aWorkingPath,
                                         nsString&      aParams,
                                         nsIFile*       aIcon,
                                         PRInt32        aIconId,
                                         PRInt32*       aReturn)
:nsInstallObject(aInstallObj),
 mTarget(aTarget),
 mShortcutPath(aShortcutPath),
 mWorkingPath(aWorkingPath),
 mIcon(aIcon)
{
    MOZ_COUNT_CTOR(nsInstallFileOpItem);

  *aReturn    = nsInstall::SUCCESS;
  mIObj       = aInstallObj;
  mCommand    = aCommand;
  mIconId     = aIconId;
  mFlags      = 0;
  mSrc        = nsnull;
  mStrTarget  = nsnull;
  mAction     = ACTION_NONE;

  mDescription = new nsString(aDescription);
  if(mDescription == nsnull)
    *aReturn = nsInstall::OUT_OF_MEMORY;

  mParams = new nsString(aParams);
  if(mParams == nsnull)
    *aReturn = nsInstall::OUT_OF_MEMORY;
}

nsInstallFileOpItem::~nsInstallFileOpItem()
{
  //if(mSrc)
  //  delete mSrc;
  //if(mTarget)
  //  delete mTarget;
  if(mStrTarget)
    delete mStrTarget;
  if(mParams)
    delete mParams;
  //if(mShortcutPath)
  //  delete mShortcutPath;
  if(mDescription)
    delete mDescription;
  //if(mWorkingPath)
  //  delete mWorkingPath;
  //if(mIcon)
  //  delete mIcon;

  MOZ_COUNT_DTOR(nsInstallFileOpItem);
}

#ifdef XP_MAC
#pragma mark -
#endif

PRInt32 nsInstallFileOpItem::Complete()
{
  PRInt32 ret = nsInstall::SUCCESS;

  switch(mCommand)
  {
    case NS_FOP_FILE_COPY:
      ret = NativeFileOpFileCopyComplete();
      break;
    case NS_FOP_FILE_DELETE:
      ret = NativeFileOpFileDeleteComplete(mTarget);
      break;
    case NS_FOP_FILE_EXECUTE:
      ret = NativeFileOpFileExecuteComplete();
      break;
    case NS_FOP_FILE_MOVE:
      ret = NativeFileOpFileMoveComplete();
      break;
    case NS_FOP_FILE_RENAME:
      ret = NativeFileOpFileRenameComplete();
      break;
    case NS_FOP_DIR_CREATE:
      // operation is done in the prepare phase
      break;
    case NS_FOP_DIR_REMOVE:
      ret = NativeFileOpDirRemoveComplete();
      break;
    case NS_FOP_DIR_RENAME:
      ret = NativeFileOpDirRenameComplete();
      break;
    case NS_FOP_WIN_SHORTCUT:
      ret = NativeFileOpWindowsShortcutComplete();
      break;
    case NS_FOP_MAC_ALIAS:
      ret = NativeFileOpMacAliasComplete();
      break;
    case NS_FOP_UNIX_LINK:
      ret = NativeFileOpUnixLink();
      break;
    case NS_FOP_WIN_REGISTER_SERVER:
      ret = NativeFileOpWindowsRegisterServerComplete();
      break;
  }

  if ( (ret != nsInstall::SUCCESS) && (ret < nsInstall::GESTALT_INVALID_ARGUMENT || ret > nsInstall::REBOOT_NEEDED) )
    ret = nsInstall::UNEXPECTED_ERROR; /* translate to XPInstall error */
  	
  return ret;
}
  
#define RESBUFSIZE 4096
char* nsInstallFileOpItem::toString()
{
  nsString result;
  char*    resultCString = new char[RESBUFSIZE];
  char*    rsrcVal = nsnull;
  char*    temp;
  char*    srcPath;
  char*    dstPath;

    // STRING USE WARNING: perhaps |result| should be an |nsCAutoString| to avoid all this double converting
  
  switch(mCommand)
  {
    case NS_FOP_FILE_COPY:
      if((mSrc == nsnull) || (mTarget == nsnull))
        break;

      mSrc->GetPath(&srcPath);
      mTarget->GetPath(&dstPath);
      rsrcVal = mInstall->GetResourcedString(NS_ConvertASCIItoUCS2("CopyFile"));
      if(rsrcVal != nsnull)
        PR_snprintf(resultCString, RESBUFSIZE, rsrcVal, srcPath, dstPath );
      break;

    case NS_FOP_FILE_DELETE:
      if(mTarget == nsnull)
        break;

      mTarget->GetPath(&dstPath);
      rsrcVal = mInstall->GetResourcedString(NS_ConvertASCIItoUCS2("DeleteFile"));
      if(rsrcVal != nsnull)
        PR_snprintf(resultCString, RESBUFSIZE, rsrcVal, dstPath );
      break;

    case NS_FOP_FILE_EXECUTE:
      if(mTarget == nsnull)
        break;

      mTarget->GetPath(&dstPath);

      temp = mParams->ToNewCString();
      if((temp != nsnull) && (*temp != '\0'))
      {
        rsrcVal = mInstall->GetResourcedString(NS_ConvertASCIItoUCS2("ExecuteWithArgs"));
        if(rsrcVal != nsnull)
          PR_snprintf(resultCString, RESBUFSIZE, rsrcVal, dstPath, temp);
      }
      else
      {
        rsrcVal = mInstall->GetResourcedString(NS_ConvertASCIItoUCS2("Execute"));
        if(rsrcVal != nsnull)
          PR_snprintf(resultCString, RESBUFSIZE, rsrcVal, dstPath);
      }

      if(temp != nsnull)
        Recycle(temp);

      break;

    case NS_FOP_FILE_MOVE:
      if((mSrc == nsnull) || (mTarget == nsnull))
        break;

      mSrc->GetPath(&srcPath);
      mTarget->GetPath(&dstPath);
      rsrcVal = mInstall->GetResourcedString(NS_ConvertASCIItoUCS2("MoveFile"));
      if(rsrcVal != nsnull)
        PR_snprintf(resultCString, RESBUFSIZE, rsrcVal, srcPath, dstPath );
      break;

    case NS_FOP_FILE_RENAME:
      if((mSrc == nsnull) || (mTarget == nsnull))
        break;

      mSrc->GetPath(&srcPath);
      mTarget->GetPath(&dstPath);
      rsrcVal = mInstall->GetResourcedString(NS_ConvertASCIItoUCS2("RenameFile"));
      if(rsrcVal != nsnull)
        PR_snprintf(resultCString, RESBUFSIZE, rsrcVal, srcPath, dstPath );
      break;

    case NS_FOP_DIR_CREATE:
      if(mTarget == nsnull)
        break;

      mTarget->GetPath(&dstPath);
      rsrcVal = mInstall->GetResourcedString(NS_ConvertASCIItoUCS2("CreateFolder"));
      if(rsrcVal != nsnull)
        PR_snprintf(resultCString, RESBUFSIZE, rsrcVal, dstPath );
      break;

    case NS_FOP_DIR_REMOVE:
      if(mTarget == nsnull)
        break;

      mTarget->GetPath(&dstPath);
      rsrcVal = mInstall->GetResourcedString(NS_ConvertASCIItoUCS2("RemoveFolder"));
      if(rsrcVal != nsnull)
        PR_snprintf(resultCString, RESBUFSIZE, rsrcVal, dstPath );
      break;

    case NS_FOP_DIR_RENAME:
      if((mSrc == nsnull) || (mTarget == nsnull))
        break;

      mSrc->GetPath(&srcPath);
      mTarget->GetPath(&dstPath);
      rsrcVal = mInstall->GetResourcedString(NS_ConvertASCIItoUCS2("RenameFolder"));
      if(rsrcVal != nsnull)
        PR_snprintf(resultCString, RESBUFSIZE, rsrcVal, srcPath, dstPath );
      break;

    case NS_FOP_WIN_SHORTCUT:
      rsrcVal = mInstall->GetResourcedString(NS_ConvertASCIItoUCS2("WindowsShortcut"));
      if(rsrcVal != nsnull)
      {
        mShortcutPath->GetPath(&temp);
        result.AssignWithConversion(temp);
        result.AppendWithConversion("\\");
        result.Append(*mDescription);
        dstPath = result.ToNewCString();
        if(dstPath != nsnull)
        {
          PR_snprintf(resultCString, RESBUFSIZE, rsrcVal, dstPath );
          Recycle(dstPath);
        }
      }
      break;

    case NS_FOP_MAC_ALIAS:
      if(mTarget == nsnull)
        break;

      mTarget->GetPath(&dstPath);
      rsrcVal = mInstall->GetResourcedString(NS_ConvertASCIItoUCS2("MacAlias"));
      if(rsrcVal != nsnull)
        PR_snprintf(resultCString, RESBUFSIZE, rsrcVal, dstPath );
      break;

    case NS_FOP_UNIX_LINK:
      break;

    case NS_FOP_WIN_REGISTER_SERVER:
      if(mTarget == nsnull)
        break;

      mTarget->GetPath(&dstPath);
      rsrcVal = mInstall->GetResourcedString(NS_ConvertASCIItoUCS2("WindowsRegisterServer"));
      if(rsrcVal != nsnull)
        PR_snprintf(resultCString, RESBUFSIZE, rsrcVal, dstPath );
      break;

    default:
      if(rsrcVal != nsnull)
        resultCString = mInstall->GetResourcedString(NS_ConvertASCIItoUCS2("UnknownFileOpCommand"));
      break;
  }

  if(rsrcVal)
    Recycle(rsrcVal);

  return resultCString;
}

PRInt32 nsInstallFileOpItem::Prepare()
{
  PRInt32 ret = nsInstall::SUCCESS;

  switch(mCommand)
  {
    case NS_FOP_FILE_COPY:
      ret = NativeFileOpFileCopyPrepare();
      break;
    case NS_FOP_FILE_DELETE:
      ret = NativeFileOpFileDeletePrepare();
      break;
    case NS_FOP_FILE_EXECUTE:
      ret = NativeFileOpFileExecutePrepare();
      break;
    case NS_FOP_FILE_MOVE:
      ret = NativeFileOpFileMovePrepare();
      break;
    case NS_FOP_FILE_RENAME:
      ret = NativeFileOpFileRenamePrepare();
      break;
    case NS_FOP_DIR_CREATE:
      ret = NativeFileOpDirCreatePrepare();
      break;
    case NS_FOP_DIR_REMOVE:
      ret = NativeFileOpDirRemovePrepare();
      break;
    case NS_FOP_DIR_RENAME:
      ret = NativeFileOpDirRenamePrepare();
      break;
    case NS_FOP_WIN_SHORTCUT:
      ret = NativeFileOpWindowsShortcutPrepare();
      break;
    case NS_FOP_MAC_ALIAS:
      break;
    case NS_FOP_UNIX_LINK:
      break;
    case NS_FOP_WIN_REGISTER_SERVER:
      ret = NativeFileOpWindowsRegisterServerPrepare();
      break;
    default:
      break;
  }

  if ( (ret != nsInstall::SUCCESS) && (ret < nsInstall::GESTALT_INVALID_ARGUMENT || ret > nsInstall::REBOOT_NEEDED) )
    ret = nsInstall::UNEXPECTED_ERROR; /* translate to XPInstall error */

  return(ret);
}

void nsInstallFileOpItem::Abort()
{
  switch(mCommand)
  {
    case NS_FOP_FILE_COPY:
      NativeFileOpFileCopyAbort();
      break;
    case NS_FOP_FILE_DELETE:
      // does nothing
      break;
    case NS_FOP_FILE_EXECUTE:
      // does nothing
      break;
    case NS_FOP_FILE_MOVE:
      NativeFileOpFileMoveAbort();
      break;
    case NS_FOP_FILE_RENAME:
      NativeFileOpFileRenameAbort();
      break;
    case NS_FOP_DIR_CREATE:
      NativeFileOpDirCreateAbort();
      break;
    case NS_FOP_DIR_REMOVE:
      break;
    case NS_FOP_DIR_RENAME:
      NativeFileOpDirRenameAbort();
      break;
    case NS_FOP_WIN_SHORTCUT:
      NativeFileOpWindowsShortcutAbort();
      break;
    case NS_FOP_MAC_ALIAS:
      NativeFileOpMacAliasAbort();
      break;
    case NS_FOP_UNIX_LINK:
      break;
    case NS_FOP_WIN_REGISTER_SERVER:
      NativeFileOpWindowsRegisterServerAbort();
      break;
  }
}

/* Private Methods */

/* CanUninstall
* InstallFileOpItem() does not install any files which can be uninstalled,
* hence this function returns false. 
*/
PRBool
nsInstallFileOpItem::CanUninstall()
{
    return PR_FALSE;
}

/* RegisterPackageNode
* InstallFileOpItem() does notinstall files which need to be registered,
* hence this function returns false.
*/
PRBool
nsInstallFileOpItem::RegisterPackageNode()
{
    return PR_FALSE;
}

#ifdef XP_MAC
#pragma mark -
#endif

//
// File operation functions begin here
//
PRInt32
nsInstallFileOpItem::NativeFileOpDirCreatePrepare()
{
  PRInt32 ret = nsInstall::ALREADY_EXISTS;
  PRBool  flagExists;

  mAction = nsInstallFileOpItem::ACTION_FAILED;

  mTarget->Exists(&flagExists);
  if (!flagExists)
  {
      mTarget->Create(1, 0755);
      mAction = nsInstallFileOpItem::ACTION_SUCCESS;
      ret     = nsInstall::SUCCESS;
  }

  return ret;
}

PRInt32
nsInstallFileOpItem::NativeFileOpDirCreateAbort()
{
  if(nsInstallFileOpItem::ACTION_SUCCESS == mAction)
    mTarget->Delete(PR_FALSE);

  return nsInstall::SUCCESS;
}

PRInt32
nsInstallFileOpItem::NativeFileOpDirRemovePrepare()
{
  PRBool flagExists, flagIsFile;

  mTarget->Exists(&flagExists);

  if(flagExists)
  {
    mTarget->IsFile(&flagIsFile);
    if(!flagIsFile)
      return nsInstall::SUCCESS;
    else
      return nsInstall::IS_FILE;
  }
    
  return nsInstall::DOES_NOT_EXIST;
}

PRInt32
nsInstallFileOpItem::NativeFileOpDirRemoveComplete()
{
  mTarget->Delete(mFlags);
  return nsInstall::SUCCESS;
}

PRInt32
nsInstallFileOpItem::NativeFileOpFileRenamePrepare()
{
  PRBool flagExists, flagIsFile;

  // XXX needs to check file attributes to make sure
  // user has proper permissions to delete file.
  // Waiting on dougt's fix to nsFileSpec().
  // In the meantime, check as much as possible.
  mSrc->Exists(&flagExists);
  if(flagExists)
  {
    mSrc->IsFile(&flagIsFile);
    if(flagIsFile)
    {
      nsIFile* target;

      mSrc->GetParent(&target);
      nsAutoCString tempTargetString(*mStrTarget);
      target->Append(tempTargetString);

      target->Exists(&flagExists);
      if(flagExists)
        return nsInstall::ALREADY_EXISTS;
      else
        return nsInstall::SUCCESS;
    }
    else
      return nsInstall::SOURCE_IS_DIRECTORY;
  }
    
  return nsInstall::SOURCE_DOES_NOT_EXIST;
}

PRInt32
nsInstallFileOpItem::NativeFileOpFileRenameComplete()
{
  PRInt32 ret = nsInstall::SUCCESS;
  PRBool flagExists, flagIsFile;
  
  mSrc->Exists(&flagExists);
  if(flagExists)
  {
    mSrc->IsFile(&flagIsFile);
    if(flagIsFile)
    {
        nsCOMPtr<nsIFile> parent;
        nsCOMPtr<nsIFile> target;

        mSrc->GetParent(getter_AddRefs(parent)); //need parent seprated for use in MoveTo method
        if(parent)
        {
            mSrc->GetParent(getter_AddRefs(target)); //need target for path assembly to check if the file already exists

            if (target)
            {
                nsAutoCString tempTargetString(*mStrTarget);
                target->Append(tempTargetString);
            }
            else
                return nsInstall::UNEXPECTED_ERROR;

            target->Exists(&flagExists);
            if(!flagExists)
            {
                nsAutoCString tempTargetString(*mStrTarget);
                mSrc->MoveTo(parent, tempTargetString);
            }
            else
                return nsInstall::ALREADY_EXISTS;
        }
        else
            return nsInstall::UNEXPECTED_ERROR;
    }
    else
      ret = nsInstall::SOURCE_IS_DIRECTORY;
  }
  else  
    ret = nsInstall::SOURCE_DOES_NOT_EXIST;

  return ret;
}

PRInt32
nsInstallFileOpItem::NativeFileOpFileRenameAbort()
{
  PRInt32   ret  = nsInstall::SUCCESS;
  PRBool    flagExists;
  char*     leafName;
  nsCOMPtr<nsIFile>  newFilename;
  nsCOMPtr<nsIFile>  parent;

  mSrc->Exists(&flagExists);
  if(!flagExists)
  {
    mSrc->GetParent(getter_AddRefs(newFilename));
    if(newFilename)
    {
      mSrc->GetParent(getter_AddRefs(parent));
      if(parent)
      {
        nsAutoCString tempTargetString(*mStrTarget);
        newFilename->Append(tempTargetString);
    
        mSrc->GetLeafName(&leafName);

        newFilename->MoveTo(parent, leafName);
    
        if(leafName)
            nsCRT::free(leafName);
      }
      else
        return nsInstall::UNEXPECTED_ERROR;
    }
    else
      return nsInstall::UNEXPECTED_ERROR;
  }

  return ret;
}

PRInt32
nsInstallFileOpItem::NativeFileOpFileCopyPrepare()
{
  PRBool flagExists, flagIsFile;
  char* leafName;
  nsCOMPtr<nsIFile> tempVar;

  // XXX needs to check file attributes to make sure
  // user has proper permissions to delete file.
  // Waiting on dougt's fix to nsFileSpec().
  // In the meantime, check as much as possible.
  
  mSrc->Exists(&flagExists);
  if(flagExists)
  {
    mSrc->IsFile(&flagIsFile);
    if(flagIsFile)
    {
      mTarget->Exists(&flagExists);
      if(!flagExists)
        return nsInstall::DOES_NOT_EXIST;
      else
      {
        mTarget->IsFile(&flagIsFile);
        if(flagIsFile)
          return nsInstall::IS_FILE;
        else
        {
          mTarget->Clone(getter_AddRefs(tempVar));
          mSrc->GetLeafName(&leafName);
          tempVar->Append(leafName);
        }

        tempVar->Exists(&flagExists);
        if(flagExists)
          return nsInstall::ALREADY_EXISTS;
      }

      return nsInstall::SUCCESS;
    }
    else
      return nsInstall::SOURCE_IS_DIRECTORY;
  }
    
  return nsInstall::SOURCE_DOES_NOT_EXIST;
}

PRInt32
nsInstallFileOpItem::NativeFileOpFileCopyComplete()
{
  PRInt32 ret;
  char* leafName;

  mAction = nsInstallFileOpItem::ACTION_FAILED;

  mSrc->GetLeafName(&leafName);
  ret = mSrc->CopyTo(mTarget, leafName);
  if(nsInstall::SUCCESS == ret)
    mAction = nsInstallFileOpItem::ACTION_SUCCESS;

  return ret;
}

PRInt32
nsInstallFileOpItem::NativeFileOpFileCopyAbort()
{
  nsCOMPtr<nsIFile> fullTarget;
  PRInt32 ret = nsInstall::SUCCESS;

  mTarget->Clone(getter_AddRefs(fullTarget));
  if(nsInstallFileOpItem::ACTION_SUCCESS == mAction)
  {
    char* leafName;
    mSrc->GetLeafName(&leafName);
    fullTarget->Append(leafName);
    fullTarget->Delete(PR_FALSE);
  }

  return ret;
}

PRInt32
nsInstallFileOpItem::NativeFileOpFileDeletePrepare()
{
  PRBool flagExists, flagIsFile;

  // XXX needs to check file attributes to make sure
  // user has proper permissions to delete file.
  // Waiting on dougt's fix to nsFileSpec().
  // In the meantime, check as much as possible.
  
  mTarget->Exists(&flagExists);
  if(flagExists)
  {
    mTarget->IsFile(&flagIsFile);
    if(flagIsFile)
      return nsInstall::SUCCESS;
    else
      return nsInstall::IS_DIRECTORY;
  }
    
  return nsInstall::DOES_NOT_EXIST;
}

PRInt32
nsInstallFileOpItem::NativeFileOpFileDeleteComplete(nsIFile *aTarget)
{
  PRBool flagExists, flagIsFile;

  aTarget->Exists(&flagExists);
  if(flagExists)
  {
    aTarget->IsFile(&flagIsFile);
    if(flagIsFile)
      return DeleteFileNowOrSchedule(aTarget);
    else
      return nsInstall::IS_DIRECTORY;
  }
    
  return nsInstall::DOES_NOT_EXIST;
}

PRInt32
nsInstallFileOpItem::NativeFileOpFileExecutePrepare()
{
  PRBool flagExists, flagIsFile;
  // XXX needs to check file attributes to make sure
  // user has proper permissions to delete file.
  // Waiting on dougt's fix to nsFileSpec().
  // In the meantime, check as much as possible.
  // Also, an absolute path (with filename) must be
  // used.  Xpinstall does not assume files are on the path.
  mTarget->Exists(&flagExists);
  if(flagExists)
  {
    mTarget->IsFile(&flagIsFile);
    if(flagIsFile)
      return nsInstall::SUCCESS;
    else
      return nsInstall::IS_DIRECTORY;
  }
    
  return nsInstall::DOES_NOT_EXIST;
}

PRInt32
nsInstallFileOpItem::NativeFileOpFileExecuteComplete()
{
  //mTarget->Execute(*mParams);
  //mTarget->Spawn(nsAutoCString(*mParams), 0);

  char *cParams[1];

  cParams[0] = nsnull;
  cParams[0] = mParams->ToNewCString();

  if(cParams[0] == nsnull)
    return nsInstall::OUT_OF_MEMORY;

  mTarget->Spawn((const char **)&cParams[0], 1);

  if(cParams[0])
    delete(cParams[0]);

  // We don't care if it succeeded or not since we
  // don't wait for the process to end anyways.
  // If the file doesn't exist, it was already detected
  // during the prepare phase.
  return nsInstall::SUCCESS;
}

PRInt32
nsInstallFileOpItem::NativeFileOpFileMovePrepare()
{
  PRBool flagExists, flagIsFile;

  mSrc->Exists(&flagExists);
  if(flagExists)
  {
    mTarget->Exists(&flagExists);
    if(!flagExists)
      return nsInstall::DOES_NOT_EXIST;
    else
    {
      mTarget->IsFile(&flagIsFile);
      if(flagIsFile)
        return nsInstall::IS_FILE;
      else
      {
        nsCOMPtr<nsIFile> tempVar;
        char* leaf;

        mTarget->Clone(getter_AddRefs(tempVar));
        mSrc->GetLeafName(&leaf);
        tempVar->Append(leaf);

        tempVar->Exists(&flagExists);
        if(flagExists)
          return nsInstall::ALREADY_EXISTS;
        else
          return NativeFileOpFileCopyPrepare();
      }
    }
  }

  return nsInstall::SOURCE_DOES_NOT_EXIST;
}

PRInt32
nsInstallFileOpItem::NativeFileOpFileMoveComplete()
{
  PRBool flagExists;
  PRInt32 ret = nsInstall::SUCCESS;

  mAction = nsInstallFileOpItem::ACTION_FAILED;
  mSrc->Exists(&flagExists);
  if(flagExists)
  {
    mTarget->Exists(&flagExists);
    if(!flagExists)
      ret = nsInstall::DOES_NOT_EXIST;
    else
    {
      PRInt32 ret2 = nsInstall::SUCCESS;

      ret = NativeFileOpFileCopyComplete();
      if(nsInstall::SUCCESS == ret)
      {
        mAction = nsInstallFileOpItem::ACTION_SUCCESS;
        ret2    = NativeFileOpFileDeleteComplete(mSrc);

        // We don't care if the value of ret2 is other than
        // REBOOT_NEEDED.  ret takes precedence otherwise.
        if(nsInstall::REBOOT_NEEDED == ret2)
          ret = ret2;
      }
    }
  }
  else
    ret = nsInstall::SOURCE_DOES_NOT_EXIST;

  return ret;
}

PRInt32
nsInstallFileOpItem::NativeFileOpFileMoveAbort()
{
  PRBool flagExists;
  PRInt32 ret = nsInstall::SUCCESS;

  if(nsInstallFileOpItem::ACTION_SUCCESS == mAction)
  {
    mSrc->Exists(&flagExists);
    if(flagExists)
      ret = NativeFileOpFileDeleteComplete(mTarget);
    else
    {
      mTarget->Exists(&flagExists);
      if(flagExists)
      {
        nsCOMPtr<nsIFile> tempVar;
        PRInt32    ret2 = nsInstall::SUCCESS;

        // switch the values of mSrc and mTarget
        // so the original state can be restored.
        // NativeFileOpFileCopyComplete() copies from
        // mSrc to mTarget by default.
        mTarget->Clone(getter_AddRefs(tempVar));
        mSrc->Clone(getter_AddRefs(mTarget));
        tempVar->Clone(getter_AddRefs(mSrc));

        ret = NativeFileOpFileCopyComplete();
        if(nsInstall::SUCCESS == ret)
        {
          ret2 = NativeFileOpFileDeleteComplete(mSrc);

          // We don't care if the value of ret2 is other than
          // REBOOT_NEEDED.  ret takes precedence otherwise.
          if(nsInstall::REBOOT_NEEDED == ret2)
            ret = ret2;
        }
      }
      else
        ret = nsInstall::DOES_NOT_EXIST;
    }
  }

  return ret;
}

PRInt32
nsInstallFileOpItem::NativeFileOpDirRenamePrepare()
{
  PRBool flagExists, flagIsFile;
  // XXX needs to check file attributes to make sure
  // user has proper permissions to delete file.
  // Waiting on dougt's fix to nsFileSpec().
  // In the meantime, check as much as possible.
  mSrc->Exists(&flagExists);
  if(flagExists)
  {
    mSrc->IsFile(&flagIsFile);
    if(!flagIsFile)
    {
      nsCOMPtr<nsIFile> target;

      mSrc->GetParent(getter_AddRefs(target));
      target->Append(nsAutoCString(*mStrTarget));

      target->Exists(&flagExists);
      if(flagExists)
        return nsInstall::ALREADY_EXISTS;
      else
        return nsInstall::SUCCESS;
    }
    else
      return nsInstall::IS_FILE;
  }
    
  return nsInstall::SOURCE_DOES_NOT_EXIST;
}

PRInt32
nsInstallFileOpItem::NativeFileOpDirRenameComplete()
{
  PRBool flagExists, flagIsFile;
  PRInt32 ret = nsInstall::SUCCESS;

  mSrc->Exists(&flagExists);
  if(flagExists)
  {
    mSrc->IsFile(&flagIsFile);
    if(!flagIsFile)
    {
      nsCOMPtr<nsIFile> target;

      mSrc->GetParent(getter_AddRefs(target));
      target->Append(nsAutoCString(*mStrTarget));

      target->Exists(&flagExists);
      if(!flagExists)
      {
        nsAutoCString cStrTarget(*mStrTarget);

        nsCOMPtr<nsIFile> parent;
        mSrc->GetParent(getter_AddRefs(parent));
        ret = mSrc->MoveTo(parent, cStrTarget);
      }
      else
        return nsInstall::ALREADY_EXISTS;
    }
    else
      ret = nsInstall::SOURCE_IS_FILE;
  }
  else  
    ret = nsInstall::SOURCE_DOES_NOT_EXIST;

  return ret;
}

PRInt32
nsInstallFileOpItem::NativeFileOpDirRenameAbort()
{
  PRBool     flagExists;
  PRInt32    ret = nsInstall::SUCCESS;
  char*      leafName;
  nsCOMPtr<nsIFile> newDirName;
  nsCOMPtr<nsIFile> parent;

  mSrc->Exists(&flagExists);
  if(!flagExists)
  {
    mSrc->GetParent(getter_AddRefs(newDirName));
    newDirName->Append(nsAutoCString(*mStrTarget));
    mSrc->GetLeafName(&leafName);
    mSrc->GetParent(getter_AddRefs(parent));
    ret = newDirName->MoveTo(parent, leafName);
    
    if(leafName)
      nsCRT::free(leafName);
  }

  return ret;
}

PRInt32
nsInstallFileOpItem::NativeFileOpWindowsShortcutPrepare()
{
  PRInt32 ret = nsInstall::SUCCESS;

#ifdef _WINDOWS
  nsCOMPtr<nsIFile> tempVar;
  PRBool            flagExists;

  if(mShortcutPath)
  {
    mShortcutPath->Clone(getter_AddRefs(tempVar));
    tempVar->Exists(&flagExists);
    if(!flagExists)
    {
      tempVar->Create(1, 0755);
      tempVar->Exists(&flagExists);
      if(!flagExists)
        ret = nsInstall::ACCESS_DENIED;
    }
    else
    {
      tempVar->Append("NSTestDir");
      tempVar->Create(1, 0755);
      tempVar->Exists(&flagExists);
      if(!flagExists)
        ret = nsInstall::ACCESS_DENIED;
      else
        tempVar->Delete(0);
    }
  }

  if(nsInstall::SUCCESS == ret)
    mAction = nsInstallFileOpItem::ACTION_SUCCESS;

#endif

  return ret;
}

PRInt32
nsInstallFileOpItem::NativeFileOpWindowsShortcutComplete()
{
  PRInt32 ret = nsInstall::SUCCESS;

#ifdef _WINDOWS
  char *cDescription             = nsnull;
  char *cParams                  = nsnull;
  char *targetNativePathStr      = nsnull;
  char *shortcutNativePathStr    = nsnull;
  char *workingpathNativePathStr = nsnull;
  char *iconNativePathStr        = nsnull;

  if(mDescription)
    cDescription = mDescription->ToNewCString();
  if(mParams)
    cParams = mParams->ToNewCString();

  if((cDescription == nsnull) || (cParams == nsnull))
    ret = nsInstall::OUT_OF_MEMORY;
  else
  {
    if(mTarget)
      mTarget->GetPath(&targetNativePathStr);
    if(mShortcutPath)
      mShortcutPath->GetPath(&shortcutNativePathStr);
    if(mWorkingPath)
      mWorkingPath->GetPath(&workingpathNativePathStr);
    if(mIcon)
      mIcon->GetPath(&iconNativePathStr);

    ret = CreateALink(targetNativePathStr,
                      shortcutNativePathStr,
                      cDescription,
                      workingpathNativePathStr,
                      cParams,
                      iconNativePathStr,
                      mIconId);

    if(nsInstall::SUCCESS == ret)
      mAction = nsInstallFileOpItem::ACTION_SUCCESS;
  }

  if(cDescription)
    delete(cDescription);
  if(cParams)
    delete(cParams);
#endif

  return ret;
}

PRInt32
nsInstallFileOpItem::NativeFileOpWindowsShortcutAbort()
{
#ifdef _WINDOWS
  nsString   shortcutDescription;
  nsCOMPtr<nsIFile> shortcutTarget;

  shortcutDescription = *mDescription;
  shortcutDescription.AppendWithConversion(".lnk");
  mShortcutPath->Clone(getter_AddRefs(shortcutTarget));
  shortcutTarget->Append(nsAutoCString(shortcutDescription));

  NativeFileOpFileDeleteComplete(shortcutTarget);
#endif

  return nsInstall::SUCCESS;
}

PRInt32
nsInstallFileOpItem::NativeFileOpMacAliasComplete()
{

#ifdef XP_MAC
  // XXX gestalt to see if alias manager is around
  
  nsCOMPtr<nsILocalFileMac> localFileMacTarget = do_QueryInterface(mTarget);
  nsCOMPtr<nsILocalFileMac> localFileMacSrc = do_QueryInterface(mSrc);
  
  FSSpec        fsSource, fsAliasParent, fsAlias;
  AliasHandle   aliasH;
  FInfo         info;
  OSErr         err = noErr;
  nsresult      rv = NS_OK;
  long          aliasDirID;
  Boolean       isDir;
  char          *aliasLeaf;  
  
  // nsIFile sucks so we have to do special hackery here
  rv = localFileMacSrc->GetResolvedFSSpec(&fsSource);
  if (!NS_SUCCEEDED(rv)) return rv;
  rv = localFileMacTarget->GetFSSpec(&fsAliasParent); 
  if (!NS_SUCCEEDED(rv)) return rv;
  rv = localFileMacTarget->GetAppendedPath(&aliasLeaf);
  if (!NS_SUCCEEDED(rv)) return rv;

  // construct target alias FSSpec using parent and leaf path
  err = FSpGetDirectoryID(&fsAliasParent, &aliasDirID, &isDir);
  if (err != noErr) 
  {
    if (aliasLeaf)
      nsMemory::Free(aliasLeaf);
    return err;
  }
  c2pstr(aliasLeaf);
  FSMakeFSSpec(fsAliasParent.vRefNum, aliasDirID, (unsigned char *) aliasLeaf, &fsAlias);
  p2cstr((unsigned char *)aliasLeaf);
  if (aliasLeaf)
    nsMemory::Free(aliasLeaf);
  
  err = NewAliasMinimal( &fsSource, &aliasH );
  if (err != noErr)  // bubble up Alias Manager error
  	return err;
  	
  // create the alias file
  FSpGetFInfo(&fsSource, &info);
  FSpCreateResFile(&fsAlias, info.fdCreator, info.fdType, smRoman);
  short refNum = FSpOpenResFile(&fsAlias, fsRdWrPerm);
  if (refNum != -1)
  {
    UseResFile(refNum);
    AddResource((Handle)aliasH, rAliasType, 0, fsAlias.name);
    ReleaseResource((Handle)aliasH);
    UpdateResFile(refNum);
    CloseResFile(refNum);
  }
  else
    return nsInstall::SUCCESS;  // non-fatal so prevent internal abort
  
  // mark newly created file as an alias file
  FSpGetFInfo(&fsAlias, &info);
  info.fdFlags |= kIsAlias;
  FSpSetFInfo(&fsAlias, &info);
#endif

  return nsInstall::SUCCESS;
}

PRInt32
nsInstallFileOpItem::NativeFileOpMacAliasAbort()
{  
#ifdef XP_MAC
  NativeFileOpFileDeleteComplete(mTarget);
#endif 

  return nsInstall::SUCCESS;
}

PRInt32
nsInstallFileOpItem::NativeFileOpUnixLink()
{
  return nsInstall::SUCCESS;
}

PRInt32
nsInstallFileOpItem::NativeFileOpWindowsRegisterServerPrepare()
{
  PRInt32 rv = nsInstall::SUCCESS;

#ifdef _WINDOWS
  char      *file = nsnull;
  FARPROC   DllReg;
  HINSTANCE hLib;

  mTarget->GetPath(&file);
  if(file != nsnull)
  {
    if((hLib = LoadLibraryEx(file, NULL, LOAD_WITH_ALTERED_SEARCH_PATH)) != NULL)
    {
      if((DllReg = GetProcAddress(hLib, "DllRegisterServer")) == NULL)
        rv = nsInstall::UNABLE_TO_LOCATE_LIB_FUNCTION;

      FreeLibrary(hLib);
    }
    else
      rv = nsInstall::UNABLE_TO_LOAD_LIBRARY;
  }
  else
    rv = nsInstall::UNEXPECTED_ERROR;
#endif

  return(rv);
}

PRInt32
nsInstallFileOpItem::NativeFileOpWindowsRegisterServerComplete()
{
  PRInt32 rv = nsInstall::SUCCESS;

#ifdef _WINDOWS
  char      *file = nsnull;
  FARPROC   DllReg;
  HINSTANCE hLib;

  mTarget->GetPath(&file);
  if(file != nsnull)
  {
    if((hLib = LoadLibraryEx(file, NULL, LOAD_WITH_ALTERED_SEARCH_PATH)) != NULL)
    {
      if((DllReg = GetProcAddress(hLib, "DllRegisterServer")) != NULL)
        DllReg();
      else
        rv = nsInstall::UNABLE_TO_LOCATE_LIB_FUNCTION;

      FreeLibrary(hLib);
    }
    else
      rv = nsInstall::UNABLE_TO_LOAD_LIBRARY;
  }
  else
    rv = nsInstall::UNEXPECTED_ERROR;
#endif

  return(rv);
}

PRInt32
nsInstallFileOpItem::NativeFileOpWindowsRegisterServerAbort()
{
  PRInt32 rv = nsInstall::SUCCESS;

#ifdef _WINDOWS
  char      *file = nsnull;
  FARPROC   DllUnReg;
  HINSTANCE hLib;

  mTarget->GetPath(&file);
  if(file != nsnull)
  {
    if((hLib = LoadLibraryEx(file, NULL, LOAD_WITH_ALTERED_SEARCH_PATH)) != NULL)
    {
      if((DllUnReg = GetProcAddress(hLib, "DllUnregisterServer")) != NULL)
        DllUnReg();
      else
        rv = nsInstall::UNABLE_TO_LOCATE_LIB_FUNCTION;

      FreeLibrary(hLib);
    }
    else
      rv = nsInstall::UNABLE_TO_LOAD_LIBRARY;
  }
  else
    rv = nsInstall::UNEXPECTED_ERROR;
#endif

  return(rv);
}