/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/*

 * This file is part of the LibreOffice project.

 *

 * This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/.

 *

 * This file incorporates work covered by the following license notice:

 *

 *   Licensed to the Apache Software Foundation (ASF) under one or more

 *   contributor license agreements. See the NOTICE file distributed

 *   with this work for additional information regarding copyright

 *   ownership. The ASF licenses this file to you under the Apache

 *   License, Version 2.0 (the "License"); you may not use this file

 *   except in compliance with the License. You may obtain a copy of

 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .

 */

#include <sal/config.h>

#include <i18nlangtag/mslangid.hxx>

#include <officecfg/Office/Common.hxx>

#include <sal/log.hxx>

#include <tools/stream.hxx>

#include <unotools/configmgr.hxx>

#include <unotools/fontdefs.hxx>

#include <vcl/metric.hxx>

#include <vcl/outdev.hxx>

#include <font/FontSelectPattern.hxx>

#include <font/PhysicalFontFace.hxx>

#include <font/LogicalFontInstance.hxx>

#include <font/FontMetricData.hxx>

#include <font/TrueTypeFont.hxx>

#include <com/sun/star/uno/Sequence.hxx>

#include <comphelper/sequence.hxx>

#include <hb-ot.h>

using namespace ::com::sun::star;

using namespace ::com::sun::star::uno;

using namespace ::rtl;

FontMetric::FontMetric()

    : mnAscent(0)

    , mnDescent(0)

    , mnIntLeading(0)

    , mnExtLeading(0)

    , mnLineHeight(0)

    , mnSlant(0)

    , mnBulletOffset(0)

    , mnHangingBaseline(0)

    , mdEmSize(0.0)

    , mdHorCJKAdvanceSize(0.0)

    , mdVertCJKAdvanceSize(0.0)

    , mbFullstopCentered(false)

{}

FontMetric::FontMetric( const FontMetric& rFontMetric ) = default;

FontMetric::FontMetric(vcl::font::PhysicalFontFace const& rFace)

    : FontMetric()

{

    SetFamilyName(rFace.GetFamilyName());

    SetStyleName(rFace.GetStyleName());

    SetCharSet(rFace.IsMicrosoftSymbolEncoded() ? RTL_TEXTENCODING_SYMBOL : RTL_TEXTENCODING_UNICODE);

    SetFamily(rFace.GetFamilyType());

    SetPitch(rFace.GetPitch());

    SetWeight(rFace.GetWeight());

    SetItalic(rFace.GetItalic());

    SetAlignment(TextAlign::ALIGN_TOP);

    SetWidthType(rFace.GetWidthType());

    SetQuality(rFace.GetQuality() );

}

FontMetric::~FontMetric()

{

}

FontMetric& FontMetric::operator=(const FontMetric& rFontMetric) = default;

FontMetric& FontMetric::operator=(FontMetric&& rFontMetric) = default;

bool FontMetric::EqualNoBase( const FontMetric& r ) const

{

    if (mbFullstopCentered != r.mbFullstopCentered)

        return false;

    if( mnAscent     != r.mnAscent )

        return false;

    if( mnDescent    != r.mnDescent )

        return false;

    if( mnIntLeading != r.mnIntLeading )

        return false;

    if( mnExtLeading != r.mnExtLeading )

        return false;

    if( mnSlant      != r.mnSlant )

        return false;

    return true;

}

bool FontMetric::operator==( const FontMetric& r ) const

{

    if( Font::operator!=(r) )

        return false;

    return EqualNoBase(r);

}

bool FontMetric::EqualIgnoreColor( const FontMetric& r ) const

{

    if( !Font::EqualIgnoreColor(r) )

        return false;

    return EqualNoBase(r);

}

size_t FontMetric::GetHashValueNoBase() const

{

    size_t hash = 0;

    o3tl::hash_combine( hash, mbFullstopCentered );

    o3tl::hash_combine( hash, mnAscent );

    o3tl::hash_combine( hash, mnDescent );

    o3tl::hash_combine( hash, mnIntLeading );

    o3tl::hash_combine( hash, mnExtLeading );

    o3tl::hash_combine( hash, mnSlant );

    return hash;

}

