#include <cdlpch.h>
#pragma hdrstop

#include <winnls.h>
#include <shlobj.h>
 
CMutexSem g_mxsCDLGetLongPathNameGlobals;

// stolen from shellp.h
#define ILCreateFromPathORD                     157
#define ILFreeORD                               155

// stolen from shsemip.h
typedef LPITEMIDLIST  (WINAPI *ILCreateFromPathPtr)(LPCWSTR pszPath);
typedef void          (WINAPI *ILFreePtr)(LPITEMIDLIST pidl);

// We'll use this if we're running on Memphis or NT5
#ifdef UNICODE
#define STR_GETLONGPATHNAMEW "GetLongPathNameW"
typedef DWORD (WINAPI *GetLongPathNameWPtr)( LPCWSTR lpszShortPath,
                                             LPWSTR  lpszLongPath,
                                             DWORD    cchBuffer
                                           );
#else
#define STR_GETLONGPATHNAMEA "GetLongPathNameA"
typedef DWORD (WINAPI *GetLongPathNameAPtr)( LPCSTR lpszShortPath,
                                             LPSTR  lpszLongPath,
                                             DWORD    cchBuffer
                                           );
#endif


STATIC ILCreateFromPathPtr     s_pfnILCreate;
STATIC ILFreePtr               s_pfnILFree;
STATIC GetLongPathNameAPtr     s_pfnGetLongPathNameA;

#define cKnownDirs  5
STATIC struct KnownDirsMap {
    BOOL   m_bInited;
    LPTSTR m_aszCaches[cKnownDirs];
    struct _tagKDMap {
        TCHAR szShort[MAX_PATH];
        int cchShort;
        TCHAR szCanonical[MAX_PATH];
        int cchCanonical;
    } m_aKDMap[cKnownDirs];

    int IndexKnownDirs( LPTSTR szName )
    {
        int i;

        for ( i = 0; i < cKnownDirs; i++ ) {
            // we only want to compare out through the cache folder itself 
            BOOL fMatch = (m_aKDMap[i].cchShort != 0 &&
                           CompareString( LOCALE_SYSTEM_DEFAULT,
                                          NORM_IGNORECASE,
                                          m_aKDMap[i].szShort,
                                          m_aKDMap[i].cchShort,
                                          szName,
                                          m_aKDMap[i].cchShort ) == 2)
                                                 ||
                          (m_aKDMap[i].cchCanonical != 0 &&
                           CompareString( LOCALE_SYSTEM_DEFAULT,
                                          NORM_IGNORECASE,
                                          m_aKDMap[i].szCanonical,
                                          m_aKDMap[i].cchCanonical,
                                          szName,
                                          m_aKDMap[i].cchCanonical ) == 2);
            if ( fMatch )
                break;
        }

        if ( i >= cKnownDirs )
            i = -1; // signal a miss
        return i;
    };

} s_kdMap = {
    FALSE,
    { 
    "\\Occache\\",
    "\\OC Cache\\",
    "\\Downloaded ActiveX Controls\\",
    "\\Downloaded Components\\",
    "\\Downloaded Program Files\\"
    },
    {
        { 0, 0, 0, 0 },
        { 0, 0, 0, 0 },
        { 0, 0, 0, 0 }
    }
};

DWORD GetFullPathNameA_Wrap(
  LPCSTR lpFileName,  // file name
  DWORD nBufferLength, // size of path buffer
  LPSTR lpBuffer,     // path buffer
  LPSTR *lpFilePart   // address of file name in path
)
{
    DWORD dwRet = GetFullPathName(lpFileName, nBufferLength, lpBuffer, lpFilePart);

    if (dwRet && (dwRet<nBufferLength))
    {
        if (! *lpFilePart)
        {
            // to prevent crashes where lpFileName == directory name terminating with '\'.
            // See IE6 bug 19001 
            *lpFilePart = lpBuffer+dwRet; //make it point to NULL char.
        }
    }
    else
    {
        dwRet = 0;
        SetLastError(ERROR_INSUFFICIENT_BUFFER);
    }

    return dwRet;
}
   

STATIC BOOL IsCanonicalName( LPCTSTR szName )
{
    // simple test - if there's a ~ in it, it has a contraction in it
    // and is therefore non-canonical
    for ( ; *szName != '\0' && *szName != '~'; szName++ );
    
    return *szName != '~';
}

