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

#include "SkBitmap.h"
#include "SkCanvas.h"
#include "SkDescriptor.h"
#include "SkGlyph.h"
#include "SkMask.h"
// #include "SkOTUtils.h"
#include "SkScalerContext.h"
#include "SkTestScalerContext.h"
#include "SkTypefaceCache.h"

class SkTestTypeface : public SkTypeface {
public:
    SkTestTypeface(SkPaint::FontMetrics (*funct)(SkTDArray<SkPath*>& , SkTDArray<SkFixed>& ),
                   SkTypeface::Style style) 
        : SkTypeface(style, SkTypefaceCache::NewFontID(), false) {
        fMetrics = (*funct)(fPaths, fWidths);
    }

    virtual ~SkTestTypeface() {
        fPaths.deleteAll();
    }

    void getAdvance(SkGlyph* glyph) {
        glyph->fAdvanceX = fWidths[SkGlyph::ID2Code(glyph->fID)];
        glyph->fAdvanceY = 0;
    }

    void getFontMetrics(SkPaint::FontMetrics* metrics) {
        *metrics = fMetrics;
    }

    void getMetrics(SkGlyph* glyph) {
        glyph->fAdvanceX = fWidths[SkGlyph::ID2Code(glyph->fID)];
        glyph->fAdvanceY = 0;
    }

    void getPath(const SkGlyph& glyph, SkPath* path) {
        *path = *fPaths[SkGlyph::ID2Code(glyph.fID)];
    }

protected:
    virtual SkScalerContext* onCreateScalerContext(const SkDescriptor* desc) const SK_OVERRIDE;

    virtual void onFilterRec(SkScalerContextRec* rec) const SK_OVERRIDE {
        rec->setHinting(SkPaint::kNo_Hinting);
        rec->fMaskFormat = SkMask::kA8_Format;
    }

    virtual SkAdvancedTypefaceMetrics* onGetAdvancedTypefaceMetrics(
                                    SkAdvancedTypefaceMetrics::PerGlyphInfo ,
                                    const uint32_t* glyphIDs,
                                    uint32_t glyphIDsCount) const SK_OVERRIDE {
    // pdf only
        SkAdvancedTypefaceMetrics* info = new SkAdvancedTypefaceMetrics;
        info->fEmSize = 0;
        info->fLastGlyphID = SkToU16(onCountGlyphs() - 1);
        info->fStyle = 0;
        info->fFontName.set("SkiaTest");
        info->fType = SkAdvancedTypefaceMetrics::kOther_Font;
        info->fItalicAngle = 0;
        info->fAscent = 0;
        info->fDescent = 0;
        info->fStemV = 0;
        info->fCapHeight = 0;
        info->fBBox = SkIRect::MakeEmpty();
        return info;
    }

    virtual SkStream* onOpenStream(int* ttcIndex) const SK_OVERRIDE {
        SkASSERT(0);  // don't expect to get here
        return NULL;
    }

    virtual void onGetFontDescriptor(SkFontDescriptor* desc, bool* isLocal) const SK_OVERRIDE {
        SkASSERT(0);  // don't expect to get here
    }

    virtual int onCharsToGlyphs(const void* chars, Encoding encoding,
                                uint16_t glyphs[], int glyphCount) const SK_OVERRIDE {
        SkASSERT(encoding == kUTF8_Encoding);
        for (int index = 0; index < glyphCount; ++index) {
            int ch = ((unsigned char*) chars)[index];
            SkASSERT(ch < 0x7F);
            if (ch < 0x20) {
                glyphs[index] = 0;
            } else {
                glyphs[index] = ch - 0x20;
            }
        }
        return glyphCount;
    }

    virtual int onCountGlyphs() const SK_OVERRIDE {
        return fPaths.count();
    }

    virtual int onGetUPEM() const SK_OVERRIDE {
        SkASSERT(0);  // don't expect to get here
        return 1;
    }

    virtual SkTypeface::LocalizedStrings* onCreateFamilyNameIterator() const SK_OVERRIDE {
        SkString familyName("SkiaTest");
        SkString language("und"); //undetermined
    SkASSERT(0);  // incomplete
        return NULL;
   //     return new SkOTUtils::LocalizedStrings_SingleName(familyName, language);
    }

    virtual int onGetTableTags(SkFontTableTag tags[]) const SK_OVERRIDE {
        return 0;
    }

    virtual size_t onGetTableData(SkFontTableTag tag, size_t offset,
                                  size_t length, void* data) const SK_OVERRIDE {
        return 0;
    }

private:
    SkTDArray<SkPath* > fPaths;
    SkTDArray<SkFixed> fWidths;
    SkPaint::FontMetrics fMetrics;
    friend class SkTestScalerContext;
};