size_t FontMetric::GetHashValueIgnoreColor() const

{

    size_t hash = GetHashValueNoBase();

    o3tl::hash_combine( hash, Font::GetHashValueIgnoreColor());

    return hash;

}

FontMetricData::FontMetricData( const vcl::font::FontSelectPattern& rFontSelData )

    : FontAttributes( rFontSelData )

    , mnHeight ( rFontSelData.mnHeight )

    , mnWidth ( rFontSelData.mnWidth )

    , mnOrientation( static_cast<short>(rFontSelData.mnOrientation) )

    , mnAscent( 0 )

    , mnDescent( 0 )

    , mnIntLeading( 0 )

    , mnExtLeading( 0 )

    , mnSlant( 0 )

    , mnMinKashida( 0 )

    , mnHangingBaseline( 0 )

    , mdEmSize(0.0)

    , mdHorCJKAdvanceSize(0.0)

    , mdVertCJKAdvanceSize(0.0)

    , mbFullstopCentered( false )

    , mnBulletOffset( 0 )

    , mnUnderlineSize( 0 )

    , mnUnderlineOffset( 0 )

    , mnBUnderlineSize( 0 )

    , mnBUnderlineOffset( 0 )

    , mnDUnderlineSize( 0 )

    , mnDUnderlineOffset1( 0 )

    , mnDUnderlineOffset2( 0 )

    , mnWUnderlineSize( 0 )

    , mnWUnderlineOffset( 0 )

    , mnAboveUnderlineSize( 0 )

    , mnAboveUnderlineOffset( 0 )

    , mnAboveBUnderlineSize( 0 )

    , mnAboveBUnderlineOffset( 0 )

    , mnAboveDUnderlineSize( 0 )

    , mnAboveDUnderlineOffset1( 0 )

    , mnAboveDUnderlineOffset2( 0 )

    , mnAboveWUnderlineSize( 0 )

    , mnAboveWUnderlineOffset( 0 )

    , mnStrikeoutSize( 0 )

    , mnStrikeoutOffset( 0 )

    , mnBStrikeoutSize( 0 )

    , mnBStrikeoutOffset( 0 )

    , mnDStrikeoutSize( 0 )

    , mnDStrikeoutOffset1( 0 )

    , mnDStrikeoutOffset2( 0 )

{

    // initialize the used font name

    sal_Int32 nTokenPos = 0;

    SetFamilyName( OUString(GetNextFontToken( rFontSelData.GetFamilyName(), nTokenPos )) );

    SetStyleName( rFontSelData.GetStyleName() );

}

bool FontMetricData::ShouldNotUseUnderlineMetrics() const

{

    if (comphelper::IsFuzzing())

        return false;

    css::uno::Sequence<OUString> rNoUnderlineMetricsList(

        officecfg::Office::Common::Misc::FontsDontUseUnderlineMetrics::get());

    if (comphelper::findValue(rNoUnderlineMetricsList, GetFamilyName()) != -1)

    {

        SAL_INFO("vcl.gdi.fontmetric", "Not using underline metrics for: " << GetFamilyName());

        return true;

    }

    return false;

}

bool FontMetricData::ImplInitTextLineSizeHarfBuzz(LogicalFontInstance* pFont)