STATIC DWORD s_CDLGetLongPathName( LPTSTR szLong, LPCTSTR szShort, DWORD cchBuffer)
{
    HRESULT hr = E_FAIL;
    HMODULE hmodS32;
    HMODULE hmodK32;
    DWORD   cchLong = 0;

    // Don't jump through all these hoops if there aren't any contractions in it.
    if ( IsCanonicalName( szShort ) ) {
        lstrcpyn( szLong, szShort, cchBuffer );
        return lstrlen( szLong );
    }

    hmodS32 = LoadLibrary( "SHELL32.DLL" );
    hmodK32 = LoadLibrary( "KERNEL32.DLL" );

    // Set up our globals with short and long versions of the base cache path 
    if ( hmodS32 && hmodK32 ) {
#ifdef UNICODE
        s_pfnGetLongPathNameW = (GetLongPathNameWPtr)GetProcAddress(hmodK32, (LPCSTR)STR_GETLONGPATHNAMEW );
#else
        s_pfnGetLongPathNameA = (GetLongPathNameAPtr)GetProcAddress(hmodK32, (LPCSTR)STR_GETLONGPATHNAMEA );
#endif
        s_pfnILCreate = (ILCreateFromPathPtr)GetProcAddress(hmodS32, (LPCSTR)ILCreateFromPathORD );
        s_pfnILFree = (ILFreePtr)GetProcAddress(hmodS32, (LPCSTR)ILFreeORD );

        if ( s_pfnILCreate != NULL  && s_pfnILFree != NULL ) {
            // We need to initialize our static know directories table.
            // To be safe, we'll grab a mutex while we do the dirty deed.
            {   // constrain the scope of the mutex
                CLock lck(g_mxsCDLGetLongPathNameGlobals);

                if ( !s_kdMap.m_bInited ) {
                     TCHAR szWinDir[MAX_PATH];
                    int i;

                    GetWindowsDirectory( szWinDir, MAX_PATH );
                    for ( i = 0; i < cKnownDirs; i++ ) {
                        lstrcpy( s_kdMap.m_aKDMap[i].szCanonical, szWinDir );
                        StrCatBuff( s_kdMap.m_aKDMap[i].szCanonical, s_kdMap.m_aszCaches[i], MAX_PATH);
                        s_kdMap.m_aKDMap[i].cchCanonical = lstrlen( s_kdMap.m_aKDMap[i].szCanonical );
                        GetShortPathName( s_kdMap.m_aKDMap[i].szCanonical,
                                          s_kdMap.m_aKDMap[i].szShort, MAX_PATH );
                        s_kdMap.m_aKDMap[i].cchShort = lstrlen( s_kdMap.m_aKDMap[i].szShort );
                    }
                    s_kdMap.m_bInited = TRUE;
                }
            }

            TCHAR *pch;
            TCHAR *szT = new CHAR[MAX_PATH];

            if ( szShort != NULL && szT != NULL && s_kdMap.m_bInited ) {
                LPITEMIDLIST pidl = NULL;

                // Okay, kids, now this gets fun.
                // If we're on Memphis or NT5, we can simply call GetLongPathName
                // to get the canonical format.
                // If not, we've a bit more work ahead of us.
                // If the path is not down into one of the dowload cache folders,
                // we can use shell32 functions to create the long path. This involves
                // generating a pidl for the file, then converting the pidl back into a path.
                // If the path goes down into one of the cache directories, we're in
                // a bit of trouble, because OC cache does not implement
                // IShellFolder::ParseDisplayName, so we cannot generate a proper pidl.
                // In that case, we use prefab paths to these known directories
                // and tack on the long name of the file.
#ifdef UNICODE
                // NOTE: the prototypes in Winbase.h are deceiving - look at the argument types,
                // NOT at the argument names, the output parameter is second!
                if ( s_pfnGetLongPathNameW ) {
                    hr = (s_pfnGetLongPathNameW( szShort, szLong, MAX_PATH ) != 0)? S_OK : E_FAIL;
#else
                if ( s_pfnGetLongPathNameA ) {
                    hr = (s_pfnGetLongPathNameA( szShort, szLong, MAX_PATH ) != 0)? S_OK : E_FAIL;
#endif
                } else {
                    LPTSTR szFileName;
                    if ( GetFullPathNameA_Wrap( szShort, MAX_PATH, szT, &szFileName ) ) {
                        int iKnownDir = s_kdMap.IndexKnownDirs( szT );
                        if ( iKnownDir >= 0 ) {
                            WIN32_FIND_DATA wfd;
                            int cchBase = lstrlen(szT) - lstrlen(szFileName);
                    
                            // okay, it's in one of our caches
                            if ( !IsCanonicalName( szFileName ) ) {
                                HANDLE hfind = FindFirstFile( szShort, &wfd );
                                if ( hfind != INVALID_HANDLE_VALUE ) {
                                    szFileName = wfd.cFileName;
                                    FindClose(hfind);
                                } else
                                    szFileName = NULL;
                            }

                            if ( szFileName != NULL  ) {
                                StrNCpy( szLong, s_kdMap.m_aKDMap[iKnownDir].szCanonical, cchBuffer);
                                // chop off szT right before the file name.
                                // if this is longer than the known dir name, we have a
                                // conflict.* subdirectory and must add this before the file
                                if ( cchBase != s_kdMap.m_aKDMap[iKnownDir].cchShort &&
                                     cchBase != s_kdMap.m_aKDMap[iKnownDir].cchCanonical ) {
                                    LPTSTR szConflict;
                                    CHAR chT = szT[cchBase];
                                    szT[cchBase] = '\0';
                                    // search back from before the file name.
                                    for ( szConflict = &szT[cchBase - 2];
                                          *szConflict != '\\'; szConflict-- );
                                    szConflict++; // we already have a '\'
                                    StrCatBuff( szLong, szConflict, cchBuffer);
                                    szT[cchBase] = chT;
                                }
                                StrCatBuff( szLong, szFileName, cchBuffer);
                                hr = S_OK;
                            }

                        } else {
        #ifndef UNICODE
                            WCHAR *szwT = new WCHAR[MAX_PATH];
                            if ( szwT && 
                                 MultiByteToWideChar( CP_ACP, 0, szShort, -1, szwT, MAX_PATH ) )
                                pidl = s_pfnILCreate( szwT );
                            delete szwT;
        #else
                            pidl = s_pfnILCreate( szShort );
        #endif
                            if ( pidl != NULL ) {
                                // Now we get the shell to turn the item id list back into 
                                // a path rich in long file names, which is our canonical form
                                if ( SHGetPathFromIDList( pidl, szT ) ) {
                                    if ( szLong != NULL ) {
#ifdef UNICODE
                                        LPWSTR szLongW;
                                        hr = Ansi2Unicode( szT, &szLongW );
                                        if ( SUCCEEDED(hr) ) {
                                            StrCpyNW( szLong, szLongW, cchBuffer );
                                            delete szLongW;
                                        }
#else
                                        //BUFFER OVERRUN lstrcpyA( szLong, szT );
                                        StrCpyN( szLong, szT, cchBuffer );
                                        hr = S_OK;
#endif
                                    }
                                }
                                s_pfnILFree( pidl );
                            } // if we got the pidl
                        } // else we're getting shell32 to do the dirty-work
                    } // if we got the full path/file name
                } // else we can't use GetLongPathName

                delete szT;
            } // if we can get out temp string
        } 
        FreeLibrary( hmodS32 );
        FreeLibrary( hmodK32 );
    }

    return ((hr==S_OK)? lstrlen(szLong) : 0);
}

STDAPI_(DWORD) CDLGetLongPathNameA( LPSTR szLong, LPCSTR szShort, DWORD cchBuffer)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Dword,
                "CDLGetLongPathNameA",
                "%.80q, %.80q, %#x",
                szLong, szShort, cchBuffer
                ));
    HRESULT hr;
                
    if (!szShort || !szLong)
    {
        hr = E_FAIL;
        DEBUG_LEAVE(hr);
        return hr;
    }
