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

#include <hb-ot.h>
#include <unicode/stringpiece.h>
#include <unicode/ubidi.h>
#include <unicode/unistr.h>

#include "SkShaper.h"
#include "SkStream.h"
#include "SkTemplates.h"
#include "SkTextBlob.h"
#include "SkTypeface.h"
#include "SkUtils.h"

static const int FONT_SIZE_SCALE = 512;

namespace {
template <class T, void(*P)(T*)> using resource = std::unique_ptr<T, SkFunctionWrapper<void, T, P>>;
using HBBlob   = resource<hb_blob_t  , hb_blob_destroy  >;
using HBFace   = resource<hb_face_t  , hb_face_destroy  >;
using HBFont   = resource<hb_font_t  , hb_font_destroy  >;
using HBBuffer = resource<hb_buffer_t, hb_buffer_destroy>;
using ICUBiDi  = resource<UBiDi      , ubidi_close      >;

HBBlob stream_to_blob(std::unique_ptr<SkStreamAsset> asset) {
    size_t size = asset->getLength();
    HBBlob blob;
    if (const void* base = asset->getMemoryBase()) {
        blob.reset(hb_blob_create((char*)base, SkToUInt(size),
                                  HB_MEMORY_MODE_READONLY, asset.release(),
                                  [](void* p) { delete (SkStreamAsset*)p; }));
    } else {
        // SkDebugf("Extra SkStreamAsset copy\n");
        void* ptr = size ? sk_malloc_throw(size) : nullptr;
        asset->read(ptr, size);
        blob.reset(hb_blob_create((char*)ptr, SkToUInt(size),
                                  HB_MEMORY_MODE_READONLY, ptr, sk_free));
    }
    SkASSERT(blob);
    hb_blob_make_immutable(blob.get());
    return blob;
}
}  // namespace

struct SkShaper::Impl {
    HBFont fHarfBuzzFont;
    HBBuffer fBuffer;
    sk_sp<SkTypeface> fTypeface;
};

static HBFont create_hb_font(SkTypeface* tf) {
    int index;
    HBBlob blob(stream_to_blob(std::unique_ptr<SkStreamAsset>(tf->openStream(&index))));
    HBFace face(hb_face_create(blob.get(), (unsigned)index));
    SkASSERT(face);
    if (!face) {
        return nullptr;
    }
    hb_face_set_index(face.get(), (unsigned)index);
    hb_face_set_upem(face.get(), tf->getUnitsPerEm());

    HBFont font(hb_font_create(face.get()));
    SkASSERT(font);
    if (!font) {
        return nullptr;
    }
    hb_font_set_scale(font.get(), FONT_SIZE_SCALE, FONT_SIZE_SCALE);
    hb_ot_font_set_funcs(font.get());
    int axis_count = tf->getVariationDesignPosition(nullptr, 0);
    if (axis_count > 0) {
        SkAutoSTMalloc<4, SkFontArguments::VariationPosition::Coordinate> axis_values(axis_count);
        if (tf->getVariationDesignPosition(axis_values, axis_count) == axis_count) {
            hb_font_set_variations(font.get(),
                                   reinterpret_cast<hb_variation_t*>(axis_values.get()),
                                   axis_count);
        }
    }
    return font;
}

SkShaper::SkShaper(sk_sp<SkTypeface> tf) : fImpl(new Impl) {
    fImpl->fTypeface = tf ? std::move(tf) : SkTypeface::MakeDefault();
    fImpl->fHarfBuzzFont = create_hb_font(fImpl->fTypeface.get());
    SkASSERT(fImpl->fHarfBuzzFont);
    fImpl->fBuffer.reset(hb_buffer_create());
}

SkShaper::~SkShaper() {}

bool SkShaper::good() const { return fImpl->fHarfBuzzFont != nullptr; }