{

    if (ShouldNotUseUnderlineMetrics())

        return false;

    auto* pHbFont = pFont->GetHbFont();

    hb_position_t nUnderlineSize;

    if (!hb_ot_metrics_get_position(pHbFont, HB_OT_METRICS_TAG_UNDERLINE_SIZE, &nUnderlineSize))

        return false;

    hb_position_t nUnderlineOffset;

    if (!hb_ot_metrics_get_position(pHbFont, HB_OT_METRICS_TAG_UNDERLINE_OFFSET, &nUnderlineOffset))

        return false;

    hb_position_t nStrikeoutSize;

    if (!hb_ot_metrics_get_position(pHbFont, HB_OT_METRICS_TAG_STRIKEOUT_SIZE, &nStrikeoutSize))

        return false;

    hb_position_t nStrikeoutOffset;

    if (!hb_ot_metrics_get_position(pHbFont, HB_OT_METRICS_TAG_STRIKEOUT_OFFSET, &nStrikeoutOffset))

        return false;

    double fScale = 0;

    pFont->GetScale(nullptr, &fScale);

    double nOffset = -nUnderlineOffset * fScale;

    double nSize = nUnderlineSize * fScale;

    double nSize2 = nSize / 2.;

    double nBSize = nSize * 2.;

    double n2Size = nBSize / 3.;

    mnUnderlineSize = std::ceil(nSize);

    mnUnderlineOffset = std::ceil(nOffset);

    mnBUnderlineSize = std::ceil(nBSize);

    mnBUnderlineOffset = std::ceil(nOffset - nSize2);

    mnDUnderlineSize = std::ceil(n2Size);

    mnDUnderlineOffset1 = mnBUnderlineOffset;

    mnDUnderlineOffset2 = mnBUnderlineOffset + mnDUnderlineSize * 2;

    mnWUnderlineSize = mnBUnderlineSize;

    mnWUnderlineOffset = std::ceil(nOffset + nSize);

    nOffset = -nStrikeoutOffset * fScale;

    nSize = nStrikeoutSize * fScale;

    nSize2 = nSize / 2.;

    nBSize = nSize * 2.;

    n2Size = nBSize / 3.;

    mnStrikeoutSize = std::ceil(nSize);

    mnStrikeoutOffset = std::ceil(nOffset);

    mnBStrikeoutSize = std::ceil(nBSize);

    mnBStrikeoutOffset = std::round(nOffset - nSize2);

    mnDStrikeoutSize = std::ceil(n2Size);

    mnDStrikeoutOffset1 = mnBStrikeoutOffset;

    mnDStrikeoutOffset2 = mnBStrikeoutOffset + mnDStrikeoutSize * 2;

    return true;

}

void FontMetricData::ImplInitTextLineSize( const OutputDevice* pDev )

{

    mnBulletOffset = ( pDev->GetTextWidth( OUString( u' ' ) ) - pDev->GetTextWidth( OUString( u'\x00b7' ) ) ) >> 1 ;

    if (ImplInitTextLineSizeHarfBuzz(const_cast<LogicalFontInstance*>(pDev->GetFontInstance())))

        return;

    tools::Long nDescent = mnDescent;

    if ( nDescent <= 0 )

    {

        nDescent = mnAscent / 10;

        if ( !nDescent )

            nDescent = 1;

    }

    // #i55341# for some fonts it is not a good idea to calculate

    // their text line metrics from the real font descent

    // => work around this problem just for these fonts

    if( 3*nDescent > mnAscent )

        nDescent = mnAscent / 3;

    tools::Long nLineHeight = ((nDescent*25)+50) / 100;

    if ( !nLineHeight )

        nLineHeight = 1;

    tools::Long nLineHeight2 = nLineHeight / 2;

    if ( !nLineHeight2 )

        nLineHeight2 = 1;

    tools::Long nBLineHeight = ((nDescent*50)+50) / 100;

    if ( nBLineHeight == nLineHeight )

        nBLineHeight++;

    tools::Long nBLineHeight2 = nBLineHeight/2;

    if ( !nBLineHeight2 )

        nBLineHeight2 = 1;

    tools::Long n2LineHeight = ((nDescent*16)+50) / 100;

    if ( !n2LineHeight )

        n2LineHeight = 1;

    tools::Long n2LineDY = n2LineHeight;

     /* #117909#

      * add some pixels to minimum double line distance on higher resolution devices

      */

    tools::Long nMin2LineDY = 1 + pDev->GetDPIY()/150;

    if ( n2LineDY < nMin2LineDY )

        n2LineDY = nMin2LineDY;

    tools::Long n2LineDY2 = n2LineDY/2;

    if ( !n2LineDY2 )

        n2LineDY2 = 1;

    const vcl::Font& rFont ( pDev->GetFont() );

    bool bCJKVertical = MsLangId::isCJK(rFont.GetLanguage()) && rFont.IsVertical();

    tools::Long nUnderlineOffset = bCJKVertical ? mnDescent : (mnDescent/2 + 1);

    tools::Long nStrikeoutOffset = rFont.IsVertical() ? -((mnAscent - mnDescent) / 2) : -((mnAscent - mnIntLeading) / 3);

    mnUnderlineSize        = nLineHeight;

    mnUnderlineOffset      = nUnderlineOffset - nLineHeight2;

    mnBUnderlineSize       = nBLineHeight;

    mnBUnderlineOffset     = nUnderlineOffset - nBLineHeight2;

    mnDUnderlineSize       = n2LineHeight;

    mnDUnderlineOffset1    = nUnderlineOffset - n2LineDY2 - n2LineHeight;

    mnDUnderlineOffset2    = mnDUnderlineOffset1 + n2LineDY + n2LineHeight;

    tools::Long nWCalcSize = mnDescent;

    if ( nWCalcSize < 6 )

    {

        if ( (nWCalcSize == 1) || (nWCalcSize == 2) )

            mnWUnderlineSize = nWCalcSize;

        else

            mnWUnderlineSize = 3;

    }

    else

        mnWUnderlineSize = ((nWCalcSize*50)+50) / 100;

    // Don't assume that wavelines are never placed below the descent, because for most fonts the waveline

    // is drawn into the text

    mnWUnderlineOffset     = nUnderlineOffset;

    mnStrikeoutSize        = nLineHeight;

    mnStrikeoutOffset      = nStrikeoutOffset - nLineHeight2;

    mnBStrikeoutSize       = nBLineHeight;

    mnBStrikeoutOffset     = nStrikeoutOffset - nBLineHeight2;

    mnDStrikeoutSize       = n2LineHeight;

    mnDStrikeoutOffset1    = nStrikeoutOffset - n2LineDY2 - n2LineHeight;

    mnDStrikeoutOffset2    = mnDStrikeoutOffset1 + n2LineDY + n2LineHeight;

}

