#include "fiko/cekirdek/makine_kimlik.hpp"

#include "fiko/cekirdek/kripto.hpp"

#if defined(_WIN32)
#include <windows.h>
//
#include <intrin.h>
#endif

namespace fiko {
namespace {

// Alanı tuzla + sha256 → 32 haneli hex (ham donanım verisi asla dışarı çıkmaz).
// Tuz alan adını içerir → aynı değer iki alanda aynı hash'i vermez.
std::string ozetle(const char* alan, const std::string& ham) {
  if (ham.empty()) return "";
  const std::string tuzlu = std::string("fiko.makine.v1|") + alan + "|" + ham;
  u8 d[32];
  if (!kripto::sha256(tuzlu.data(), tuzlu.size(), d)) return "";
  return kripto::baytHex(d, 32).substr(0, 32);
}

#if defined(_WIN32)

std::string registryOku(HKEY kok, const wchar_t* yol, const wchar_t* ad) {
  wchar_t tampon[512];
  DWORD n = sizeof(tampon);
  // 64-bit görünüm: WOW64 yönlendirmesi olmadan gerçek anahtarı oku.
  if (RegGetValueW(kok, yol, ad, RRF_RT_REG_SZ | RRF_SUBKEY_WOW6464KEY, nullptr, tampon, &n) !=
      ERROR_SUCCESS) {
    return "";
  }
  std::string s;
  for (const wchar_t* p = tampon; *p; ++p) s.push_back((char)(*p & 0x7F));
  return s;
}

std::string kurulumHam() {
  return registryOku(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Cryptography", L"MachineGuid");
}

std::string diskHam() {
  wchar_t sistemYolu[MAX_PATH];
  if (!GetSystemWindowsDirectoryW(sistemYolu, MAX_PATH)) return "";
  const std::wstring kok = std::wstring(sistemYolu).substr(0, 3);  // "C:\"
  DWORD seri = 0;
  if (!GetVolumeInformationW(kok.c_str(), nullptr, 0, &seri, nullptr, nullptr, nullptr, 0)) {
    return "";
  }
  return seri ? std::to_string(seri) : "";
}

std::string cpuHam() {
  int reg[4] = {0, 0, 0, 0};
  __cpuid(reg, 0x80000000);
  if ((unsigned)reg[0] < 0x80000004u) return "";
  char marka[49] = {};
  for (unsigned i = 0; i < 3; ++i) {
    __cpuid(reg, 0x80000002 + i);
    __movsb((unsigned char*)(marka + i * 16), (const unsigned char*)reg, 16);
  }
  SYSTEM_INFO si{};
  GetNativeSystemInfo(&si);
  return std::string(marka) + "|" + std::to_string(si.dwNumberOfProcessors);
}

std::string biosHam() {
  const wchar_t* yol = L"HARDWARE\\DESCRIPTION\\System\\BIOS";
  const std::string uretici = registryOku(HKEY_LOCAL_MACHINE, yol, L"SystemManufacturer");
  const std::string urun = registryOku(HKEY_LOCAL_MACHINE, yol, L"SystemProductName");
  const std::string anakart = registryOku(HKEY_LOCAL_MACHINE, yol, L"BaseBoardProduct");
  const std::string birlesik = uretici + "|" + urun + "|" + anakart;
  return birlesik == "||" ? "" : birlesik;
}

#else  // Windows dışı: parmak izi yok → node-lock kurulamaz (lisans üretiminde uyarılır).
std::string kurulumHam() { return ""; }
std::string diskHam() { return ""; }
std::string cpuHam() { return ""; }
std::string biosHam() { return ""; }
#endif

}  // namespace

std::vector<std::string> MakineParmakIzi::hashListesi() const {
  std::vector<std::string> l;
  for (const std::string* s : {&kurulum, &disk, &cpu, &bios})
    if (!s->empty()) l.push_back(*s);
  return l;
}

int MakineParmakIzi::alanSayisi() const { return (int)hashListesi().size(); }

const std::string& uygulamaYapiHash() {
  static const std::string h = [] {
#if defined(_WIN32)
    wchar_t yol[MAX_PATH];
    if (!GetModuleFileNameW(nullptr, yol, MAX_PATH)) return std::string();
    std::string dar;
    for (const wchar_t* p = yol; *p; ++p) dar.push_back((char)*p);  // ASCII yollar
    u8 d[32];
    if (!kripto::sha256Dosya(dar, d)) return std::string();
    return kripto::baytHex(d, 32).substr(0, 32);
#else
    return std::string();
#endif
  }();
  return h;
}

const MakineParmakIzi& makineParmakIzi() {
  static const MakineParmakIzi p = [] {
    MakineParmakIzi m;
    m.kurulum = ozetle("kurulum", kurulumHam());
    m.disk = ozetle("disk", diskHam());
    m.cpu = ozetle("cpu", cpuHam());
    m.bios = ozetle("bios", biosHam());
    return m;
  }();
  return p;
}

std::string cihazKimlikUret() {
  const std::vector<std::string> h = makineParmakIzi().hashListesi();
  if (h.empty()) return "";
  std::string birlesik = "fiko.cihaz.v1";
  for (const std::string& s : h) { birlesik += '|'; birlesik += s; }
  u8 d[32];
  if (!kripto::sha256(birlesik.data(), birlesik.size(), d)) return "";
  return kripto::baytHex(d, 32).substr(0, 24);
}

}  // namespace fiko