SkScalar SkShaper::shape(SkTextBlobBuilder* builder,
                         const SkPaint& srcPaint,
                         const char* utf8text,
                         size_t textBytes,
                         bool leftToRight,
                         SkPoint point) const {
    SkASSERT(builder);
    UBiDiLevel bidiLevel = leftToRight ? UBIDI_DEFAULT_LTR : UBIDI_DEFAULT_RTL;
    //hb_script_t script = ...
    UErrorCode status = U_ZERO_ERROR;
    double x = point.x();
    double y = point.y();

    // This function only accepts utf8.
    // ubidi only accepts utf16 (though internally it basically works on utf32 chars).
    // Internally, harfbuzz is all utf32, but always makes a copy.

    if (!SkTFitsIn<int32_t>(textBytes)) {
        SkDebugf("Bidi error: text too long");
        return (SkScalar)x;
    }
    icu::UnicodeString utf16 = icu::UnicodeString::fromUTF8(icu::StringPiece(utf8text, textBytes));

    ICUBiDi bidi(ubidi_openSized(utf16.length(), 0, &status));
    if (U_FAILURE(status)) {
        SkDebugf("Bidi error: %s", u_errorName(status));
        return (SkScalar)x;
    }
    SkASSERT(bidi);

    ubidi_setPara(bidi.get(), utf16.getBuffer(), utf16.length(), bidiLevel, nullptr, &status);
    if (U_FAILURE(status)) {
        SkDebugf("Bidi error: %s", u_errorName(status));
        return (SkScalar)x;
    }

    int32_t runCount = ubidi_countRuns(bidi.get(), &status);
    if (U_FAILURE(status)) {
        SkDebugf("Bidi error: %s", u_errorName(status));
        return (SkScalar)x;
    }

    const UChar* utf16End = utf16.getBuffer();
    const char* utf8End = utf8text;
    for (int32_t i = 0; i < runCount; ++i) {
        int32_t start;
        int32_t length;
        UBiDiDirection direction = ubidi_getVisualRun(bidi.get(), i, &start, &length);

        SkPaint paint(srcPaint);
        paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
        paint.setTypeface(fImpl->fTypeface);

        hb_buffer_t* buffer = fImpl->fBuffer.get();
        SkAutoTCallVProc<hb_buffer_t, hb_buffer_clear_contents> autoClearBuffer(buffer);

        // The difficulty here is the cluster mapping.
        // If the hb_buffer is created with utf16, clusters will be pointing to the utf16 indexes,
        // but the SkTextBlob can only take utf8 and utf8 cluster indexes.
        // So populate the hb_buffer directly with utf32 and utf8 cluster indexes.
        // Since this steps through the visual runs in order, it is expected that each run will
        // start just after the previous one ended.
        const UChar* utf16Start = utf16.getBuffer() + start;
        const char* utf8Start;
        if (utf16End == utf16Start) {
            utf16Start = utf16End;
            utf8Start = utf8End;
        } else {
            SkDEBUGFAIL("Did not expect to ever get here.");
            utf16Start = utf16.getBuffer();
            utf8Start = utf8text;
            while (utf16Start < utf16.getBuffer() + start) {
                SkUTF16_NextUnichar(&utf16Start);
                SkUTF8_NextUnichar(&utf8Start);
            }
        }
        const char* utf8Current = utf8Start;
        const UChar* utf16Current = utf16Start;
        utf16End = utf16Current + length;
        while (utf16Current < utf16End) {
            hb_codepoint_t u;
            u = SkUTF16_NextUnichar(&utf16Current);
            hb_buffer_add(buffer, u, utf8Current - utf8Start);
            SkUTF8_NextUnichar(&utf8Current);
        }
        hb_buffer_set_content_type(buffer, HB_BUFFER_CONTENT_TYPE_UNICODE);
        utf8End = utf8Current;
        size_t utf8runLength = utf8End - utf8Start;
        if (!SkTFitsIn<int>(utf8runLength)) {
            SkDebugf("Shaping error: utf8 too long");
            return (SkScalar)x;
        }
        hb_buffer_guess_segment_properties(buffer);
        //hb_buffer_set_script(buffer, script);
        hb_buffer_set_direction(buffer, direction ? HB_DIRECTION_RTL : HB_DIRECTION_LTR);
        hb_shape(fImpl->fHarfBuzzFont.get(), buffer, nullptr, 0);
        unsigned len = hb_buffer_get_length(buffer);
        if (len == 0) {
            continue;
        }

        hb_glyph_info_t* info = hb_buffer_get_glyph_infos(buffer, nullptr);
        hb_glyph_position_t* pos = hb_buffer_get_glyph_positions(buffer, nullptr);

        if (!SkTFitsIn<int>(len)) {
            SkDebugf("Shaping error: too many glyphs");
            return (SkScalar)x;
        }
        auto runBuffer = builder->allocRunTextPos(paint, len, utf8runLength, SkString());
        memcpy(runBuffer.utf8text, utf8Start, utf8runLength);

        double textSizeY = paint.getTextSize() / (double)FONT_SIZE_SCALE;
        double textSizeX = textSizeY * paint.getTextScaleX();

        for (unsigned i = 0; i < len; i++) {
            runBuffer.glyphs[i] = info[i].codepoint;
            runBuffer.clusters[i] = info[i].cluster;
            reinterpret_cast<SkPoint*>(runBuffer.pos)[i] =
                    SkPoint::Make(SkDoubleToScalar(x + pos[i].x_offset * textSizeX),
                                  SkDoubleToScalar(y - pos[i].y_offset * textSizeY));
            x += pos[i].x_advance * textSizeX;
            y += pos[i].y_advance * textSizeY;
        }
    }
    return (SkScalar)x;
}