#ifndef STA_CORE_FIFO_BUFFER_TPP
#define STA_CORE_FIFO_BUFFER_TPP

#ifndef STA_CORE_FIFO_BUFFER_HPP
#  error "Internal header. Include <sta/fifo_buffer.hpp> instead"
#endif // !STA_CORE_FIFO_BUFFER_HPP

#include <cstring>


namespace sta
{
    template <typename Size, Size N>
    FifoBuffer<Size, N>::FifoBuffer()
        : head_{buffer_}, tail_{buffer_}
    {}

    template <typename Size, Size N>
    FifoBuffer<Size, N>::FifoBuffer(const uint8_t * buffer, size_type size)
    {
        set(buffer, size);
    }


    template <typename Size, Size N>
    void FifoBuffer<Size, N>::set(const uint8_t * buffer, size_type bsize)
    {
        STA_ASSERT(bsize <= sizeof(buffer_));
        STA_ASSERT(buffer != nullptr);

        head_ = buffer_;
        tail_ = buffer_ + bsize;
        memcpy(buffer_, buffer, bsize);
    }

    template <typename Size, Size N>
    void FifoBuffer<Size, N>::clear()
    {
        head_ = tail_ = buffer_;
    }


    template <typename Size, Size N>
    void FifoBuffer<Size, N>::pushBack(uint8_t value)
    {
        STA_ASSERT_MSG(tail_ < buffer_ + sizeof(buffer_), "Buffer overflow");

        *tail_++ = value;
    }

    template <typename Size, Size N>
    void FifoBuffer<Size, N>::pushBack(const uint8_t * buffer, size_type bsize)
    {
        STA_ASSERT_MSG(size() + bsize <= sizeof(buffer_), "Buffer overflow");
        STA_ASSERT(buffer != nullptr);

        memcpy(tail_, buffer, bsize);
        tail_ += bsize;
    }

    template <typename Size, Size N>
    void FifoBuffer<Size, N>::pushBack(uint8_t value, size_type count)
    {
        STA_ASSERT_MSG(size() + count <= sizeof(buffer_), "Buffer overflow");

        memset(tail_, value, count);
        tail_ += count;
    }


    template <typename Size, Size N>
    void FifoBuffer<Size, N>::popFront(uint8_t * buffer, size_type bsize)
    {
        STA_ASSERT_MSG(size() >= bsize, "Not enough data");
        STA_ASSERT(buffer != nullptr);

        memcpy(buffer, head_, bsize);
        head_ += bsize;
    }


    template <typename Size, Size N>
    typename FifoBuffer<Size, N>::size_type FifoBuffer<Size, N>::size() const
    {
        return (tail_ - head_);
    }


    template <typename Size, Size N>
    bool FifoBuffer<Size, N>::isFull() const
    {
        return (tail_ == buffer_ + sizeof(buffer_));
    }

    template <typename Size, Size N>
    bool FifoBuffer<Size, N>::isEmpty() const
    {
        return (head_ == tail_);
    }
} // namespace sta


#endif // STA_CORE_FIFO_BUFFER_TPP