void FontMetricData::ImplInitAboveTextLineSize( const OutputDevice* pDev )

{

    ImplInitTextLineSize(pDev);

    tools::Long nIntLeading = mnIntLeading;

    // TODO: assess usage of nLeading below (changed in extleading CWS)

    // if no leading is available, we assume 15% of the ascent

    if ( nIntLeading <= 0 )

    {

        nIntLeading = mnAscent*15/100;

        if ( !nIntLeading )

            nIntLeading = 1;

    }

    tools::Long nCeiling = -mnAscent;

    mnAboveUnderlineSize       = mnUnderlineSize;

    mnAboveUnderlineOffset     = nCeiling + (nIntLeading - mnUnderlineSize + 1) / 2;

    mnAboveBUnderlineSize      = mnBUnderlineSize;

    mnAboveBUnderlineOffset    = nCeiling + (nIntLeading - mnBUnderlineSize + 1) / 2;

    mnAboveDUnderlineSize      = mnDUnderlineSize;

    mnAboveDUnderlineOffset1   = nCeiling + (nIntLeading - 3*mnDUnderlineSize + 1) / 2;

    mnAboveDUnderlineOffset2   = nCeiling + (nIntLeading +   mnDUnderlineSize + 1) / 2;

    mnAboveWUnderlineSize = mnWUnderlineSize;

    mnAboveWUnderlineOffset = nCeiling + (nIntLeading + 1) / 2;

}

void FontMetricData::ImplInitFlags( const OutputDevice* pDev )

{

    const vcl::Font& rFont ( pDev->GetFont() );

    bool bCentered = true;

    if (MsLangId::isCJK(rFont.GetLanguage()))

    {

        tools::Rectangle aRect;

        pDev->GetTextBoundRect( aRect, u"\x3001"_ustr ); // Fullwidth fullstop

        const auto nH = rFont.GetFontSize().Height();

        const auto nB = aRect.Left();

        // Use 18.75% as a threshold to define a centered fullwidth fullstop.

        // In general, nB/nH < 5% for most Japanese fonts.

        bCentered = nB > (((nH >> 1)+nH)>>3);

    }

    SetFullstopCenteredFlag( bCentered );

}

bool FontMetricData::ShouldUseWinMetrics(int nAscent, int nDescent, int nTypoAscent,

                                             int nTypoDescent, int nWinAscent,

                                             int nWinDescent) const

