#import "kernel32.kl"
#import "base.kl"

PAGE_SIZE :: 4096
Memory :: struct
  commit : SizeU
  reserve: SizeU
  data   : *U8

ProcessHeap: HANDLE
Allocate :: (size: U64): *void
  if ProcessHeap == 0
    ProcessHeap = GetProcessHeap()
  return HeapAlloc(ProcessHeap, 0, size)

Reserve :: (size: SizeU): Memory
  result := Memory{reserve=AlignUp(size, PAGE_SIZE)}
  result.data = VirtualAlloc(
    flProtect        = PAGE_READWRITE,
    dwSize           = result.reserve,
    flAllocationType = MEM_RESERVE,
    lpAddress        = 0)->*U8
  return result

Commit :: (m: *Memory, size: SizeU): Bool
  commit_size := AlignUp(size, PAGE_SIZE)
  total_commit := m.commit + commit_size
  clamped_commit := ClampTopSizeU(total_commit, m.reserve)
  adjusted_commit := clamped_commit - m.commit
  if adjusted_commit != 0
    result := VirtualAlloc(
      lpAddress        = (m.data + m.commit)->*void,
      dwSize           = adjusted_commit,
      flAllocationType = MEM_COMMIT,
      flProtect        = PAGE_READWRITE,
    )
    m.commit += adjusted_commit
    return true
  return false

Release :: (m: *Memory)
  result := VirtualFree(m.data->*void, 0, MEM_RELEASE)
  if result != 0
    m.data    = 0
    m.commit  = 0
    m.reserve = 0

WriteConsole :: (string: String16)
  handle := GetStdHandle(STD_OUTPUT_HANDLE)
  WriteConsoleW(handle, string.str->*void, string.len->DWORD, 0, 0)

PerformanceFrequency: F64
Time :: (): F64
  query: LARGE_INTEGER
  if !PerformanceFrequency
    err := QueryPerformanceFrequency(&query)
    Assert(err != 0)
    PerformanceFrequency = query->F64

  err := QueryPerformanceCounter(&query)
  Assert(err != 0)
  result := query->F64 / PerformanceFrequency
  return result

/**
 * C++ version 0.4 char* style "itoa":
 * Written by Lukás Chmela
 * Released under GPLv3.
 */
Itoa :: (value: S64, result: *U8, base: S64): *U8
    // check that the base if valid
    if (base < 2) || (base > 36)
      *result = 0 // '
      return result

    ptr := result
    ptr1 := result
    tmp_char: U8
    tmp_value: S64

    for value != 0
      tmp_value = value
      value /= base
      *ptr++ = "zyxwvutsrqponmlkjihgfedcba9876543210123456789abcdefghijklmnopqrstuvwxyz" [35 + (tmp_value - value * base)]

    // Apply negative sign
    if tmp_value < 0
      *ptr++ = '-'
    *ptr-- = 0
    for ptr1 < ptr
      tmp_char = *ptr
      *ptr-- = *ptr1
      *ptr1++ = tmp_char
    return result


Print :: (string: String, args: ..)
  buffer: [1024]U8
  buffer_len: S64

  arg_counter := 0
  for i := 0, i < Length(string), i+=1
    if string[i] == '%'
      Assert(arg_counter < Length(args), "Passing too many [%] to a print lambda")
      arg := args[arg_counter++]

      if arg.type == S64
        value := *(arg.data->*S64)
        itoa_buff: [64]U8
        p := itoa(value, &itoa_buff[0], 10)
        for *p != 0
          buffer[buffer_len++] = *p++
      else;; Assert(false)
    else
      buffer[buffer_len++] = string[i]