SkTypeface* CreateTestTypeface(SkPaint::FontMetrics (*funct)(SkTDArray<SkPath*>& pathArray,
                               SkTDArray<SkFixed>& widthArray),
                               SkTypeface::Style style) {
    SkTypeface* test = SkNEW_ARGS(SkTestTypeface, (funct, style));
    return test;
}

class SkTestScalerContext : public SkScalerContext {
public:
    SkTestScalerContext(SkTestTypeface* face, const SkDescriptor* desc)
        : SkScalerContext(face, desc)
        , fFace(face)
    {
        fRec.getSingleMatrix(&fMatrix);
        this->forceGenerateImageFromPath();
    }

    virtual ~SkTestScalerContext() {
    }

protected:
    virtual unsigned generateGlyphCount() SK_OVERRIDE {
        return fFace->onCountGlyphs();
    }

    virtual uint16_t generateCharToGlyph(SkUnichar uni) SK_OVERRIDE {
        uint8_t ch = (uint8_t) uni;
        SkASSERT(ch < 0x7f);
        uint16_t glyph;
        (void) fFace->onCharsToGlyphs((const void *) &ch, SkTypeface::kUTF8_Encoding, &glyph, 1);
        return glyph;
    }

    virtual void generateAdvance(SkGlyph* glyph) SK_OVERRIDE {
        fFace->getAdvance(glyph);

        SkVector advance;
        fMatrix.mapXY(SkFixedToScalar(glyph->fAdvanceX),
                      SkFixedToScalar(glyph->fAdvanceY), &advance);
        glyph->fAdvanceX = SkScalarToFixed(advance.fX);
        glyph->fAdvanceY = SkScalarToFixed(advance.fY);
    }

    virtual void generateMetrics(SkGlyph* glyph) SK_OVERRIDE {
        fFace->getMetrics(glyph);

        SkVector advance;
        fMatrix.mapXY(SkFixedToScalar(glyph->fAdvanceX),
                      SkFixedToScalar(glyph->fAdvanceY), &advance);
        glyph->fAdvanceX = SkScalarToFixed(advance.fX);
        glyph->fAdvanceY = SkScalarToFixed(advance.fY);

        SkPath path;
        fFace->getPath(*glyph, &path);
        path.transform(fMatrix);

        SkRect storage;
        const SkPaint paint;
        const SkRect& newBounds = paint.doComputeFastBounds(path.getBounds(),
                                                            &storage,
                                                            SkPaint::kFill_Style);
        SkIRect ibounds;
        newBounds.roundOut(&ibounds);
        glyph->fLeft = ibounds.fLeft;
        glyph->fTop = ibounds.fTop;
        glyph->fWidth = ibounds.width();
        glyph->fHeight = ibounds.height();
        glyph->fMaskFormat = SkMask::kARGB32_Format;
    }

    virtual void generateImage(const SkGlyph& glyph) SK_OVERRIDE {
        SkPath path;
        fFace->getPath(glyph, &path);

        SkBitmap bm;
        bm.installPixels(SkImageInfo::MakeN32Premul(glyph.fWidth, glyph.fHeight),
                            glyph.fImage, glyph.rowBytes());
        bm.eraseColor(0);

        SkCanvas canvas(bm);
        canvas.translate(-SkIntToScalar(glyph.fLeft),
                            -SkIntToScalar(glyph.fTop));
        canvas.concat(fMatrix);
        SkPaint paint;
        paint.setAntiAlias(true);
        canvas.drawPath(path, paint);
    }

    virtual void generatePath(const SkGlyph& glyph, SkPath* path) SK_OVERRIDE {
        fFace->getPath(glyph, path);
        path->transform(fMatrix);
    }

    virtual void generateFontMetrics(SkPaint::FontMetrics* metrics) SK_OVERRIDE {
        fFace->getFontMetrics(metrics);
        if (metrics) {
            SkScalar scale = fMatrix.getScaleY();
            metrics->fTop = SkScalarMul(metrics->fTop, scale);
            metrics->fAscent = SkScalarMul(metrics->fAscent, scale);
            metrics->fDescent = SkScalarMul(metrics->fDescent, scale);
            metrics->fBottom = SkScalarMul(metrics->fBottom, scale);
            metrics->fLeading = SkScalarMul(metrics->fLeading, scale);
            metrics->fAvgCharWidth = SkScalarMul(metrics->fAvgCharWidth, scale);
            metrics->fXMin = SkScalarMul(metrics->fXMin, scale);
            metrics->fXMax = SkScalarMul(metrics->fXMax, scale);
            metrics->fXHeight = SkScalarMul(metrics->fXHeight, scale);
        }
    }

private:
    SkTestTypeface*  fFace;
    SkMatrix         fMatrix;
};

SkScalerContext* SkTestTypeface::onCreateScalerContext(const SkDescriptor* desc) const {
    return SkNEW_ARGS(SkTestScalerContext, (const_cast<SkTestTypeface*>(this), desc));
}