{

    if (comphelper::IsFuzzing())

        return false;

    OUString aFontIdentifier(

        GetFamilyName() + ","

        + OUString::number(nAscent) + "," + OUString::number(nDescent) + ","

        + OUString::number(nTypoAscent) + "," + OUString::number(nTypoDescent) + ","

        + OUString::number(nWinAscent) + "," + OUString::number(nWinDescent));

    css::uno::Sequence<OUString> rWinMetricFontList(

        officecfg::Office::Common::Misc::FontsUseWinMetrics::get());

    if (comphelper::findValue(rWinMetricFontList, aFontIdentifier) != -1)

    {

        SAL_INFO("vcl.gdi.fontmetric", "Using win metrics for: " << aFontIdentifier);

        return true;

    }

    return false;

}

// These are “private” HarfBuzz metrics tags, they are supported by not exposed

// in the public header. They are safe to use, HarfBuzz just does not want to

// advertise them.

constexpr auto ASCENT_OS2 = static_cast<hb_ot_metrics_tag_t>(HB_TAG('O', 'a', 's', 'c'));

constexpr auto DESCENT_OS2 = static_cast<hb_ot_metrics_tag_t>(HB_TAG('O', 'd', 's', 'c'));

constexpr auto LINEGAP_OS2 = static_cast<hb_ot_metrics_tag_t>(HB_TAG('O', 'l', 'g', 'p'));

constexpr auto ASCENT_HHEA = static_cast<hb_ot_metrics_tag_t>(HB_TAG('H', 'a', 's', 'c'));

constexpr auto DESCENT_HHEA = static_cast<hb_ot_metrics_tag_t>(HB_TAG('H', 'd', 's', 'c'));

constexpr auto LINEGAP_HHEA = static_cast<hb_ot_metrics_tag_t>(HB_TAG('H', 'l', 'g', 'p'));

void FontMetricData::ImplCalcLineSpacing(LogicalFontInstance* pFontInstance)

