#ifdef _WIN32

// clang-format off
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <wincrypt.h>
#include <dwmapi.h>
#include <tlhelp32.h>

#include <ranges>
#include <winrt/Windows.Foundation.Collections.h>
#include <winrt/Windows.Media.Control.h>
#include <winrt/Windows.Storage.h>
#include <winrt/Windows.System.Profile.h>
#include <winrt/Windows.Management.Deployment.h>
#include <winrt/base.h>
#include <winrt/impl/Windows.Media.Control.2.h>

#include "src/core/util/error.hpp"
#include "src/core/util/helpers.hpp"
#include "src/core/util/logging.hpp"
#include "src/core/util/types.hpp"

#include "os.hpp"
// clang-format on

using RtlGetVersionPtr = NTSTATUS(WINAPI*)(PRTL_OSVERSIONINFOW);

namespace {
  using util::error::DraconisError, util::error::DraconisErrorCode;
  using namespace util::types;

  struct ProcessData {
    DWORD  parentPid = 0;
    String baseExeNameLower;
  };

  // clang-format off
  constexpr Array<Pair<StringView, StringView>, 3> windowsShellMap = {{
    {        "cmd",  "Command Prompt" },
    { "powershell",      "PowerShell" },
    {       "pwsh", "PowerShell Core" },
  }};

  constexpr Array<Pair<StringView, StringView>, 3> msysShellMap = {{
    { "bash", "Bash" },
    {  "zsh",  "Zsh" },
    { "fish", "Fish" },
  }};
  // clang-format on

  fn GetRegistryValue(const HKEY& hKey, const String& subKey, const String& valueName) -> String {
    HKEY key = nullptr;
    if (RegOpenKeyExA(hKey, subKey.c_str(), 0, KEY_READ, &key) != ERROR_SUCCESS)
      return "";

    DWORD dataSize = 0;
    DWORD type     = 0;
    if (RegQueryValueExA(key, valueName.c_str(), nullptr, &type, nullptr, &dataSize) != ERROR_SUCCESS) {
      RegCloseKey(key);
      return "";
    }

    String value((type == REG_SZ || type == REG_EXPAND_SZ) ? dataSize - 1 : dataSize, '\0');

    if (RegQueryValueExA(key, valueName.c_str(), nullptr, nullptr, reinterpret_cast<LPBYTE>(value.data()), &dataSize) !=
        ERROR_SUCCESS) {
      RegCloseKey(key);
      return "";
    }

    RegCloseKey(key);
    return value;
  }

  template <usize sz>
  fn FindShellInProcessTree(const DWORD startPid, const Array<Pair<StringView, StringView>, sz>& shellMap)
    -> Option<String> {
    if (startPid == 0)
      return None;

    std::unordered_map<DWORD, ProcessData> processMap;

    const HANDLE hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

    if (hSnap == INVALID_HANDLE_VALUE) {
      error_log("FindShellInProcessTree: Failed snapshot, error {}", GetLastError());
      return None;
    }

    PROCESSENTRY32 pe32;
    pe32.dwSize = sizeof(PROCESSENTRY32);

    if (Process32First(hSnap, &pe32)) {
      do {
        String fullName = pe32.szExeFile;
        String baseName;

        const size_t lastSlash = fullName.find_last_of("\\/");

        baseName = (lastSlash == String::npos) ? fullName : fullName.substr(lastSlash + 1);

        std::transform(baseName.begin(), baseName.end(), baseName.begin(), [](const u8 character) {
          return std::tolower(character);
        });

        if (baseName.length() > 4 && baseName.ends_with(".exe"))
          baseName.resize(baseName.length() - 4);

        processMap[pe32.th32ProcessID] = ProcessData { pe32.th32ParentProcessID, std::move(baseName) };
      } while (Process32Next(hSnap, &pe32));
    } else {
      error_log("FindShellInProcessTree: Process32First failed, error {}", GetLastError());
    }

    CloseHandle(hSnap);

    DWORD currentPid = startPid;

    i32 depth = 0;

    constexpr int maxDepth = 32;

    while (currentPid != 0 && depth < maxDepth) {
      auto procIt = processMap.find(currentPid);

      if (procIt == processMap.end())
        break;

      const String& processName = procIt->second.baseExeNameLower;

      auto mapIter =
        std::ranges::find_if(shellMap, [&](const auto& pair) { return StringView { processName } == pair.first; });

      if (mapIter != std::ranges::end(shellMap))
        return String { mapIter->second };

      currentPid = procIt->second.parentPid;

      depth++;
    }

    if (depth >= maxDepth)
      error_log("FindShellInProcessTree: Reached max depth limit ({}) walking parent PIDs from {}", maxDepth, startPid);

    return None;
  }

