// check if a file handle is for kernel32.dll
static bool kludge_isKernel32Dll(HANDLE fileHandle, std::string &kernel32Name) {
    static DWORD IndxHigh, IndxLow;
    static bool firstTime = true;
    BY_HANDLE_FILE_INFORMATION info;
    static std::string kernel32Name_;

    if (firstTime) {
       HANDLE kernel32H;
       firstTime = false;
       char sysRootDir[MAX_PATH+1];
       if (GetSystemDirectory(sysRootDir, MAX_PATH) == 0)
          assert(0);
       kernel32Name_ = std::string(sysRootDir) + "\\kernel32.dll";
       kernel32H = CreateFile(kernel32Name_.c_str(), GENERIC_READ, 
                              FILE_SHARE_READ, NULL, OPEN_EXISTING, NULL, NULL);
       assert(kernel32H);
       if (!GetFileInformationByHandle(kernel32H, &info)) {
          printSysError(GetLastError());
          assert(0);
       }
       IndxHigh = info.nFileIndexHigh;
       IndxLow = info.nFileIndexLow;
       CloseHandle(kernel32H);
    }

    if (!GetFileInformationByHandle(fileHandle, &info))
       return false;

    if (info.nFileIndexHigh==IndxHigh && info.nFileIndexLow==IndxLow) {
      kernel32Name = kernel32Name_;
      return true;
    }
    return false;
}

