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

 * 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/. */

#ifndef GFX_FONT_FAMILY_LIST_H

#define GFX_FONT_FAMILY_LIST_H

#include "nsAtom.h"

#include "nsDebug.h"

#include "nsISupportsImpl.h"

#include "nsString.h"

#include "nsUnicharUtils.h"

#include "nsTArray.h"

#include "mozilla/MemoryReporting.h"

#include "mozilla/NotNull.h"

#include "mozilla/StaticPtr.h"

namespace mozilla {

/**

 * type of font family name, either a name (e.g. Helvetica) or a

 * generic (e.g. serif, sans-serif), with the ability to distinguish

 * between unquoted and quoted names for serializaiton

 */ 

enum FontFamilyType : uint8_t {

  eFamily_none = 0,  // used when finding generics

  // explicitly named font family (e.g. Helvetica)

  eFamily_named,

  eFamily_named_quoted,

  // generics

  eFamily_serif,         // pref font code relies on this ordering!!!

  eFamily_sans_serif,

  eFamily_monospace,

  eFamily_cursive,

  eFamily_fantasy,

  // special

  eFamily_moz_variable,

  eFamily_moz_fixed,

  eFamily_moz_emoji,

  eFamily_generic_first = eFamily_serif,

  eFamily_generic_last = eFamily_fantasy,

  eFamily_generic_count = (eFamily_fantasy - eFamily_serif + 1)

};

enum QuotedName { eQuotedName, eUnquotedName };

/**

 * font family name, an Atom for the name if not a generic and

 * a font type indicated named family or which generic family

 */

struct FontFamilyName final {

    FontFamilyName()

        : mType(eFamily_named)

    {}

    // named font family - e.g. Helvetica

    explicit FontFamilyName(nsAtom* aFamilyName,

                            QuotedName aQuoted = eUnquotedName) {

        mType = (aQuoted == eQuotedName) ? eFamily_named_quoted : eFamily_named;

        mName = aFamilyName;

    }

    explicit FontFamilyName(const nsACString& aFamilyName,

                            QuotedName aQuoted = eUnquotedName) {

        mType = (aQuoted == eQuotedName) ? eFamily_named_quoted : eFamily_named;

        mName = NS_Atomize(aFamilyName);

    }

    // generic font family - e.g. sans-serif

    explicit FontFamilyName(FontFamilyType aType) {

        NS_ASSERTION(aType != eFamily_named &&

                     aType != eFamily_named_quoted &&

                     aType != eFamily_none,

                     "expected a generic font type");

        mName = nullptr;

        mType = aType;

    }

    FontFamilyName(const FontFamilyName& aCopy) {

        mType = aCopy.mType;

        mName = aCopy.mName;

    }

    bool IsNamed() const {

        return mType == eFamily_named || mType == eFamily_named_quoted;

    }

    bool IsGeneric() const {

        return !IsNamed();

    }

    void AppendToString(nsACString& aFamilyList, bool aQuotes = true) const {

        switch (mType) {

            case eFamily_named:

                aFamilyList.Append(nsAtomCString(mName));

                break;

            case eFamily_named_quoted:

                if (aQuotes) {

                    aFamilyList.Append('"');

                }

                aFamilyList.Append(nsAtomCString(mName));

                if (aQuotes) {

                    aFamilyList.Append('"');

                }

                break;

            case eFamily_serif:

                aFamilyList.AppendLiteral("serif");

                break;

            case eFamily_sans_serif:

                aFamilyList.AppendLiteral("sans-serif");

                break;

            case eFamily_monospace:

                aFamilyList.AppendLiteral("monospace");

                break;

            case eFamily_cursive:

                aFamilyList.AppendLiteral("cursive");

                break;

            case eFamily_fantasy:

                aFamilyList.AppendLiteral("fantasy");

                break;

            case eFamily_moz_fixed:

                aFamilyList.AppendLiteral("-moz-fixed");

                break;

            default:

                break;

        }

    }

    // helper method that converts generic names to the right enum value

    static FontFamilyName

    Convert(const nsACString& aFamilyOrGenericName) {

        // should only be passed a single font - not entirely correct, a family

        // *could* have a comma in it but in practice never does so

        // for debug purposes this is fine

        NS_ASSERTION(aFamilyOrGenericName.FindChar(',') == -1,

                     "Convert method should only be passed a single family name");

        FontFamilyType genericType = eFamily_none;

        if (aFamilyOrGenericName.LowerCaseEqualsLiteral("serif")) {

            genericType = eFamily_serif;

        } else if (aFamilyOrGenericName.LowerCaseEqualsLiteral("sans-serif")) {

            genericType = eFamily_sans_serif;

        } else if (aFamilyOrGenericName.LowerCaseEqualsLiteral("monospace")) {

            genericType = eFamily_monospace;

        } else if (aFamilyOrGenericName.LowerCaseEqualsLiteral("cursive")) {

            genericType = eFamily_cursive;

        } else if (aFamilyOrGenericName.LowerCaseEqualsLiteral("fantasy")) {

            genericType = eFamily_fantasy;

        } else if (aFamilyOrGenericName.LowerCaseEqualsLiteral("-moz-fixed")) {

            genericType = eFamily_moz_fixed;

        } else {

            return FontFamilyName(aFamilyOrGenericName, eUnquotedName);

        }

        return FontFamilyName(genericType);

    }

