#include "buffer.hpp"

#include "pci_handler.hpp"

#include <fmt/format.h>

#include <boost/endian/arithmetic.hpp>
#include <boost/endian/conversion.hpp>

#include <algorithm>
#include <array>
#include <cstddef>
#include <cstdint>
#include <memory>
#include <numeric>
#include <span>
#include <vector>

namespace bios_bmc_smm_error_logger
{

BufferImpl::BufferImpl(std::unique_ptr<DataInterface> dataInterface) :
    dataInterface(std::move(dataInterface)){};

void BufferImpl::initialize(uint32_t bmcInterfaceVersion, uint16_t queueSize,
                            uint16_t ueRegionSize,
                            const std::array<uint32_t, 4>& magicNumber)
{
    const size_t memoryRegionSize = dataInterface->getMemoryRegionSize();
    const size_t proposedBufferSize =
        sizeof(struct CircularBufferHeader) + ueRegionSize + queueSize;
    if (proposedBufferSize > memoryRegionSize)
    {
        throw std::runtime_error(fmt::format(
            "[initialize] Proposed region size '{}' is bigger than the "
            "BMC's allocated MMIO region of '{}'",
            proposedBufferSize, memoryRegionSize));
    }

    // Initialize the whole buffer with 0x00
    const std::vector<uint8_t> emptyVector(proposedBufferSize, 0);
    size_t byteWritten = dataInterface->write(0, emptyVector);
    if (byteWritten != proposedBufferSize)
    {
        throw std::runtime_error(
            fmt::format("[initialize] Only erased '{}'", byteWritten));
    }

    // Create an initial buffer header and write to it
    struct CircularBufferHeader initializationHeader = {};
    initializationHeader.bmcInterfaceVersion =
        boost::endian::native_to_little(bmcInterfaceVersion);
    initializationHeader.queueSize = boost::endian::native_to_little(queueSize);
    initializationHeader.ueRegionSize =
        boost::endian::native_to_little(ueRegionSize);
    std::transform(magicNumber.begin(), magicNumber.end(),
                   initializationHeader.magicNumber.begin(),
                   [](uint32_t number) -> little_uint32_t {
                       return boost::endian::native_to_little(number);
                   });

    uint8_t* initializationHeaderPtr =
        reinterpret_cast<uint8_t*>(&initializationHeader);
    size_t initializationHeaderSize = sizeof(initializationHeader);
    byteWritten = dataInterface->write(
        0, std::span<const uint8_t>(initializationHeaderPtr,
                                    initializationHeaderPtr +
                                        initializationHeaderSize));
    if (byteWritten != initializationHeaderSize)
    {
        throw std::runtime_error(fmt::format(
            "[initialize] Only wrote '{}' bytes of the header", byteWritten));
    }
    cachedBufferHeader = initializationHeader;
}

void BufferImpl::readBufferHeader()
{
    size_t headerSize = sizeof(struct CircularBufferHeader);
    std::vector<uint8_t> bytesRead =
        dataInterface->read(/* offset */ 0, headerSize);

    if (bytesRead.size() != headerSize)
    {
        throw std::runtime_error(
            fmt::format("Buffer header read only read '{}', expected '{}'",
                        bytesRead.size(), headerSize));
    }

    cachedBufferHeader =
        *reinterpret_cast<struct CircularBufferHeader*>(bytesRead.data());
};

struct CircularBufferHeader BufferImpl::getCachedBufferHeader() const
{
    return cachedBufferHeader;
}

void BufferImpl::updateReadPtr(const uint32_t newReadPtr)
{
    constexpr uint8_t bmcReadPtrOffset =
        offsetof(struct CircularBufferHeader, bmcReadPtr);

    little_uint16_t truncatedReadPtr =
        boost::endian::native_to_little(newReadPtr & 0xffff);
    uint8_t* truncatedReadPtrPtr =
        reinterpret_cast<uint8_t*>(&truncatedReadPtr);

    size_t writtenSize = dataInterface->write(
        bmcReadPtrOffset, std::span<const uint8_t>{
                              truncatedReadPtrPtr,
                              truncatedReadPtrPtr + sizeof(little_uint16_t)});
    if (writtenSize != sizeof(little_uint16_t))
    {
        throw std::runtime_error(fmt::format(
            "[updateReadPtr] Wrote '{}' bytes, instead of expected '{}'",
            writtenSize, sizeof(little_uint16_t)));
    }
    cachedBufferHeader.bmcReadPtr = truncatedReadPtr;
}

size_t BufferImpl::getQueueOffset()
{
    return sizeof(struct CircularBufferHeader) +
           boost::endian::little_to_native(cachedBufferHeader.ueRegionSize);
}

std::vector<uint8_t>
    BufferImpl::wraparoundRead(const uint32_t offset, const uint32_t length,
                               const uint32_t additionalBoundaryCheck)
{
    const size_t queueSize =
        boost::endian::little_to_native(cachedBufferHeader.queueSize);

    if (length + additionalBoundaryCheck > queueSize)
    {
        throw std::runtime_error(fmt::format(
            "[wraparoundRead] length '{}' + additionalBoundaryCheck '{}' "
            "was bigger than queueSize '{}'",
            length, additionalBoundaryCheck, queueSize));
    }

    // Do a first read up to the end of the buffer (dataInerface->read should
    // only read up to the end of the buffer)
    std::vector<uint8_t> bytesRead = dataInterface->read(offset, length);
    size_t updatedReadOffset = offset + bytesRead.size();
    size_t bytesRemaining = length - bytesRead.size();

    // If there are any more bytes to be read beyond the buffer, wrap around and
    // read from the beginning of the buffer (offset by the queueOffset)
    size_t queueOffset = getQueueOffset();
    if (bytesRemaining > 0)
    {
        std::vector<uint8_t> wrappedBytesRead =
            dataInterface->read(queueOffset, bytesRemaining);
        bytesRemaining -= wrappedBytesRead.size();
        if (bytesRemaining != 0)
        {
            throw std::runtime_error(fmt::format(
                "[wraparoundRead] Buffer wrapped around but was not able to read "
                "all of the requested info. Bytes remaining to read '{}' of '{}'",
                bytesRemaining, length));
        }
        bytesRead.insert(bytesRead.end(), wrappedBytesRead.begin(),
                         wrappedBytesRead.end());
        updatedReadOffset = wrappedBytesRead.size();
    }
    updateReadPtr(updatedReadOffset);

    return bytesRead;
}

struct QueueEntryHeader BufferImpl::readEntryHeader(size_t offset)
{
    size_t headerSize = sizeof(struct QueueEntryHeader);
    // wraparonudRead will throw if it did not read all the bytes, let it
    // propagate up the stack
    std::vector<uint8_t> bytesRead = wraparoundRead(offset, headerSize);