bool LuaProxy::Misc::isSamePath(const std::string first, const std::string second) 
{
    HANDLE hFileFirst = CreateFileA(first.c_str(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, NULL, NULL);
    if (hFileFirst == INVALID_HANDLE_VALUE) return false;
    HANDLE hFileSecond = CreateFileA(second.c_str(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, NULL, NULL);
    if (hFileSecond == INVALID_HANDLE_VALUE) {
        CloseHandle(hFileFirst);
        return false;
    }

    BY_HANDLE_FILE_INFORMATION fInfoFirst = { 0 };
    BY_HANDLE_FILE_INFORMATION fInfoSecond = { 0 };
    BOOL success = GetFileInformationByHandle(hFileFirst, &fInfoFirst);
    success = success && GetFileInformationByHandle(hFileSecond, &fInfoSecond);
    if (!success) {
        CloseHandle(hFileFirst);
        CloseHandle(hFileSecond);
        return false;
    }

    bool isSame = fInfoFirst.dwVolumeSerialNumber == fInfoSecond.dwVolumeSerialNumber &&
        fInfoFirst.nFileIndexLow == fInfoSecond.nFileIndexLow &&
        fInfoFirst.nFileIndexHigh == fInfoSecond.nFileIndexHigh;

    CloseHandle(hFileFirst);
    CloseHandle(hFileSecond);
    
    return isSame;
}

// Code adapted from http://stackoverflow.com/questions/562701/best-way-to-determine-if-two-path-reference-to-same-file-in-c-c/562830#562830
// Determine if 2 paths point ot the same file...
bool IsSame(const WCHAR *path1, const WCHAR *path2)
{
    bool isSame = false, needFallback = true;
    HANDLE handle1 = CreateFile(path1, 0, 0, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
    HANDLE handle2 = CreateFile(path2, 0, 0, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);

    if (handle1 != INVALID_HANDLE_VALUE && handle2 != INVALID_HANDLE_VALUE) {
        BY_HANDLE_FILE_INFORMATION fi1, fi2;
        if (GetFileInformationByHandle(handle1, &fi1) && GetFileInformationByHandle(handle2, &fi2)) {
            isSame = fi1.dwVolumeSerialNumber == fi2.dwVolumeSerialNumber &&
                     fi1.nFileIndexHigh == fi2.nFileIndexHigh &&
                     fi1.nFileIndexLow == fi2.nFileIndexLow;
            needFallback = false;
        }
    }

    CloseHandle(handle1);
    CloseHandle(handle2);

    if (!needFallback)
        return isSame;

    ScopedMem<WCHAR> npath1(Normalize(path1));
    ScopedMem<WCHAR> npath2(Normalize(path2));
    // consider the files different, if their paths can't be normalized
    if (!npath1 || !npath2)
        return false;
    return str::EqI(npath1, npath2);
}

int CheckFiles(HANDLE hFile1, HANDLE hFile2)
{

	BY_HANDLE_FILE_INFORMATION info1;
	BY_HANDLE_FILE_INFORMATION info2;
    BOOL r1 = GetFileInformationByHandle(hFile1, &info1);
    BOOL r2 = GetFileInformationByHandle(hFile2, &info2);

	if (!r1 && !r2) {
		return 0;
	}
	else if (r1 && !r2) {
		return 1;
	}
	else if (!r1 && r2) {
		return -1;
	}

	if (info1.dwVolumeSerialNumber != info2.dwVolumeSerialNumber) {
		return info1.dwVolumeSerialNumber - info2.dwVolumeSerialNumber;
	}

	if (info1.nFileIndexHigh != info2.nFileIndexHigh) {
		return info1.nFileIndexHigh - info2.nFileIndexHigh;
	}
	return info1.nFileIndexLow - info2.nFileIndexLow;
}

/* Return non-zero if F1 and F2 are 2 streams representing the same
   file or pipe or device.  */
int
same_stream (FILE *f1, FILE *f2)
{
  HANDLE fh1 = (HANDLE)_get_osfhandle (fileno (f1));
  HANDLE fh2 = (HANDLE)_get_osfhandle (fileno (f2));

  /* Invalid file descriptors get treated as different streams.  */
  if (fh1 && fh1 != INVALID_HANDLE_VALUE
      && fh2 && fh2 != INVALID_HANDLE_VALUE)
    {
      if (fh1 == fh2)
        return 1;
      else
        {
          DWORD ftyp1 = GetFileType (fh1), ftyp2 = GetFileType (fh2);

          if (ftyp1 != ftyp2
              || ftyp1 == FILE_TYPE_UNKNOWN || ftyp2 == FILE_TYPE_UNKNOWN)
            return 0;
          else if (ftyp1 == FILE_TYPE_CHAR)
            {
              /* For character devices, check if they both refer to a
                 console.  This loses if both handles refer to the
                 null device (FIXME!), but in that case we don't care
                 in the context of Make.  */
              DWORD conmode1, conmode2;

              /* Each process on Windows can have at most 1 console,
                 so if both handles are for the console device, they
                 are the same.  We also compare the console mode to
                 distinguish between stdin and stdout/stderr.  */
              if (GetConsoleMode (fh1, &conmode1)
                  && GetConsoleMode (fh2, &conmode2)
                  && conmode1 == conmode2)
                return 1;
            }
          else
            {
              /* For disk files and pipes, compare their unique
                 attributes.  */
              BY_HANDLE_FILE_INFORMATION bhfi1, bhfi2;

              /* Pipes get zero in the volume serial number, but do
                 appear to have meaningful information in file index
                 attributes.  We test file attributes as well, for a
                 good measure.  */
              if (GetFileInformationByHandle (fh1, &bhfi1)
                  && GetFileInformationByHandle (fh2, &bhfi2))
                return (bhfi1.dwVolumeSerialNumber == bhfi2.dwVolumeSerialNumber
                        && bhfi1.nFileIndexLow == bhfi2.nFileIndexLow
                        && bhfi1.nFileIndexHigh == bhfi2.nFileIndexHigh
                        && bhfi1.dwFileAttributes == bhfi2.dwFileAttributes);
            }
        }
    }
  return 0;
}

bool
tr_sys_path_is_same (const char  * path1,
                     const char  * path2,
                     tr_error   ** error)
{
  bool ret = false;
  wchar_t * wide_path1 = NULL;
  wchar_t * wide_path2 = NULL;
  HANDLE handle1 = INVALID_HANDLE_VALUE;
  HANDLE handle2 = INVALID_HANDLE_VALUE;
  BY_HANDLE_FILE_INFORMATION fi1, fi2;

  assert (path1 != NULL);
  assert (path2 != NULL);

  wide_path1 = tr_win32_utf8_to_native (path1, -1);
  if (wide_path1 == NULL)
    goto fail;

  wide_path2 = tr_win32_utf8_to_native (path2, -1);
  if (wide_path2 == NULL)
    goto fail;

  handle1 = CreateFileW (wide_path1, 0, 0, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
  if (handle1 == INVALID_HANDLE_VALUE)
    goto fail;

  handle2 = CreateFileW (wide_path2, 0, 0, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
  if (handle2 == INVALID_HANDLE_VALUE)
    goto fail;

  /* TODO: Use GetFileInformationByHandleEx on >= Server 2012 */

  if (!GetFileInformationByHandle (handle1, &fi1) || !GetFileInformationByHandle (handle2, &fi2))
    goto fail;

  ret = fi1.dwVolumeSerialNumber == fi2.dwVolumeSerialNumber &&
        fi1.nFileIndexHigh == fi2.nFileIndexHigh &&
        fi1.nFileIndexLow  == fi2.nFileIndexLow;

  goto cleanup;

fail:
  set_system_error_if_file_found (error, GetLastError ());

cleanup:
  CloseHandle (handle2);
  CloseHandle (handle1);

  tr_free (wide_path2);
  tr_free (wide_path1);

  return ret;
}

static bool GetStatByHandle(TSystemFStat& fs, FHANDLE f) {
#ifdef _win_
    return GetFileInformationByHandle(f, &fs);
#else
    return !fstat(f, &fs);
#endif
}

static INT_PTR CDECL fci_get_open_info( char *name, USHORT *date, USHORT *time,
                                        USHORT *attribs, int *err, void *ptr )
{
    HANDLE handle;
    BY_HANDLE_FILE_INFORMATION info;
    WCHAR *p, *nameW = strdupAtoW( CP_UTF8, name );

    handle = CreateFileW( nameW, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
                          NULL, OPEN_EXISTING, 0, NULL );
    if (handle == INVALID_HANDLE_VALUE)
    {
        *err = GetLastError();
        WINE_ERR( "failed to open %s: error %u\n", wine_dbgstr_w(nameW), *err );
        cab_free( nameW );
        return -1;
    }
    if (!GetFileInformationByHandle( handle, &info ))
    {
        *err = GetLastError();
        CloseHandle( handle );
        cab_free( nameW );
        return -1;
    }
    FileTimeToDosDateTime( &info.ftLastWriteTime, date, time );
    *attribs = info.dwFileAttributes & (_A_RDONLY | _A_HIDDEN | _A_SYSTEM | _A_ARCH);
    for (p = nameW; *p; p++) if (*p >= 0x80) break;
    if (*p) *attribs |= _A_NAME_IS_UTF;
    cab_free( nameW );
    return (INT_PTR)handle;
}

/**
 * Get two values that (together with the device number), uniquely
 * identify a file. Taken together these values create the windows
 * equivalent of UNIX inodes. If this fails for any reason a 0 is
 * returned, otherwise a 1 is returned. On failure only the st_rdev
 * value is set to zero, normally the st_ino (if this is the result
 * of a call to stat(), may have a sensible value).
 */
int win_get_inodes( const char *fns, ino_t *st_ino, dev_t *st_rdev )
{
    HANDLE fh;
    BY_HANDLE_FILE_INFORMATION info;
    DWORD error;
    int result = 1;

    /* Open file, use FILE_SHARE_READ and FILE_SHARE_WRITE as this
     * seems to be needed for win98 (but not for XP) */
    fh = CreateFile( fns, 0, FILE_SHARE_READ | FILE_SHARE_WRITE,
                     NULL, OPEN_EXISTING, 0, NULL );
    if ( fh != INVALID_HANDLE_VALUE ) {

        if ( GetFileInformationByHandle( fh, &info ) ) {
            *st_ino = info.nFileIndexLow;
            *st_rdev = info.nFileIndexHigh;
        }
        else {
            *st_rdev = 0;
            result = 0;
        }
        CloseHandle( fh );
    }
    else {
        *st_rdev = 0;
        result = 0;
    }
    return result;
}

__int64 FileReader::GetFileSize()
{
  CAutoLockFR rLock (&m_accessLock);

	if (m_hFile == INVALID_HANDLE_VALUE) 
  {
    //LogDebug("FileReader::GetFileSize() no open file");
		return -1;
	}
  
  BY_HANDLE_FILE_INFORMATION fileinfo;
		
  //fill the structure with info regarding the file
  if (GetFileInformationByHandle(m_hFile, &fileinfo))
  {	  
    //Extract the file size info
  	LARGE_INTEGER li;
  	li.LowPart  = fileinfo.nFileSizeLow;
  	li.HighPart = fileinfo.nFileSizeHigh;
  	
	  return li.QuadPart;
  }
  
  HRESULT lastErr = HRESULT_FROM_WIN32(GetLastError());	  
	LogDebug("FileReader::GetFileSize() failed. Error 0x%x, %ws, filename = %ws", lastErr, HresultToCString(lastErr), m_pFileName);    
  return -1;
}

static int filefind_index_number_of_links_helper(lua_State* L, struct FileFindInfo* info) {
#if defined(_WIN32)
	HANDLE handle;
	BY_HANDLE_FILE_INFORMATION fileInformation;

	char fullPath[MAX_PATH];
	strcpy(fullPath, info->path);
	strcat(fullPath, info->fd.cFileName);

	handle = CreateFile(fullPath, 0, 0, NULL, OPEN_EXISTING, 0, NULL);
	if (handle == INVALID_HANDLE_VALUE) {
		lua_pushnumber(L, 0);
		return 1;
	}
	if (GetFileInformationByHandle(handle, &fileInformation) == FALSE) {
		CloseHandle(handle);
		lua_pushnumber(L, 0);
		return 1;
	}
	CloseHandle(handle);

	lua_pushnumber(L, fileInformation.nNumberOfLinks);
#else
	lua_pushnumber(L, 0);
#endif
	return 1;
}

bool CRawFile::Stat( struct stat *pFileStats ) const
{
#ifdef _WIN32
    BY_HANDLE_FILE_INFORMATION info;

    if (!GetFileInformationByHandle( m_file, &info ))
        return false;

    pFileStats->st_size = info.nFileSizeLow;
    pFileStats->st_dev = info.nFileIndexLow;
    pFileStats->st_atime = info.ftLastAccessTime.dwLowDateTime;
    pFileStats->st_ctime = info.ftCreationTime.dwLowDateTime;
    pFileStats->st_mtime = info.ftLastWriteTime.dwLowDateTime;
    pFileStats->st_dev = info.dwVolumeSerialNumber;
    pFileStats->st_mode = 0;
    pFileStats->st_nlink = (unsigned short)info.nNumberOfLinks;
    pFileStats->st_rdev = 0;
    pFileStats->st_gid = 0;
    return true;
#elif __linux
    return fstat( fileno( m_file ), pFileStats ) != 0;
#else
    return false;
#endif //OS DEPENDANT CODE
}

/*************************************************************************
 * IStream_fnStat
 */
static HRESULT WINAPI IStream_fnStat(IStream *iface, STATSTG* lpStat,
                                     DWORD grfStatFlag)
{
    ISHFileStream *This = impl_from_IStream(iface);
    BY_HANDLE_FILE_INFORMATION fi;

    TRACE("(%p,%p,%d)\n", This, lpStat, grfStatFlag);

    if (!grfStatFlag)
        return STG_E_INVALIDPOINTER;

    memset(&fi, 0, sizeof(fi));
    GetFileInformationByHandle(This->hFile, &fi);

    if (grfStatFlag & STATFLAG_NONAME)
      lpStat->pwcsName = NULL;
    else
      lpStat->pwcsName = StrDupW(This->lpszPath);
    lpStat->type = This->type;
    lpStat->cbSize.u.LowPart = fi.nFileSizeLow;
    lpStat->cbSize.u.HighPart = fi.nFileSizeHigh;
    lpStat->mtime = fi.ftLastWriteTime;
    lpStat->ctime = fi.ftCreationTime;
    lpStat->atime = fi.ftLastAccessTime;
    lpStat->grfMode = This->dwMode;
    lpStat->grfLocksSupported = 0;
    memcpy(&lpStat->clsid, &IID_IStream, sizeof(CLSID));
    lpStat->grfStateBits = This->grfStateBits;
    lpStat->reserved = 0;

    return S_OK;
}

    bool GetPlatformFileInfo(PlatformFile file, PlatformFileInfo* info)
    {
        ThreadRestrictions::AssertIOAllowed();
        if(!info)
        {
            return false;
        }

        BY_HANDLE_FILE_INFORMATION file_info;
        if(GetFileInformationByHandle(file, &file_info) == 0)
        {
            return false;
        }

        LARGE_INTEGER size;
        size.HighPart = file_info.nFileSizeHigh;
        size.LowPart = file_info.nFileSizeLow;
        info->size = size.QuadPart;
        info->is_directory =
            (file_info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
        info->last_modified = base::Time::FromFileTime(file_info.ftLastWriteTime);
        info->last_accessed = base::Time::FromFileTime(file_info.ftLastAccessTime);
        info->creation_time = base::Time::FromFileTime(file_info.ftCreationTime);
        return true;
    }

/**
 * stat a file and return the appropriate object
 * This would better be done on an open file handle
 */
int file_metadata_t::stat(const tstring &fn,
			  file_metadata_t *m,
			  class display &ocb)
{
  struct __stat64 sb;
  if (::TSTAT(fn.c_str(),&sb)) 
  {
    ocb.error_filename(fn,"%s",strerror(errno));
    return -1;
  }
  m->fileid.dev = sb.st_dev;
#ifdef _WIN32
  BY_HANDLE_FILE_INFORMATION fileinfo;
  HANDLE filehandle = CreateFile(fn.c_str(),
				 0,   // desired access
				 FILE_SHARE_READ,
				 NULL,  
				 OPEN_EXISTING,
				 (FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS),
				 NULL);
  // RBF - Error check CreateFile
  (void)GetFileInformationByHandle(filehandle, &fileinfo);
  CloseHandle(filehandle);
  m->fileid.ino = (((uint64_t)fileinfo.nFileIndexHigh)<<32) | (fileinfo.nFileIndexLow);
#else
  m->fileid.ino = sb.st_ino;
#endif
  m->nlink      = sb.st_nlink;
  m->size       = sb.st_size;
  m->ctime      = sb.st_ctime;
  m->mtime      = sb.st_mtime;
  m->atime      = sb.st_atime;

  return 0;
}

ofint32 
OFFile::type( )
{
    ofint32 t = 0;
#if defined(OFOPSYS_LINUX) || defined(OFOPSYS_SOLARIS) || defined(OFOPSYS_FREEBSD) || defined(OFOPSYS_DARWIN)
    struct stat statbuf;
    ofint32 rc = fstat( m_handle, &statbuf );
    if ( rc == -1 )
        t = -1;
    if ( S_ISDIR(statbuf.st_mode) )
        t = OFFILE_FILETYPE_DIR;
    if ( S_ISREG(statbuf.st_mode) )
        t = OFFILE_FILETYPE_FILE;
#elif defined(OFOPSYS_WIN32) && !defined(__CYGWIN__)
    BY_HANDLE_FILE_INFORMATION fi;
    GetFileInformationByHandle( m_handle, &fi );
    
    if ( fi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )
        t = OFFILE_FILETYPE_DIR;
    if ( ( fi.dwFileAttributes & FILE_ATTRIBUTE_NORMAL) || ( fi.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN ) ||
         ( fi.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM) )
        t = OFFILE_FILETYPE_FILE;
#else
#error Undefined platform
#endif
    return t;
}

int mingw_fstat(int fd, struct stat *buf)
{
	HANDLE fh = (HANDLE)_get_osfhandle(fd);
	BY_HANDLE_FILE_INFORMATION fdata;

	if (fh == INVALID_HANDLE_VALUE) {
		errno = EBADF;
		return -1;
	}
	/* direct non-file handles to MS's fstat() */
	if (GetFileType(fh) != FILE_TYPE_DISK)
		return _fstati64(fd, buf);

	if (GetFileInformationByHandle(fh, &fdata)) {
		buf->st_ino = 0;
		buf->st_gid = 0;
		buf->st_uid = 0;
		buf->st_nlink = 1;
		buf->st_mode = file_attr_to_st_mode(fdata.dwFileAttributes);
		buf->st_size = fdata.nFileSizeLow |
			(((off_t)fdata.nFileSizeHigh)<<32);
		buf->st_dev = buf->st_rdev = 0; /* not used by Git */
		buf->st_atime = filetime_to_time_t(&(fdata.ftLastAccessTime));
		buf->st_mtime = filetime_to_time_t(&(fdata.ftLastWriteTime));
		buf->st_ctime = filetime_to_time_t(&(fdata.ftCreationTime));
		return 0;
	}
	errno = EBADF;
	return -1;
}

LONG gfile_get_length(GFile *gf)
{
    BY_HANDLE_FILE_INFORMATION fi;
    ASSERT(gf != NULL);
    GetFileInformationByHandle((HANDLE)gf->m_hFile, &fi);
    return fi.nFileSizeLow;
}

static void compute_socketname(char socketname[PATHSZ], struct stat *st)
#endif
{
#ifdef _WIN32
  CHAR user[UNLEN + 1];
  DWORD dwBufSize = UNLEN;
  BY_HANDLE_FILE_INFORMATION info;
  HANDLE hFile = CreateFile(merlin_path, FILE_READ_ATTRIBUTES, FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
  if (hFile == INVALID_HANDLE_VALUE || !GetFileInformationByHandle(hFile, &info))
    failwith_perror("stat (cannot find ocamlmerlin binary)");
  CloseHandle(hFile);

  if (!GetUserName(user, &dwBufSize))
    user[0] = '\0';
  // @@DRA Need to use Windows API functions to get meaningful values for st_dev and st_ino
  snprintf(eventname, PATHSZ,
      "ocamlmerlin_%s_%lx_%llx",
      user,
      info.dwVolumeSerialNumber,
      ((__int64)info.nFileIndexHigh) << 32 | ((__int64)info.nFileIndexLow));
  snprintf(socketname, PATHSZ,
      "\\\\.\\pipe\\%s", eventname);
#else
  snprintf(socketname, PATHSZ,
      "ocamlmerlin_%llu_%llu_%llu.socket",
      (unsigned long long)getuid(),
      (unsigned long long)st->st_dev,
      (unsigned long long)st->st_ino);
#endif
}

bool os_fstat(int fd, const char* path, pony_stat_t* p)
{
#if defined(PLATFORM_IS_WINDOWS)
  HANDLE h = (HANDLE)_get_osfhandle(fd);
  BY_HANDLE_FILE_INFORMATION fa;

  if(!GetFileInformationByHandle(h, &fa))
    return false;

  struct __stat64 st;

  if(_fstat64(fd, &st) != 0)
    return false;

  windows_stat(path, p, &st, fa.dwFileAttributes,
    &fa.ftLastAccessTime, &fa.ftLastWriteTime, &fa.ftCreationTime);

  return true;
#elif defined(PLATFORM_IS_POSIX_BASED)
  (void)path;
  struct stat st;

  if(fstat(fd, &st) != 0)
    return false;

  unix_stat(p, &st);
  return true;
#endif
}