    FontFamilyType mType;

    RefPtr<nsAtom> mName; // null if mType != eFamily_named

};

inline bool

operator==(const FontFamilyName& a, const FontFamilyName& b) {

    return a.mType == b.mType && a.mName == b.mName;

}

/**

 * A refcounted array of FontFamilyNames.  We use this to store the specified

 * value (in Servo) and the computed value (in both Gecko and Servo) of the

 * font-family property.

 */

class SharedFontList

{

public:

    NS_INLINE_DECL_THREADSAFE_REFCOUNTING(SharedFontList);

    SharedFontList()

    {

    }

    explicit SharedFontList(FontFamilyType aGenericType)

        : mNames { FontFamilyName(aGenericType) }

    {

    }

    SharedFontList(nsAtom* aFamilyName, QuotedName aQuoted)

        : mNames { FontFamilyName(aFamilyName, aQuoted) }

    {

    }

    SharedFontList(const nsACString& aFamilyName, QuotedName aQuoted)

        : mNames { FontFamilyName(aFamilyName, aQuoted) }

    {

    }

    explicit SharedFontList(const FontFamilyName& aName)

        : mNames { aName }

    {

    }

    explicit SharedFontList(nsTArray<FontFamilyName>&& aNames)

        : mNames(std::move(aNames))

    {

    }

    FontFamilyType FirstGeneric() const

    {

        for (const FontFamilyName& name : mNames) {

            if (name.IsGeneric()) {

                return name.mType;

            }

        }

        return eFamily_none;

    }

    bool HasGeneric() const

    {

        return FirstGeneric() != eFamily_none;

    }

    size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const

    {

      size_t n = 0;

      n += aMallocSizeOf(this);

      n += mNames.ShallowSizeOfExcludingThis(aMallocSizeOf);

      return n;

    }

    size_t SizeOfIncludingThisIfUnshared(MallocSizeOf aMallocSizeOf) const

    {

        size_t n = 0;

        if (mRefCnt.get() == 1) {

          n += SizeOfIncludingThis(aMallocSizeOf);

        }

        return n;

    }

    const nsTArray<FontFamilyName> mNames;

    static void Initialize();

    static void Shutdown();

    static StaticRefPtr<SharedFontList> sEmpty;

private:

    ~SharedFontList() = default;

};

/**

 * font family list, array of font families and a default font type.

 * font family names are either named strings or generics. the default

 * font type is used to preserve the variable font fallback behavior

 */

class FontFamilyList {

public:

    FontFamilyList()

        : mFontlist(WrapNotNull(SharedFontList::sEmpty.get()))

        , mDefaultFontType(eFamily_none)

    {

    }

    explicit FontFamilyList(FontFamilyType aGenericType)

        : mFontlist(MakeNotNull<SharedFontList*>(aGenericType))

        , mDefaultFontType(eFamily_none)

    {

    }

    FontFamilyList(nsAtom* aFamilyName,

                   QuotedName aQuoted)

        : mFontlist(MakeNotNull<SharedFontList*>(aFamilyName, aQuoted))

        , mDefaultFontType(eFamily_none)

    {

    }

    FontFamilyList(const nsACString& aFamilyName,

                   QuotedName aQuoted)

        : mFontlist(MakeNotNull<SharedFontList*>(aFamilyName, aQuoted))

        , mDefaultFontType(eFamily_none)

    {

    }

    explicit FontFamilyList(const FontFamilyName& aName)

        : mFontlist(MakeNotNull<SharedFontList*>(aName))

        , mDefaultFontType(eFamily_none)

    {

    }

    explicit FontFamilyList(nsTArray<FontFamilyName>&& aNames)

        : mFontlist(MakeNotNull<SharedFontList*>(std::move(aNames)))

        , mDefaultFontType(eFamily_none)

    {

    }

    FontFamilyList(const FontFamilyList& aOther)

        : mFontlist(aOther.mFontlist)

        , mDefaultFontType(aOther.mDefaultFontType)

    {

    }

    explicit FontFamilyList(NotNull<SharedFontList*> aFontList)

        : mFontlist(aFontList)

        , mDefaultFontType(eFamily_none)

