#include <kstd/cstring>

#include <algorithm>
#include <bit>
#include <cstddef>
#include <iterator>
#include <span>

namespace kstd::libc
{

  auto memcpy(void * dest, void const * src, std::size_t size) noexcept -> void *
  {
    auto dest_span = std::span{static_cast<std::byte *>(dest), size};
    auto src_span = std::span{static_cast<std::byte const *>(src), size};

    for (std::size_t i = 0; i < size; ++i)
    {
      dest_span[i] = src_span[i];
    }

    return dest;
  }

  auto memset(void * dest, int value, std::size_t size) noexcept -> void *
  {
    auto const byte_value = static_cast<std::byte>(static_cast<unsigned char>(value));
    auto dest_span = std::span{static_cast<std::byte *>(dest), size};

    for (std::size_t i = 0; i < size; ++i)
    {
      dest_span[i] = byte_value;
    }

    return dest;
  }

  auto memcmp(void const * lhs, void const * rhs, std::size_t size) noexcept -> int
  {
    auto left_span = std::span{static_cast<std::byte const *>(lhs), size};
    auto right_span = std::span{static_cast<std::byte const *>(rhs), size};
    auto mismatched = std::ranges::mismatch(left_span, right_span);

    if (mismatched.in1 == left_span.end())
    {
      return 0;
    }

    return std::bit_cast<char>(*mismatched.in1) - std::bit_cast<char>(*mismatched.in2);
  }

  auto memmove(void * dest, void const * src, std::size_t size) noexcept -> void *
  {
    auto dest_span = std::span{static_cast<std::byte *>(dest), size};
    auto src_span = std::span{static_cast<std::byte const *>(src), size};
    if (dest < src)
    {
      for (std::size_t i = 0; i < size; ++i)
      {
        dest_span[i] = src_span[i];
      }
    }
    else
    {
      for (std::size_t i = size; i > 0; --i)
      {
        dest_span[i - 1] = src_span[i - 1];
      }
    }
    return dest;
  }

  auto strlen(char const * string) noexcept -> std::size_t
  {
    return std::distance(string, std::ranges::find(string, nullptr, '\0'));
  }

}  // namespace kstd::libc