/*

 * Copyright 2011 Google Inc.

 *

 * Use of this source code is governed by a BSD-style license that can be

 * found in the LICENSE file.

 */

#ifndef SkPDFDevice_DEFINED

#define SkPDFDevice_DEFINED

#include "include/core/SkBitmap.h"

#include "include/core/SkCanvas.h"

#include "include/core/SkData.h"

#include "include/core/SkPaint.h"

#include "include/core/SkRect.h"

#include "include/core/SkRefCnt.h"

#include "include/core/SkStream.h"

#include "include/private/SkTHash.h"

#include "src/core/SkClipStack.h"

#include "src/core/SkClipStackDevice.h"

#include "src/core/SkTextBlobPriv.h"

#include "src/pdf/SkKeyedImage.h"

#include "src/pdf/SkPDFGraphicStackState.h"

#include "src/pdf/SkPDFTypes.h"

#include <vector>

class SkGlyphRunList;

class SkKeyedImage;

class SkPDFArray;

class SkPDFDevice;

class SkPDFDict;

class SkPDFDocument;

class SkPDFFont;

class SkPDFObject;

class SkPath;

class SkRRect;

struct SkPDFIndirectReference;

/**

 *  \class SkPDFDevice

 *

 *  An SkPDFDevice is the drawing context for a page or layer of PDF

 *  content.

 */

class SkPDFDevice final : public SkClipStackDevice {

public:

    /**

     *  @param pageSize Page size in point units.

     *         1 point == 127/360 mm == 1/72 inch

     *  @param document  A non-null pointer back to the

     *         PDFDocument object.  The document is responsible for

     *         de-duplicating across pages (via the SkPDFDocument) and

     *         for early serializing of large immutable objects, such

     *         as images (via SkPDFDocument::serialize()).

     *  @param initialTransform Transform to be applied to the entire page.

     */

    SkPDFDevice(SkISize pageSize, SkPDFDocument* document,

                const SkMatrix& initialTransform = SkMatrix::I());

    sk_sp<SkPDFDevice> makeCongruentDevice() {

        return sk_make_sp<SkPDFDevice>(this->size(), fDocument);

    }

    ~SkPDFDevice() override;

    /**

     *  These are called inside the per-device-layer loop for each draw call.

     *  When these are called, we have already applied any saveLayer

     *  operations, and are handling any looping from the paint.

     */

    void drawPaint(const SkPaint& paint) override;

    void drawPoints(SkCanvas::PointMode mode,

                    size_t count, const SkPoint[],

                    const SkPaint& paint) override;

    void drawRect(const SkRect& r, const SkPaint& paint) override;

    void drawOval(const SkRect& oval, const SkPaint& paint) override;

    void drawRRect(const SkRRect& rr, const SkPaint& paint) override;

    void drawPath(const SkPath& origpath, const SkPaint& paint, bool pathIsMutable) override;

    void drawImageRect(const SkImage*,

                       const SkRect* src,

                       const SkRect& dst,

                       const SkSamplingOptions&,

                       const SkPaint&,

                       SkCanvas::SrcRectConstraint) override;

    void onDrawGlyphRunList(const SkGlyphRunList& glyphRunList, const SkPaint& paint) override;

    void drawVertices(const SkVertices*, SkBlendMode, const SkPaint&) override;

    // PDF specific methods.

    void drawSprite(const SkBitmap& bitmap, int x, int y,

                    const SkPaint& paint);

    /** Create the resource dictionary for this device. Destructive. */

    std::unique_ptr<SkPDFDict> makeResourceDict();

    /** Returns a SkStream with the page contents.

     */

    std::unique_ptr<SkStreamAsset> content();

    SkISize size() const { return this->imageInfo().dimensions(); }

    SkIRect bounds() const { return this->imageInfo().bounds(); }

    void DrawGlyphRunAsPath(SkPDFDevice* dev, const SkGlyphRun& glyphRun, SkPoint offset);

    const SkMatrix& initialTransform() const { return fInitialTransform; }

protected:

