/*
 * Copyright 2019 Google LLC
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#ifndef GrGpuBuffer_DEFINED
#define GrGpuBuffer_DEFINED

#include "include/private/gpu/ganesh/GrTypesPriv.h"
#include "src/gpu/ganesh/GrBuffer.h"
#include "src/gpu/ganesh/GrGpuResource.h"

#include <cstddef>
#include <string_view>

class GrGpu;

namespace skgpu {
class ScratchKey;
}

class GrGpuBuffer : public GrGpuResource, public GrBuffer {
public:
    /**
     * Computes a scratch key for a GPU-side buffer with a "dynamic" access pattern. (Buffers with
     * "static" and "stream" patterns are disqualified by nature from being cached and reused.)
     */
    static void ComputeScratchKeyForDynamicBuffer(size_t size, GrGpuBufferType, skgpu::ScratchKey*);

    GrAccessPattern accessPattern() const { return fAccessPattern; }

    size_t size() const final { return fSizeInBytes; }

    void ref() const final { GrGpuResource::ref(); }

    void unref() const final { GrGpuResource::unref(); }

    /**
     * Maps the buffer to be read or written by the CPU.
     *
     * It is an error to draw from the buffer while it is mapped or transfer to/from the buffer. It
     * may fail if the backend doesn't support mapping the buffer. Once a buffer is mapped,
     * subsequent calls to map() trivially succeed. No matter how many times map() is called,
     * umap() will unmap the buffer on the first call if it is mapped.
     *
     * If the buffer is of type GrGpuBufferType::kXferGpuToCpu then it is mapped for reading only.
     * Otherwise it is mapped writing only. Writing to a buffer that is mapped for reading or vice
     * versa produces undefined results. If the buffer is mapped for writing then the buffer's
     * previous contents are invalidated.
     *
     * @return a pointer to the data or nullptr if the map fails.
     */
    void* map();

    /**
     * Unmaps the buffer if it is mapped.
     *
     * The pointer returned by the previous map call will no longer be valid.
     */
    void unmap();

    /**
     * Queries whether the buffer has been mapped.
     *
     * @return true if the buffer is mapped, false otherwise.
     */
    bool isMapped() const;

    bool isCpuBuffer() const final { return false; }

    /**
     * Overwrites the buffer with zero bytes. Always fails for GrGpuBufferType::kXferGpuToCpu
     * buffers. The buffer must not currently be mapped.
     */
    bool clearToZero();

    /**
     * Updates the buffer data.
     *
     * The size of the buffer will be preserved. The src data will be
     * placed at offset. If preserve is false then any remaining content
     * before/after the range [offset, offset+size) becomes undefined.
     * Preserving updates will fail if the size and offset are not aligned
     * to GrCaps::bufferUpdateDataPreserveAlignment().
     *
     * The buffer must not be mapped.
     *
     * Fails for GrGpuBufferType::kXferGpuToCpu.
     *
     * Note that buffer updates do not go through GrContext and therefore are
     * not serialized with other operations.
     *
     * @return returns true if the update succeeds, false otherwise.
     */
    bool updateData(const void* src, size_t offset, size_t size, bool preserve);

    GrGpuBufferType intendedType() const { return fIntendedType; }

protected:
    GrGpuBuffer(GrGpu*,
                size_t sizeInBytes,
                GrGpuBufferType,
                GrAccessPattern,
                std::string_view label);

    enum class MapType {
        /** Maps for reading. The effect of writes is undefined. */
        kRead,
        /**
         * Maps for writing. The existing contents are discarded and the initial contents of the
         * buffer. Reads (even after overwriting initial contents) should be avoided for performance
         * reasons as the memory may not be cached.
         */
        kWriteDiscard,
    };

    void* fMapPtr;

private:
    /** Currently MapType is determined entirely by the buffer type, as documented in map(). */
    MapType mapType() const {
        return this->intendedType() == GrGpuBufferType::kXferGpuToCpu ? MapType::kRead
                                                                      : MapType::kWriteDiscard;
    }

    virtual void onMap(MapType) = 0;
    virtual void onUnmap(MapType) = 0;
    virtual bool onClearToZero() = 0;
    virtual bool onUpdateData(const void* src, size_t offset, size_t size, bool preserve) = 0;

    size_t onGpuMemorySize() const override { return fSizeInBytes; }
    void onSetLabel() override{}
    const char* getResourceType() const override { return "Buffer Object"; }
    void computeScratchKey(skgpu::ScratchKey* key) const override;

    size_t            fSizeInBytes;
    GrAccessPattern   fAccessPattern;
    GrGpuBufferType   fIntendedType;
};

#endif
