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

#ifndef GrCCAtlas_DEFINED
#define GrCCAtlas_DEFINED

#include "src/gpu/GrDynamicAtlas.h"
#include "src/gpu/GrTBlockList.h"
#include "src/gpu/ccpr/GrCCPathProcessor.h"

class GrCCCachedAtlas;

/**
 * GrDynamicAtlas with CCPR caching capabilities.
 */
class GrCCAtlas : public GrDynamicAtlas {
public:
    // This struct encapsulates the minimum and desired requirements for an atlas, as well as an
    // approximate number of pixels to help select a good initial size.
    struct Specs {
        int fMaxPreferredTextureSize = 0;
        int fMinTextureSize = 0;
        int fMinWidth = 0;  // If there are 100 20x10 paths, this should be 20.
        int fMinHeight = 0;  // If there are 100 20x10 paths, this should be 10.
        int fApproxNumPixels = 0;

        // Add space for a rect in the desired atlas specs.
        void accountForSpace(int width, int height);
    };

    enum class CoverageType {
        kFP16_CoverageCount,
        kA8_Multisample,
        kA8_LiteralCoverage
    };

    static constexpr GrColorType CoverageTypeToColorType(CoverageType coverageType) {
        switch (coverageType) {
            case CoverageType::kFP16_CoverageCount:
                return GrColorType::kAlpha_F16;
            case CoverageType::kA8_Multisample:
            case CoverageType::kA8_LiteralCoverage:
                return GrColorType::kAlpha_8;
        }
        SkUNREACHABLE;
    }

    static constexpr InternalMultisample CoverageTypeHasInternalMultisample(
            CoverageType coverageType) {
        switch (coverageType) {
            case CoverageType::kFP16_CoverageCount:
            case CoverageType::kA8_LiteralCoverage:
                return InternalMultisample::kNo;
            case CoverageType::kA8_Multisample:
                return InternalMultisample::kYes;
        }
        SkUNREACHABLE;
    }

    static constexpr GrCCPathProcessor::CoverageMode CoverageTypeToPathCoverageMode(
            CoverageType coverageType) {
        return (GrCCAtlas::CoverageType::kFP16_CoverageCount == coverageType)
                ? GrCCPathProcessor::CoverageMode::kCoverageCount
                : GrCCPathProcessor::CoverageMode::kLiteral;
    }

    static sk_sp<GrTextureProxy> MakeLazyAtlasProxy(LazyInstantiateAtlasCallback&& callback,
                                                    CoverageType coverageType,
                                                    const GrCaps& caps,
                                                    GrSurfaceProxy::UseAllocator useAllocator) {
        return GrDynamicAtlas::MakeLazyAtlasProxy(std::move(callback),
                                                  CoverageTypeToColorType(coverageType),
                                                  CoverageTypeHasInternalMultisample(coverageType),
                                                  caps,
                                                  useAllocator);
    }

    GrCCAtlas(CoverageType, const Specs&, const GrCaps&);
    ~GrCCAtlas() override;

    // This is an optional space for the caller to jot down user-defined instance data to use when
    // rendering atlas content.
    void setFillBatchID(int id);
    int getFillBatchID() const { return fFillBatchID; }
    void setStrokeBatchID(int id);
    int getStrokeBatchID() const { return fStrokeBatchID; }
    void setEndStencilResolveInstance(int idx);
    int getEndStencilResolveInstance() const { return fEndStencilResolveInstance; }

    sk_sp<GrCCCachedAtlas> refOrMakeCachedAtlas(GrOnFlushResourceProvider*);

private:
    const CoverageType fCoverageType;
    int fFillBatchID;
    int fStrokeBatchID;
    int fEndStencilResolveInstance;
    sk_sp<GrCCCachedAtlas> fCachedAtlas;
};

/**
 * This class implements an unbounded stack of atlases. When the current atlas reaches the
 * implementation-dependent max texture size, a new one is pushed to the back and we continue on.
 */
class GrCCAtlasStack {
public:
    using CoverageType = GrCCAtlas::CoverageType;
    using CCAtlasAllocator = GrTBlockList<GrCCAtlas, 4>;

    GrCCAtlasStack(CoverageType coverageType, const GrCCAtlas::Specs& specs, const GrCaps* caps)
            : fCoverageType(coverageType), fSpecs(specs), fCaps(caps) {}

    CoverageType coverageType() const { return fCoverageType; }
    bool empty() const { return fAtlases.empty(); }
    const GrCCAtlas& front() const { SkASSERT(!this->empty()); return fAtlases.front(); }
    GrCCAtlas& front() { SkASSERT(!this->empty()); return fAtlases.front(); }
    GrCCAtlas& current() { SkASSERT(!this->empty()); return fAtlases.back(); }

    CCAtlasAllocator::Iter atlases() { return fAtlases.items(); }
    CCAtlasAllocator::CIter atlases() const { return fAtlases.items(); }

    // Adds a rect to the current atlas and returns the offset from device space to atlas space.
    // Call current() to get the atlas it was added to.
    //
    // If the return value is non-null, it means the given rect did not fit in the then-current
    // atlas, so it was retired and a new one was added to the stack. The return value is the
    // newly-retired atlas. The caller should call setUserBatchID() on the retired atlas before
    // moving on.
    GrCCAtlas* addRect(const SkIRect& devIBounds, SkIVector* devToAtlasOffset);

private:
    const CoverageType fCoverageType;
    const GrCCAtlas::Specs fSpecs;
    const GrCaps* const fCaps;
    CCAtlasAllocator fAtlases;
};

inline void GrCCAtlas::Specs::accountForSpace(int width, int height) {
    fMinWidth = std::max(width, fMinWidth);
    fMinHeight = std::max(height, fMinHeight);
    fApproxNumPixels += (width + kPadding) * (height + kPadding);
}

#endif