  fn GetBuildNumber() -> Option<u64> {
    try {
      using namespace winrt::Windows::System::Profile;
      const auto           versionInfo   = AnalyticsInfo::VersionInfo();
      const winrt::hstring familyVersion = versionInfo.DeviceFamilyVersion();

      if (!familyVersion.empty()) {
        const u64 versionUl = std::stoull(winrt::to_string(familyVersion));
        return (versionUl >> 16) & 0xFFFF;
      }
    } catch (const winrt::hresult_error& e) {
      debug_log("WinRT error getting build number: {}", winrt::to_string(e.message()));
    } catch (const Exception& e) { debug_log("Standard exception getting build number: {}", e.what()); }

    return None;
  }
} // namespace

namespace os {
  fn GetMemInfo() -> Result<u64, DraconisError> {
    MEMORYSTATUSEX memInfo;
    memInfo.dwLength = sizeof(MEMORYSTATUSEX);

    if (GlobalMemoryStatusEx(&memInfo))
      return memInfo.ullTotalPhys;

    DWORD lastError = GetLastError();
    return Err(DraconisError(
      DraconisErrorCode::PlatformSpecific, std::format("GlobalMemoryStatusEx failed with error code {}", lastError)
    ));
  }

  fn GetNowPlaying() -> Result<MediaInfo, DraconisError> {
    using namespace winrt::Windows::Media::Control;
    using namespace winrt::Windows::Foundation;

    using Session         = GlobalSystemMediaTransportControlsSession;
    using SessionManager  = GlobalSystemMediaTransportControlsSessionManager;
    using MediaProperties = GlobalSystemMediaTransportControlsSessionMediaProperties;

    try {
      const IAsyncOperation<SessionManager> sessionManagerOp = SessionManager::RequestAsync();
      const SessionManager                  sessionManager   = sessionManagerOp.get();

      if (const Session currentSession = sessionManager.GetCurrentSession()) {
        const MediaProperties mediaProperties = currentSession.TryGetMediaPropertiesAsync().get();

        return MediaInfo(
          winrt::to_string(mediaProperties.Title()), winrt::to_string(mediaProperties.Artist()), None, None
        );
      }

      return Err(DraconisError(DraconisErrorCode::NotFound, "No media session found"));
    } catch (const winrt::hresult_error& e) { return Err(DraconisError(e)); }
  }

  fn GetOSVersion() -> Result<String, DraconisError> {
    try {
      const String regSubKey = R"(SOFTWARE\Microsoft\Windows NT\CurrentVersion)";

      String       productName    = GetRegistryValue(HKEY_LOCAL_MACHINE, regSubKey, "ProductName");
      const String displayVersion = GetRegistryValue(HKEY_LOCAL_MACHINE, regSubKey, "DisplayVersion");

      if (productName.empty())
        return Err(DraconisError(DraconisErrorCode::NotFound, "ProductName not found in registry"));

      if (const Option<u64> buildNumberOpt = GetBuildNumber()) {
        if (const u64 buildNumber = *buildNumberOpt; buildNumber >= 22000) {
          if (const size_t pos = productName.find("Windows 10"); pos != String::npos) {
            const bool startBoundary = (pos == 0 || !isalnum(static_cast<unsigned char>(productName[pos - 1])));
            const bool endBoundary =
              (pos + 10 == productName.length() || !isalnum(static_cast<unsigned char>(productName[pos + 10])));

            if (startBoundary && endBoundary) {
              productName.replace(pos, 10, "Windows 11");
            }
          }
        }
      } else {
        debug_log("Warning: Could not get build number via WinRT; Win11 detection might be inaccurate.");
      }

      return displayVersion.empty() ? productName : productName + " " + displayVersion;
    } catch (const std::exception& e) { return Err(DraconisError(e)); }
  }

  fn GetHost() -> Result<String, DraconisError> {
    return GetRegistryValue(HKEY_LOCAL_MACHINE, R"(SYSTEM\HardwareConfig\Current)", "SystemFamily");
  }

  fn GetKernelVersion() -> Result<String, DraconisError> {
    if (const HMODULE ntdllHandle = GetModuleHandleW(L"ntdll.dll")) {
      if (const auto rtlGetVersion = std::bit_cast<RtlGetVersionPtr>(GetProcAddress(ntdllHandle, "RtlGetVersion"))) {
        RTL_OSVERSIONINFOW osInfo  = {};
        osInfo.dwOSVersionInfoSize = sizeof(osInfo);

        if (rtlGetVersion(&osInfo) == 0)
          return std::format(
            "{}.{}.{}.{}", osInfo.dwMajorVersion, osInfo.dwMinorVersion, osInfo.dwBuildNumber, osInfo.dwPlatformId
          );
      }
    }

    return Err(DraconisError(DraconisErrorCode::NotFound, "Could not determine kernel version using RtlGetVersion"));
  }

