#include "fiko/istakip/model.hpp"

namespace fiko::istakip {

using namespace fiko::surecproto;

const char* alanBul(const IsKayit& k, const std::string& ad) {
  for (const auto& [a, d] : k.alanlar)
    if (a == ad) return d.c_str();
  return nullptr;
}

void alanAta(IsKayit& k, const std::string& ad, const std::string& deger) {
  for (auto& [a, d] : k.alanlar)
    if (a == ad) { d = deger; return; }
  k.alanlar.emplace_back(ad, deger);
}

std::array<uint8_t, 32> kimlikKanitTuret(const std::array<uint8_t, 32>& anahtar,
                                         const std::array<uint8_t, 16>& nonce,
                                         uint64_t istemciNo) {
  std::array<uint8_t, 32> kanit{};
  for (size_t blok = 0; blok < 4; ++blok) {  // 4×8B = 32B genişletme (blok tuzlu FNV)
    uint64_t h = 1469598103934665603ull ^ (0x9E3779B97F4A7C15ull * (blok + 1));
    const auto kar = [&h](uint8_t b) {
      h ^= b;
      h *= 1099511628211ull;
    };
    for (uint8_t b : anahtar) kar(b);
    for (uint8_t b : nonce) kar(b);
    for (int i = 0; i < 8; ++i) kar((uint8_t)(istemciNo >> (8 * i)));
    for (int tur = 0; tur < 3; ++tur) {  // ek turlar: bit yayılımı
      h ^= h >> 33;
      h *= 0xFF51AFD7ED558CCDull;
      h ^= h >> 29;
    }
    for (int i = 0; i < 8; ++i) kanit[blok * 8 + (size_t)i] = (uint8_t)(h >> (8 * i));
  }
  return kanit;
}

namespace istakipproto {

std::string kayitSerialize(const IsKayit& k) {
  std::string s;
  yazU64(s, k.kimlik);
  yazStr(s, k.tur);
  yazU64(s, k.surum);
  s.push_back(k.silindi ? (char)1 : (char)0);
  const uint16_t n = (uint16_t)(k.alanlar.size() > 0xFFFF ? 0xFFFF : k.alanlar.size());
  yazU16(s, n);
  for (uint16_t i = 0; i < n; ++i) {
    yazStr(s, k.alanlar[i].first);
    yazStr(s, k.alanlar[i].second);
  }
  return s;
}

bool kayitCoz(const char*& p, const char* son, IsKayit& out) {
  if (son - p < 8) return false;
  out.kimlik = okuU64(p); p += 8;
  if (!okuStr(p, son, out.tur)) return false;
  if (son - p < 9) return false;
  out.surum = okuU64(p); p += 8;
  out.silindi = *p != 0; p += 1;
  const uint16_t adet = okuU16(p); p += 2;
  out.alanlar.clear();
  for (uint16_t i = 0; i < adet; ++i) {
    std::string a, d;
    if (!okuStr(p, son, a) || !okuStr(p, son, d)) return false;
    out.alanlar.emplace_back(std::move(a), std::move(d));
  }
  return true;
}

std::string yazSerialize(uint64_t istemciNo, uint64_t sira, uint64_t beklenenSurum,
                         const IsKayit& taslak) {
  std::string s;
  yazU64(s, istemciNo);
  yazU64(s, sira);
  yazU64(s, beklenenSurum);
  s += kayitSerialize(taslak);
  return s;
}

bool yazCoz(const std::string& govde, uint64_t& istemciNo, uint64_t& sira,
            uint64_t& beklenenSurum, IsKayit& taslak) {
  const char* p = govde.data();
  const char* son = p + govde.size();
  if (son - p < 24) return false;
  istemciNo = okuU64(p); p += 8;
  sira = okuU64(p); p += 8;
  beklenenSurum = okuU64(p); p += 8;
  return kayitCoz(p, son, taslak);
}

std::string snapshotIsteSerialize(uint64_t sonSurum, uint64_t istemciNo) {
  std::string s;
  yazU64(s, sonSurum);
  yazU64(s, istemciNo);
  return s;
}

bool snapshotIsteCoz(const std::string& govde, uint64_t& sonSurum, uint64_t& istemciNo) {
  if (govde.size() < 16) return false;
  sonSurum = okuU64(govde.data());
  istemciNo = okuU64(govde.data() + 8);
  return true;
}

std::string snapshotSerialize(const std::vector<IsKayit>& kayitlar, uint64_t yeniSurum,
                              uint64_t islenenSira, bool devamVar) {
  std::string s;
  yazU64(s, yeniSurum);
  yazU64(s, islenenSira);
  s.push_back(devamVar ? (char)1 : (char)0);
  yazU32(s, (uint32_t)kayitlar.size());
  for (const auto& k : kayitlar) s += kayitSerialize(k);
  return s;
}

bool snapshotCoz(const std::string& govde, std::vector<IsKayit>& kayitlar,
                 uint64_t& yeniSurum, uint64_t& islenenSira, bool& devamVar) {
  const char* p = govde.data();
  const char* son = p + govde.size();
  if (son - p < 21) return false;
  yeniSurum = okuU64(p); p += 8;
  islenenSira = okuU64(p); p += 8;
  devamVar = *p != 0; p += 1;
  const uint32_t adet = okuU32(p); p += 4;
  kayitlar.clear();
  for (uint32_t i = 0; i < adet; ++i) {
    IsKayit k;
    if (!kayitCoz(p, son, k)) return false;
    kayitlar.push_back(std::move(k));
  }
  return true;
}

std::string deltaSerialize(const IsKayit& k, uint64_t yazarNo, uint64_t yazarSira) {
  std::string s;
  yazU64(s, yazarNo);
  yazU64(s, yazarSira);
  s += kayitSerialize(k);
  return s;
}

bool deltaCoz(const std::string& govde, IsKayit& k, uint64_t& yazarNo, uint64_t& yazarSira) {
  const char* p = govde.data();
  const char* son = p + govde.size();
  if (son - p < 16) return false;
  yazarNo = okuU64(p); p += 8;
  yazarSira = okuU64(p); p += 8;
  return kayitCoz(p, son, k);
}

}  // namespace istakipproto
}  // namespace fiko::istakip