{

    mnAscent = mnDescent = mnExtLeading = mnIntLeading = 0;

    auto* pFace = pFontInstance->GetFontFace();

    auto* pHbFont = pFontInstance->GetHbFont();

    double fScale = 0;

    pFontInstance->GetScale(nullptr, &fScale);

    double fAscent = 0, fDescent = 0, fExtLeading = 0;

    if (hb_ot_var_has_data(pFace->GetHbFace()))

    {

        // This is a variable font, trust HarfBuzz to give us the right metrics

        // and apply variations to them.

        hb_position_t nAscent, nDescent, nLineGap;

        if (hb_ot_metrics_get_position(pHbFont, HB_OT_METRICS_TAG_HORIZONTAL_ASCENDER, &nAscent)

            && hb_ot_metrics_get_position(pHbFont, HB_OT_METRICS_TAG_HORIZONTAL_DESCENDER,

                                          &nDescent)

            && hb_ot_metrics_get_position(pHbFont, HB_OT_METRICS_TAG_HORIZONTAL_LINE_GAP,

                                          &nLineGap))

        {

            fAscent = nAscent * fScale;

            fDescent = -nDescent * fScale;

            fExtLeading = nLineGap * fScale;

        }

    }

    else

    {

        // This is not a variable font, we try to choose the best metrics

        // ourselves for backward comparability:

        //

        // - hhea metrics should be used, since hhea is a mandatory font table

        //   and should always be present.

        // - But if OS/2 is present, it should be used since it is mandatory in

        //   Windows.

        //   OS/2 has Typo and Win metrics, but the later was meant to control

        //   text clipping not line spacing and can be ridiculously large.

        //   Unfortunately many Windows application incorrectly use the Win

        //   metrics (thanks to GDI’s TEXTMETRIC) and old fonts might be

        //   designed with this in mind, so OpenType introduced a flag for

        //   fonts to indicate that they really want to use Typo metrics. So

        //   for best backward compatibility:

        //   - Use Win metrics if available.

        //   - Unless USE_TYPO_METRICS flag is set, in which case use Typo

        //     metrics.

        // Try hhea table first.

        hb_position_t nAscent = 0, nDescent = 0, nLineGap = 0;

        if (hb_ot_metrics_get_position(pHbFont, ASCENT_HHEA, &nAscent)

            && hb_ot_metrics_get_position(pHbFont, DESCENT_HHEA, &nDescent)

            && hb_ot_metrics_get_position(pHbFont, LINEGAP_HHEA, &nLineGap))

        {

            // tdf#107605: Some fonts have weird values here, so check that

            // ascender is +ve and descender is -ve as they normally should.

            if (nAscent >= 0 && nDescent <= 0)

            {

                fAscent = nAscent * fScale;

                fDescent = -nDescent * fScale;

                fExtLeading = nLineGap * fScale;

            }

        }

        // But if OS/2 is present, prefer it.

        hb_position_t nTypoAscent, nTypoDescent, nTypoLineGap, nWinAscent, nWinDescent;

        if (hb_ot_metrics_get_position(pHbFont, ASCENT_OS2, &nTypoAscent)

            && hb_ot_metrics_get_position(pHbFont, DESCENT_OS2, &nTypoDescent)

            && hb_ot_metrics_get_position(pHbFont, LINEGAP_OS2, &nTypoLineGap)

            && hb_ot_metrics_get_position(pHbFont, HB_OT_METRICS_TAG_HORIZONTAL_CLIPPING_ASCENT,

                                          &nWinAscent)

            && hb_ot_metrics_get_position(pHbFont, HB_OT_METRICS_TAG_HORIZONTAL_CLIPPING_DESCENT,

                                          &nWinDescent))

        {

            if ((fAscent == 0.0 && fDescent == 0.0)

                || ShouldUseWinMetrics(nAscent, nDescent, nTypoAscent, nTypoDescent, nWinAscent,

                                       nWinDescent))

            {

                fAscent = nWinAscent * fScale;

                fDescent = nWinDescent * fScale;

                fExtLeading = 0;

            }

            bool bUseTypoMetrics

                = hb_ot_fetch_bits(pFace->GetHbFace(), HB_OT_BITS_TAG_FS_SELECTION) & (1 << 7);

            if (bUseTypoMetrics && nTypoAscent >= 0 && nTypoDescent <= 0)

            {

                fAscent = nTypoAscent * fScale;

                fDescent = -nTypoDescent * fScale;

                fExtLeading = nTypoLineGap * fScale;

            }

        }

    }

    mnAscent = round(fAscent);

    mnDescent = round(fDescent);

    mnExtLeading = round(fExtLeading);

    if (mnAscent || mnDescent)

        mnIntLeading = mnAscent + mnDescent - mnHeight;

    // tdf#36709: Additional font metrics are needed for font-relative indentation

    mdEmSize = static_cast<double>(mnHeight);

    // The ic is defined as the advance of CJK UNIFIED IDEOGRAPH-6C34 (水).

    // If this character does not exist, it defaults to em.

    mdHorCJKAdvanceSize = mdEmSize;

    mdVertCJKAdvanceSize = mdEmSize;

    hb_codepoint_t nIcGlyph;

    if (hb_font_get_glyph(pHbFont, 0x6C34, /*variation selector*/ 0, &nIcGlyph))

    {

        auto nIcHAdvance = hb_font_get_glyph_h_advance(pHbFont, nIcGlyph);

        mdHorCJKAdvanceSize = static_cast<double>(nIcHAdvance) * fScale;

        auto nIcVAdvance = hb_font_get_glyph_v_advance(pHbFont, nIcGlyph);

        mdVertCJKAdvanceSize = static_cast<double>(nIcVAdvance) * fScale;

    }

}

void FontMetricData::ImplInitBaselines(LogicalFontInstance *pFontInstance)

{

    hb_font_t* pHbFont = pFontInstance->GetHbFont();

    double fScale = 0;

    pFontInstance->GetScale(nullptr, &fScale);

    hb_position_t nBaseline = 0;

    if (hb_ot_layout_get_baseline(pHbFont,

             HB_OT_LAYOUT_BASELINE_TAG_HANGING,

                                HB_DIRECTION_INVALID,

                                HB_SCRIPT_UNKNOWN,

                                HB_TAG_NONE,

                                &nBaseline))

    {

        mnHangingBaseline = nBaseline * fScale;

    }

    else

    {

        mnHangingBaseline = 0;

    }

}

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */