/*

 * Copyright (c) 2022, the SerenityOS developers.

 *

 * SPDX-License-Identifier: BSD-2-Clause

 */

#include <AK/Utf32View.h>

#include <AK/Utf8View.h>

#include <LibGfx/Font/Emoji.h>

#include <LibGfx/Font/ScaledFont.h>

namespace Gfx {

ScaledFont::ScaledFont(NonnullRefPtr<VectorFont> font, float point_width, float point_height, unsigned dpi_x, unsigned dpi_y)

    : m_font(move(font))

    , m_point_width(point_width)

    , m_point_height(point_height)

{

    float units_per_em = m_font->units_per_em();

    m_x_scale = (point_width * dpi_x) / (POINTS_PER_INCH * units_per_em);

    m_y_scale = (point_height * dpi_y) / (POINTS_PER_INCH * units_per_em);

    auto metrics = m_font->metrics(m_x_scale, m_y_scale);

    m_pixel_size = m_point_height * (DEFAULT_DPI / POINTS_PER_INCH);

    m_pixel_size_rounded_up = static_cast<int>(ceilf(m_pixel_size));

    m_pixel_metrics = Gfx::FontPixelMetrics {

        .size = (float)pixel_size(),

        .x_height = metrics.x_height,

        .advance_of_ascii_zero = (float)glyph_width('0'),

        .glyph_spacing = (float)glyph_spacing(),

        .ascent = metrics.ascender,

        .descent = metrics.descender,

        .line_gap = metrics.line_gap,

    };

}

int ScaledFont::width_rounded_up(StringView view) const

{

    return static_cast<int>(ceilf(width(view)));

}

float ScaledFont::width(StringView view) const { return unicode_view_width(Utf8View(view)); }

float ScaledFont::width(Utf8View const& view) const { return unicode_view_width(view); }

float ScaledFont::width(Utf32View const& view) const { return unicode_view_width(view); }

template<typename T>

ALWAYS_INLINE float ScaledFont::unicode_view_width(T const& view) const

{

    if (view.is_empty())

        return 0;

    float width = 0;

    float longest_width = 0;

    u32 last_code_point = 0;

    for (auto it = view.begin(); it != view.end(); last_code_point = *it, ++it) {

        auto code_point = *it;

        if (code_point == '\n' || code_point == '\r') {

            longest_width = max(width, longest_width);

            width = 0;

            continue;

        }

        auto kerning = glyphs_horizontal_kerning(last_code_point, code_point);

        width += kerning + glyph_or_emoji_width(it);

    }

    longest_width = max(width, longest_width);

    return longest_width;

}

Unexecuted instantiation: float Gfx::ScaledFont::unicode_view_width<AK::Utf8View>(AK::Utf8View const&) const

Unexecuted instantiation: float Gfx::ScaledFont::unicode_view_width<AK::Utf32View>(AK::Utf32View const&) const

RefPtr<Gfx::Bitmap> ScaledFont::rasterize_glyph(u32 glyph_id, GlyphSubpixelOffset subpixel_offset) const

{

    GlyphIndexWithSubpixelOffset index { glyph_id, subpixel_offset };

    auto glyph_iterator = m_cached_glyph_bitmaps.find(index);

    if (glyph_iterator != m_cached_glyph_bitmaps.end())

        return glyph_iterator->value;

    auto glyph_bitmap = m_font->rasterize_glyph(glyph_id, m_x_scale, m_y_scale, subpixel_offset);

    m_cached_glyph_bitmaps.set(index, glyph_bitmap);

    return glyph_bitmap;

}

bool ScaledFont::append_glyph_path_to(Gfx::Path& path, u32 glyph_id) const

{

    auto glyph_iterator = m_glyph_cache.find(glyph_id);

    if (glyph_iterator != m_glyph_cache.end()) {

        path.append_path(glyph_iterator->value, Path::AppendRelativeToLastPoint::Yes);

        return true;

    }

    Gfx::Path glyph_path;

    bool success = m_font->append_glyph_path_to(glyph_path, glyph_id, m_x_scale, m_y_scale);

    if (success) {

        path.append_path(glyph_path, Path::AppendRelativeToLastPoint::Yes);

        m_glyph_cache.set(glyph_id, move(glyph_path));

    }

    return success;

}

Optional<Gfx::Glyph> ScaledFont::glyph(u32 code_point) const

{

    return glyph(code_point, GlyphSubpixelOffset { 0, 0 });

}

Optional<Glyph> ScaledFont::glyph_for_id(u32 id, GlyphSubpixelOffset subpixel_offset) const

{

    auto bitmap = rasterize_glyph(id, subpixel_offset);

    if (!bitmap)

        return {};

    auto metrics = glyph_metrics(id);

    return Gfx::Glyph(bitmap, metrics.left_side_bearing, metrics.advance_width, metrics.ascender, m_font->has_color_bitmaps());

}

Optional<Gfx::Glyph> ScaledFont::glyph(u32 code_point, GlyphSubpixelOffset subpixel_offset) const

{

    auto id = glyph_id_for_code_point(code_point);

    return glyph_for_id(id, subpixel_offset);

}

Optional<Glyph> ScaledFont::glyph_for_postscript_name(StringView name, GlyphSubpixelOffset subpixel_offset) const

{

    auto id = glyph_id_for_postscript_name(name);

    if (!id.has_value())

        return {};

    return glyph_for_id(id.value(), subpixel_offset);

}

float ScaledFont::glyph_left_bearing(u32 code_point) const

{

    auto id = glyph_id_for_code_point(code_point);

    return glyph_metrics(id).left_side_bearing;

}

Optional<float> ScaledFont::glyph_left_bearing_for_postscript_name(StringView name) const

{

    auto id = glyph_id_for_postscript_name(name);

    if (!id.has_value())

        return {};

    return glyph_metrics(id.value()).left_side_bearing;

}

float ScaledFont::glyph_width(u32 code_point) const

{

    auto id = glyph_id_for_code_point(code_point);

    return m_font->glyph_advance(id, m_x_scale, m_y_scale, m_point_width, m_point_height);

}

Optional<float> ScaledFont::glyph_width_for_postscript_name(StringView name) const

{

    auto id = glyph_id_for_postscript_name(name);

    if (!id.has_value())

        return {};

    return m_font->glyph_advance(id.value(), m_x_scale, m_y_scale, m_point_width, m_point_height);

}

template<typename CodePointIterator>

static float glyph_or_emoji_width_impl(ScaledFont const& font, CodePointIterator& it)

{

    if (!font.has_color_bitmaps()) {

        if (auto const* emoji = Emoji::emoji_for_code_point_iterator(it))

            return font.pixel_size() * emoji->width() / emoji->height();

    }

    return font.glyph_width(*it);

}

Unexecuted instantiation: ScaledFont.cpp:float Gfx::glyph_or_emoji_width_impl<AK::Utf8CodePointIterator>(Gfx::ScaledFont const&, AK::Utf8CodePointIterator&)

Unexecuted instantiation: ScaledFont.cpp:float Gfx::glyph_or_emoji_width_impl<AK::Utf32CodePointIterator>(Gfx::ScaledFont const&, AK::Utf32CodePointIterator&)

float ScaledFont::glyph_or_emoji_width(Utf8CodePointIterator& it) const

{

    return glyph_or_emoji_width_impl(*this, it);

}

float ScaledFont::glyph_or_emoji_width(Utf32CodePointIterator& it) const

{

    return glyph_or_emoji_width_impl(*this, it);

}

float ScaledFont::glyphs_horizontal_kerning(u32 left_code_point, u32 right_code_point) const

{

    if (left_code_point == 0 || right_code_point == 0)

        return 0.f;

    auto left_glyph_id = glyph_id_for_code_point(left_code_point);

    auto right_glyph_id = glyph_id_for_code_point(right_code_point);

    if (left_glyph_id == 0 || right_glyph_id == 0)

        return 0.f;

    return m_font->glyphs_horizontal_kerning(left_glyph_id, right_glyph_id, m_x_scale);

}

u8 ScaledFont::glyph_fixed_width() const

{

    return glyph_metrics(glyph_id_for_code_point(' ')).advance_width;

}

NonnullRefPtr<ScaledFont> ScaledFont::scaled_with_size(float point_size) const

{

    if (point_size == m_point_height && point_size == m_point_width)

        return *const_cast<ScaledFont*>(this);

    return m_font->scaled_font(point_size);

}

NonnullRefPtr<Font> ScaledFont::with_size(float point_size) const

{

    return scaled_with_size(point_size);

}

Gfx::FontPixelMetrics ScaledFont::pixel_metrics() const

{

    return m_pixel_metrics;

}

float ScaledFont::pixel_size() const

{

    return m_pixel_size;

}

int ScaledFont::pixel_size_rounded_up() const

{

    return m_pixel_size_rounded_up;

}

float ScaledFont::point_size() const

{

    return m_point_height;

}

}