    {

    }

    void SetFontlist(nsTArray<FontFamilyName>&& aNames)

    {

        mFontlist = MakeNotNull<SharedFontList*>(std::move(aNames));

    }

    void SetFontlist(NotNull<SharedFontList*> aFontlist)

    {

        mFontlist = aFontlist;

    }

    uint32_t Length() const {

        return mFontlist->mNames.Length();

    }

    bool IsEmpty() const {

        return mFontlist->mNames.IsEmpty();

    }

    NotNull<SharedFontList*> GetFontlist() const {

        return mFontlist;

    }

    bool Equals(const FontFamilyList& aFontlist) const {

        return (mFontlist == aFontlist.mFontlist ||

                mFontlist->mNames == aFontlist.mFontlist->mNames) &&

               mDefaultFontType == aFontlist.mDefaultFontType;

    }

    FontFamilyType FirstGeneric() const {

        return mFontlist->FirstGeneric();

    }

    bool HasGeneric() const

    {

        return mFontlist->HasGeneric();

    }

    bool HasDefaultGeneric() const {

        for (const FontFamilyName& name : mFontlist->mNames) {

            if (name.mType == mDefaultFontType) {

                return true;

            }

        }

        return false;

    }

    // Find the first generic (but ignoring cursive and fantasy, as they are

    // rarely configured in any useful way) in the list.

    // If found, move it to the start and return true; else return false.

    bool PrioritizeFirstGeneric() {

        uint32_t len = mFontlist->mNames.Length();

        for (uint32_t i = 0; i < len; i++) {

            const FontFamilyName name = mFontlist->mNames[i];

            if (name.IsGeneric()) {

                if (name.mType == eFamily_cursive ||

                    name.mType == eFamily_fantasy) {

                    continue;

                }

                if (i > 0) {

                    nsTArray<FontFamilyName> names;

                    names.AppendElements(mFontlist->mNames);

                    names.RemoveElementAt(i);

                    names.InsertElementAt(0, name);

                    SetFontlist(std::move(names));

                }

                return true;

            }

        }

        return false;

    }

    void PrependGeneric(FontFamilyType aType) {

        nsTArray<FontFamilyName> names;

        names.AppendElements(mFontlist->mNames);

        names.InsertElementAt(0, FontFamilyName(aType));

        SetFontlist(std::move(names));

    }

    void ToString(nsACString& aFamilyList,

                  bool aQuotes = true,

                  bool aIncludeDefault = false) const {

        const nsTArray<FontFamilyName>& names = mFontlist->mNames;

        aFamilyList.Truncate();

        uint32_t len = names.Length();

        for (uint32_t i = 0; i < len; i++) {

            if (i != 0) {

                aFamilyList.Append(',');

            }

            const FontFamilyName& name = names[i];

            name.AppendToString(aFamilyList, aQuotes);

        }

        if (aIncludeDefault && mDefaultFontType != eFamily_none) {

            if (!aFamilyList.IsEmpty()) {

                aFamilyList.Append(',');

            }

            if (mDefaultFontType == eFamily_serif) {

                aFamilyList.AppendLiteral("serif");

            } else {

                aFamilyList.AppendLiteral("sans-serif");

            }

        }

    }

    // searches for a specific non-generic name, lowercase comparison

    bool Contains(const nsACString& aFamilyName) const {

        NS_ConvertUTF8toUTF16 fam(aFamilyName);

        ToLowerCase(fam);

        for (const FontFamilyName& name : mFontlist->mNames) {

            if (!name.IsNamed()) {

                continue;

            }

            nsAtomString listname(name.mName);

            ToLowerCase(listname);

            if (listname.Equals(fam)) {

                return true;

            }

        }

        return false;

    }

    FontFamilyType GetDefaultFontType() const { return mDefaultFontType; }

    void SetDefaultFontType(FontFamilyType aType) {

        NS_ASSERTION(aType == eFamily_none || aType == eFamily_serif ||

                     aType == eFamily_sans_serif,

                     "default font type must be either serif or sans-serif");

        mDefaultFontType = aType;

    }

    // memory reporting

    size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {

        size_t n = 0;

        n += mFontlist->SizeOfIncludingThisIfUnshared(aMallocSizeOf);

        return n;

    }

    size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {

        return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);

    }

protected:

    NotNull<RefPtr<SharedFontList>> mFontlist;

    FontFamilyType             mDefaultFontType; // none, serif or sans-serif

};

inline bool

operator==(const FontFamilyList& a, const FontFamilyList& b) {

    return a.Equals(b);

}

inline bool

operator!=(const FontFamilyList& a, const FontFamilyList& b) {

    return !a.Equals(b);

}

} // namespace mozilla

#endif /* GFX_FONT_FAMILY_LIST_H */