    sk_sp<SkSurface> makeSurface(const SkImageInfo&, const SkSurfaceProps&) override;

    void drawAnnotation(const SkRect&, const char key[], SkData* value) override;

    void drawDevice(SkBaseDevice*, const SkSamplingOptions&, const SkPaint&) override;

    void drawSpecial(SkSpecialImage*, const SkMatrix&, const SkSamplingOptions&,

                     const SkPaint&) override;

    sk_sp<SkSpecialImage> makeSpecial(const SkBitmap&) override;

    sk_sp<SkSpecialImage> makeSpecial(const SkImage*) override;

    SkImageFilterCache* getImageFilterCache() override;

private:

    // TODO(vandebo): push most of SkPDFDevice's state into a core object in

    // order to get the right access levels without using friend.

    friend class ScopedContentEntry;

    SkMatrix fInitialTransform;

    SkTHashSet<SkPDFIndirectReference> fGraphicStateResources;

    SkTHashSet<SkPDFIndirectReference> fXObjectResources;

    SkTHashSet<SkPDFIndirectReference> fShaderResources;

    SkTHashSet<SkPDFIndirectReference> fFontResources;

    int fNodeId;

    SkDynamicMemoryWStream fContent;

    SkDynamicMemoryWStream fContentBuffer;

    bool fNeedsExtraSave = false;

    SkPDFGraphicStackState fActiveStackState;

    SkPDFDocument* fDocument;

    ////////////////////////////////////////////////////////////////////////////

    SkBaseDevice* onCreateDevice(const CreateInfo&, const SkPaint*) override;

    // Set alpha to true if making a transparency group form x-objects.

    SkPDFIndirectReference makeFormXObjectFromDevice(bool alpha = false);

    SkPDFIndirectReference makeFormXObjectFromDevice(SkIRect bbox, bool alpha = false);

    void drawFormXObjectWithMask(SkPDFIndirectReference xObject,

                                 SkPDFIndirectReference sMask,

                                 SkBlendMode,

                                 bool invertClip);

    // If the paint or clip is such that we shouldn't draw anything, this

    // returns nullptr and does not create a content entry.

    // setUpContentEntry and finishContentEntry can be used directly, but

    // the preferred method is to use the ScopedContentEntry helper class.

    SkDynamicMemoryWStream* setUpContentEntry(const SkClipStack* clipStack,

                                              const SkMatrix& matrix,

                                              const SkPaint& paint,

                                              SkScalar,

                                              SkPDFIndirectReference* dst);

    void finishContentEntry(const SkClipStack*, SkBlendMode, SkPDFIndirectReference, SkPath*);

    bool isContentEmpty();

    void internalDrawGlyphRun(const SkGlyphRun& glyphRun, SkPoint offset, const SkPaint& runPaint);

    void drawGlyphRunAsPath(const SkGlyphRun& glyphRun, SkPoint offset, const SkPaint& runPaint);

    void internalDrawImageRect(SkKeyedImage,

                               const SkRect* src,

                               const SkRect& dst,

                               const SkSamplingOptions&,

                               const SkPaint&,

                               const SkMatrix& canvasTransformationMatrix);

    void internalDrawPath(const SkClipStack&,

                          const SkMatrix&,

                          const SkPath&,

                          const SkPaint&,

                          bool pathIsMutable);

    void internalDrawPathWithFilter(const SkClipStack& clipStack,

                                    const SkMatrix& ctm,

                                    const SkPath& origPath,

                                    const SkPaint& paint);

    bool handleInversePath(const SkPath& origPath, const SkPaint& paint, bool pathIsMutable);

    void clearMaskOnGraphicState(SkDynamicMemoryWStream*);

    void setGraphicState(SkPDFIndirectReference gs, SkDynamicMemoryWStream*);

    void drawFormXObject(SkPDFIndirectReference xObject, SkDynamicMemoryWStream*);

    bool hasEmptyClip() const { return this->cs().isEmpty(this->bounds()); }

    void reset();

    using INHERITED = SkClipStackDevice;

};

#endif