#ifndef _RIVE_RUNTIME_HEADER_HPP_
#define _RIVE_RUNTIME_HEADER_HPP_

#include "rive/core/binary_reader.hpp"
#include <unordered_map>

namespace rive
{

/// Rive file runtime header. The header is fonud at the beginning of every
/// Rive runtime file, and begins with a specific 4-byte format: "RIVE".
/// This is followed by the major and minor version of Rive used to create
/// the file. Finally the owner and file ids are at the end of header; these
/// unsigned integers may be zero.
static constexpr char kRuntimeHeaderFingerprint[] = "RIVE";
class RuntimeHeader
{
private:
  int m_MajorVersion;
  int m_MinorVersion;
  uint64_t m_FileId;
  std::unordered_map<int, int> m_PropertyToFieldIndex;

public:
  /// @returns the file's major version
  int majorVersion() const { return m_MajorVersion; }
  /// @returns the file's minor version
  int minorVersion() const { return m_MinorVersion; }
  /// @returns the file's id; may be zero
  uint64_t fileId() const { return m_FileId; }

  int propertyFieldId(int propertyKey) const
  {
    auto itr = m_PropertyToFieldIndex.find(propertyKey);
    if (itr == m_PropertyToFieldIndex.end())
    {
      return -1;
    }

    return itr->second;
  }

  /// Reads the header from a binary buffer/
  /// @param reader the binary reader attached to the buffer
  /// @param header a pointer to the header where the data will be stored.
  /// @returns true if the header is successfully read
  static bool read(BinaryReader& reader, RuntimeHeader& header)
  {
    for (int i = 0; i < 4; i++)
    {
      auto b = reader.readByte();
      if (kRuntimeHeaderFingerprint[i] != b)
      {
        return false;
      }
    }

    header.m_MajorVersion = reader.readVarUintAs<int>();
    if (reader.didOverflow())
    {
      return false;
    }
    header.m_MinorVersion = reader.readVarUintAs<int>();
    if (reader.didOverflow())
    {
      return false;
    }

    header.m_FileId = reader.readVarUint64();

    if (reader.didOverflow())
    {
      return false;
    }

    std::vector<int> propertyKeys;
    for (int propertyKey = reader.readVarUintAs<int>(); propertyKey != 0;
         propertyKey = reader.readVarUintAs<int>())
    {
      propertyKeys.push_back(propertyKey);
      if (reader.didOverflow())
      {
        return false;
      }
    }

    int currentInt = 0;
    int currentBit = 8;
    for (auto propertyKey : propertyKeys)
    {
      if (currentBit == 8)
      {
        currentInt = reader.readUint32();
        currentBit = 0;
      }
      int fieldIndex = (currentInt >> currentBit) & 3;
      header.m_PropertyToFieldIndex[propertyKey] = fieldIndex;
      currentBit += 2;
      if (reader.didOverflow())
      {
        return false;
      }
    }

    return true;
  }
};
} // namespace rive
#endif