#ifndef UNICODE
    hr = s_CDLGetLongPathName( szLong, szShort, cchBuffer );

    DEBUG_LEAVE(hr);
    return hr;
#else
    LPWSTR szShortW;
    TCHAR  szLongT[MAX_PATH];

    hr = Ansi2Unicode( szShort, &szShortW );
    if ( SUCCEEDED(hr) ) {
        hr = s_CDLGetLongPathName( szLongT, szShortW, MAX_PATH );
        if ( SUCCEEDED(hr) ) {
            LPSTR szLongA;
            hr = Unicode2Ansi( szLongT, &szLongA );
            if ( SUCCEEDED(hr) ) {
                lstrcpynA( szLong, szLongA, cchBuffer );
                delete szLongA;
            }
        }
        delete szShortW;
    }

    DEBUG_LEAVE(hr);
    return hr;
#endif
}

STDAPI_(DWORD) CDLGetLongPathNameW( LPWSTR szLong, LPCWSTR szShort, DWORD cchBuffer)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Dword,
                "CDLGetLongPathNameW",
                "%.80q, %.80q, %#x",
                szLong, szShort, cchBuffer
                ));
    HRESULT hr;

    if (!szShort || !szLong)
    {
        hr = E_FAIL;
        DEBUG_LEAVE(hr);
        return hr;
    }
    
#ifdef UNICODE
    hr = s_CDLGetLongPathName( szLong, szShort, cchBuffer );

    DEBUG_LEAVE(hr);
    return hr;
#else
    LPSTR szShortA;
    TCHAR  szLongT[MAX_PATH];

    hr = Unicode2Ansi( szShort, &szShortA );
    if ( SUCCEEDED(hr) ) {
        hr = s_CDLGetLongPathName( szLongT, szShortA, cchBuffer );
        if ( SUCCEEDED(hr) ) {
            LPWSTR szLongW;
            hr = Ansi2Unicode( szLongT, &szLongW );
            if ( SUCCEEDED(hr) ) {
                StrCpyNW( szLong, szLongW, cchBuffer );
                delete szLongW;
            }
        }
        delete szShortA;
    }

    DEBUG_LEAVE(hr);
    return hr;
#endif
}