  fn GetWindowManager() -> Option<String> {
    BOOL compositionEnabled = FALSE;
    if (SUCCEEDED(DwmIsCompositionEnabled(&compositionEnabled))) {
      return compositionEnabled ? "DWM" : "Windows Manager (Basic)";
    }

    error_log("GetWindowManager: DwmIsCompositionEnabled failed");

    return None;
  }

  fn GetDesktopEnvironment() -> Option<String> {
    const String buildStr =
      GetRegistryValue(HKEY_LOCAL_MACHINE, R"(SOFTWARE\Microsoft\Windows NT\CurrentVersion)", "CurrentBuildNumber");

    if (buildStr.empty()) {
      debug_log("Failed to get CurrentBuildNumber from registry");
      return None;
    }

    try {
      const i32 build = stoi(buildStr);

      // Windows 11+ (Fluent)
      if (build >= 22000)
        return "Fluent (Windows 11)";

      // Windows 10 Fluent Era
      if (build >= 15063)
        return "Fluent (Windows 10)";

      // Windows 8.1/10 Metro Era
      if (build >= 9200) { // Windows 8+
        // Distinguish between Windows 8 and 10
        const String productName =
          GetRegistryValue(HKEY_LOCAL_MACHINE, R"(SOFTWARE\Microsoft\Windows NT\CurrentVersion)", "ProductName");

        if (productName.find("Windows 10") != String::npos)
          return "Metro (Windows 10)";

        if (build >= 9600)
          return "Metro (Windows 8.1)";

        return "Metro (Windows 8)";
      }

      // Windows 7 Aero
      if (build >= 7600)
        return "Aero (Windows 7)";

      // Pre-Win7
      return "Classic";
    } catch (...) {
      debug_log("Failed to parse CurrentBuildNumber");
      return None;
    }
  }

  fn GetShell() -> Option<String> {
    using util::helpers::GetEnv;

    if (const Result<String, DraconisError> msystemResult = GetEnv("MSYSTEM");
        msystemResult && !msystemResult->empty()) {
      String shellPath;

      if (const Result<String, DraconisError> shellResult = GetEnv("SHELL"); shellResult && !shellResult->empty()) {
        shellPath = *shellResult;
      } else if (const Result<String, DraconisError> loginShellResult = GetEnv("LOGINSHELL");
                 loginShellResult && !loginShellResult->empty()) {
        shellPath = *loginShellResult;
      }

      if (!shellPath.empty()) {
        const usize lastSlash = shellPath.find_last_of("\\/");
        String      shellExe  = (lastSlash != String::npos) ? shellPath.substr(lastSlash + 1) : shellPath;
        std::ranges::transform(shellExe, shellExe.begin(), [](const u8 character) { return std::tolower(character); });
        if (shellExe.ends_with(".exe"))
          shellExe.resize(shellExe.length() - 4);

        const auto iter =
          std::ranges::find_if(msysShellMap, [&](const auto& pair) { return StringView { shellExe } == pair.first; });
        if (iter != std::ranges::end(msysShellMap))
          return String { iter->second };
      }

      const DWORD currentPid = GetCurrentProcessId();
      if (const Option<String> msysShell = FindShellInProcessTree(currentPid, msysShellMap))
        return msysShell;

      return "MSYS2 Environment";
    }

    const DWORD currentPid = GetCurrentProcessId();
    if (const Option<String> windowsShell = FindShellInProcessTree(currentPid, windowsShellMap))
      return windowsShell;

    return None;
  }

  fn GetDiskUsage() -> Result<DiskSpace, DraconisError> {
    ULARGE_INTEGER freeBytes, totalBytes;

    if (GetDiskFreeSpaceExW(L"C:\\", nullptr, &totalBytes, &freeBytes))
      return DiskSpace { .used_bytes = totalBytes.QuadPart - freeBytes.QuadPart, .total_bytes = totalBytes.QuadPart };

    return Err(DraconisError(util::error::DraconisErrorCode::NotFound, "Failed to get disk usage"));
  }

  fn GetPackageCount() -> Result<u64, DraconisError> {
    try {
      return std::ranges::distance(winrt::Windows::Management::Deployment::PackageManager().FindPackagesForUser(L""));
    } catch (const winrt::hresult_error& e) { return Err(DraconisError(e)); }
  }
} // namespace os

#endif