#region CPL License
/*
Nuclex.NAnt.Tasks
Copyright (C) 2009 Nuclex Development Labs

This library is free software; you can redistribute it and/or
modify it under the terms of the IBM Common Public License as
published by the IBM Corporation; either version 1.0 of the
License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
IBM Common Public License for more details.

You should have received a copy of the IBM Common Public
License along with this library
*/
#endregion

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Runtime.InteropServices;
using System.ComponentModel;

namespace Nuclex.NAnt.Tasks.Helpers {

  /// <summary>Provides access to the known folders of the operating system</summary>
  internal static class KnownFolders {

    #region class Vista

    /// <summary>Helper class for working with system paths on windows</summary>
    private class Vista {

      /// <summary>Path of the program files folder</summary>
      public static string ProgramFilesPath {
        get { return getKnownFolderPath(programFiles); }
      }

      /// <summary>
      ///   Path of the 32 bit program files folder, even in a 64 bit environment
      /// </summary>
      public static string ProgramFilesPathX86 {
        get { return getKnownFolderPath(programFilesX86); }
      }

      /// <summary>
      ///   Path of the 64 bit program files folder, even in a WOW32 environment
      /// </summary>
      public static string ProgramFilesPathX64 {
        get { return getKnownFolderPath(programFilesX64); }
      }

      /// <summary>Obtains the path of a system folder on windows</summary>
      /// <param name="knownFolderId">
      ///   ID of the system folder whose path will be obtained
      /// </param>
      /// <returns>The path to the requested system folder</returns>
      private static string getKnownFolderPath(Guid knownFolderId) {
        IntPtr pathMemory;

        int result = SHGetKnownFolderPath(knownFolderId, 0, IntPtr.Zero, out pathMemory);
        if(result != 0) { // result != S_OK
          throw new System.ComponentModel.Win32Exception(
            result, "SHGetKnownFolderPath() failed unexpectedly"
          );
        }
        try {
          return Marshal.PtrToStringUni(pathMemory);
        }
        finally {
          Marshal.FreeCoTaskMem(pathMemory);
        }
      }

      /// <summary>
      ///   "Program Files" folder, depending on the running application's bitness
      /// </summary>
      private static readonly Guid programFiles = new Guid(
        "905e63b6-c1bf-494e-b29c-65b732d3d21a"
      );

      /// <summary>
      ///   "Program Files" folder on x64 systems, undefined on x86 systems
      /// </summary>
      private static readonly Guid programFilesX64 = new Guid(
        "6d809377-6af0-444b-8957-a3773f02200e"
      );

      /// <summary>
      ///   "Program Files (x86)" folder on x64 systems and "Program Files" folder
      ///   on x86 systems.
      /// </summary>
      private static readonly Guid programFilesX86 = new Guid(
        "7c5a40ef-a0fb-4bfc-874a-c0f2e0b9fa8e"
      );

      /// <summary>
      ///   Retrieves the full path of a known folder identified by the folder's KNOWNFOLDERID
      /// </summary>
      /// <param name="folderId">KNOWNFOLDERID that identifies the folder</param>
      /// <param name="flags">
      ///   Retrieval options. This value can be 0; otherwise, one or more of
      ///   the KNOWN_FOLDER_FLAG values
      /// </param>
      /// <param name="token">
      ///   An access token that represents a particular user. If this parameter is NULL,
      ///   which is the most common usage, the function requests the known folder for
      ///   the current user
      /// </param>
      /// <param name="path">
      ///   When this method returns, contains the address of a pointer to a null-terminated
      ///   Unicode string that specifies the path of the known folder. The calling process
      ///   is responsible for freeing this resource once it is no longer needed by
      ///   calling CoTaskMemFree()
      /// </param>
      /// <returns>Returns S_OK if successful, or an error value otherwise</returns>
      [DllImport("shell32.dll", SetLastError = true, CallingConvention = CallingConvention.Winapi)]
      private static extern int SHGetKnownFolderPath(
        [MarshalAs(UnmanagedType.LPStruct)] Guid folderId,
        uint flags,
        IntPtr token,
        out IntPtr path
      );

    }

    #endregion // class Vista

    /// <summary>Initializes the KnownFolders class</summary>
    static KnownFolders() {
      if(OsHelper.IsWindows) {
        ProgramFilesPath = findProgramFilesPath();
        ProgramFiles32Path = findProgramFiles32Path();
        if(EnvironmentHelper.RunningOn64BitOS) {
          ProgramFiles64Path = findProgramFiles64Path();
        }
      }
    }

    /// <summary>Finds the path to the program files folder</summary>
    private static string findProgramFilesPath() {
      Debug.Assert(OsHelper.IsWindows);

      return Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles);
    }

    /// <summary>Finds the path of the 64 bit program files folder</summary>
    private static string findProgramFiles64Path() {
      Debug.Assert(OsHelper.IsWindows);
      Debug.Assert(EnvironmentHelper.RunningOn64BitOS);

      // If on Vista or later, try to query directly from the operating system
      string programFilesPath;
      if(OsHelper.IsVistaOrLater) {
        try {
          programFilesPath = Vista.ProgramFilesPathX64;

          if(isPathValid(programFilesPath)) {
            return programFilesPath;
          }
        }
        catch(Win32Exception) { }
      }

      // Next, try the environment variable
      programFilesPath = Environment.GetEnvironmentVariable("ProgramW6432");

      if(isPathValid(programFilesPath)) {
        return programFilesPath;
      }

      // All failed, we give up
      throw new Exception("Could not determine path to 64 bit program files folder");
    }

    /// <summary>Finds the path of the 32 bit program files folder</summary>
    private static string findProgramFiles32Path() {
      Debug.Assert(OsHelper.IsWindows);

      // If we're on a 32 bit os, the program files folder can be queried normally
      if(!EnvironmentHelper.RunningOn64BitOS) {
        return findProgramFilesPath();
      }

      // If on Vista or later, try to query directly from the operating system
      string programFilesPath;
      if(OsHelper.IsVistaOrLater) {
        programFilesPath = Vista.ProgramFilesPathX86;

        if(isPathValid(programFilesPath)) {
          return programFilesPath;
        }
      }

      // Next, try the environment variable
      programFilesPath = Environment.GetEnvironmentVariable("ProgramFiles(x86)");

      if(isPathValid(programFilesPath)) {
        return programFilesPath;
      }

      // All failed, we give up
      throw new Exception("Could not determine path to 32 bit program files folder");
    }

    /// <summary>Checks whether the provided path is valid</summary>
    /// <param name="path">Path that will be checked</param>
    /// <returns>True if the provided path is valid</returns>
    private static bool isPathValid(string path) {
      return
        (path != null) &&
        (path != string.Empty) &&
        Directory.Exists(path);
    }

    /// <summary>
    ///   Path to the program files folder, depending on the architecture of
    ///   the operating system
    /// </summary>
    public static readonly string ProgramFilesPath;
    /// <summary>Path to the 32 bit program files folder</summary>
    public static readonly string ProgramFiles32Path;
    /// <summary>Path to the 64 bit program files folder</summary>
    public static readonly string ProgramFiles64Path;

  }


} // namespace Nuclex.NAnt.Tasks.Helpers