    return *reinterpret_cast<struct QueueEntryHeader*>(bytesRead.data());
}

EntryPair BufferImpl::readEntry(size_t offset)
{
    struct QueueEntryHeader entryHeader = readEntryHeader(offset);

    size_t entrySize = entryHeader.entrySize;

    // wraparonudRead may throw if entrySize was bigger than the buffer or if it
    // was not able to read all the bytes, let it propagate up the stack
    // - Use additionalBoundaryCheck parameter to add QueueEntryHeader size to
    //   boundary condition calculation
    std::vector<uint8_t> entry =
        wraparoundRead(offset + sizeof(struct QueueEntryHeader), entrySize,
                       sizeof(struct QueueEntryHeader));

    // Calculate the checksum
    uint8_t* entryHeaderPtr = reinterpret_cast<uint8_t*>(&entryHeader);
    uint8_t checksum = std::accumulate(
        entryHeaderPtr, entryHeaderPtr + sizeof(struct QueueEntryHeader), 0);
    checksum = std::accumulate(std::begin(entry), std::end(entry), checksum);
    if (checksum != 0)
    {
        throw std::runtime_error(fmt::format(
            "[readEntry] Checksum was '{}', expected '0'", checksum));
    }

    return {entryHeader, entry};
}

} // namespace bios_bmc_smm_error_logger