"""
Query system Windows fonts with pure Python.

Public domain work by anatoly techtonik <techtonik@gmail.com>
Use MIT License if public domain doesn't make sense for you.



The task: Get monospace font for an application in the order of
preference.

A problem: Font ID in Windows is its name. Windows doesn't provide
any information about filenames they contained in. From two different
files with the same font name you can get only one.

Windows also doesn't have a clear concept of _generic font family_
familiar from CSS specification. Here is how fontquery maps Windows
LOGFONT properties to generic CSS font families:

  serif      -   (LOGFONT.lfPitchAndFamily >> 4) == FF_ROMAN
  sans-serif -   (LOGFONT.lfPitchAndFamily >> 4) == FF_SWISS
  cursive    -   (LOGFONT.lfPitchAndFamily >> 4) == FF_SCRIPT
  fantasy    -   (LOGFONT.lfPitchAndFamily >> 4) == FF_DECORATIVE
  monospace  -   (lf.lfPitchAndFamily & 0b11) == FIXED_PITCH

NOTE: ATM, May 2015, the Microsoft documentation related to monospace
is misleading due to poor wording:
 - FF_MODERN in the description of LOGFONT structure tells
   "Fonts with constant stroke width (monospace), with or without serifs.
    Monospace fonts are usually modern.
    Pica, Elite, and CourierNew are examples.
   "
   
   Stroke width is the 'pen width', not glyph width. It should read

   "Fonts with constant stroke width, with or without serifs.
    Monospace fonts are usually modern, but not all modern are monospace
   "

PYGLET NOTE:
Examination of all fonts in a windows xp machine shows that all fonts
with

  fontentry.vector and fontentry.family != FF_DONTCARE

are rendered fine.


Use cases:
 [x] get the list of all available system font names
 [ ] get the list of all fonts for generic family
 [ ] get the list of all fonts for specific charset
 [ ] check if specific font is available

Considerations:
 - performance of querying all system fonts is not measured
 - Windows doesn't allow to get filenames of the fonts, so if there
   are two fonts with the same name, one will be missing

MSDN:

    If you request a font named Palatino, but no such font is available
on the system, the font mapper will substitute a font that has similar
attributes but a different name.

   [ ] check if font chosen by the system has required family

    To get the appropriate font, call EnumFontFamiliesEx with the
desired font characteristics in the LOGFONT structure, then retrieve the
appropriate typeface name and create the font using CreateFont or
CreateFontIndirect.

"""
from pyglet.libs.win32.context_managers import device_context

DEBUG = False

__all__ = ['have_font', 'font_list']

__version__ = '0.3'
__url__ = 'https://bitbucket.org/techtonik/fontquery'


# -- INTRO: MAINTAIN CACHED FONTS DB --

# [ ] make it Django/NDB style model definition
class FontEntry:
    """
    Font classification.
    Level 0:
    - name
    - vector (True if font is vector, False for raster fonts)
    - format: ttf | ...
    """

    def __init__(self, name, vector, format, monospace, family):
        self.name = name
        self.vector = vector
        self.format = format
        self.monospace = monospace
        self.family = family


# List of FontEntry objects
FONTDB = []

# -- CHAPTER 1: GET ALL SYSTEM FONTS USING EnumFontFamiliesEx FROM GDI --

"""
Q: Why GDI? Why not GDI+? 
A: Wikipedia:

    Because of the additional text processing and resolution independence
capabilities in GDI+, text rendering is performed by the CPU [2] and it
is nearly an order of magnitude slower than in hardware accelerated GDI.[3]
Chris Jackson published some tests indicating that a piece of text
rendering code he had written could render 99,000 glyphs per second in GDI,
but the same code using GDI+ rendered 16,600 glyphs per second.
"""

import ctypes
from ctypes import wintypes
from pyglet.libs.win32 import LOGFONT, LOGFONTW

user32 = ctypes.windll.user32
gdi32 = ctypes.windll.gdi32

# --- define necessary data structures from wingdi.h

# for calling ANSI functions of Windows API (end with A) TCHAR is
# defined as single char, for Unicode ones (end witn W) it is WCHAR
CHAR = ctypes.c_char  # Python 2.7 compatibility
TCHAR = CHAR
BYTE = ctypes.c_ubyte  # http://bugs.python.org/issue16376

# charset codes for LOGFONT structure
ANSI_CHARSET = 0
ARABIC_CHARSET = 178
BALTIC_CHARSET = 186
CHINESEBIG5_CHARSET = 136
DEFAULT_CHARSET = 1
# - charset for current system locale -
#   means function can be called several times
#   for the single font (for each charset)
EASTEUROPE_CHARSET = 238
GB2312_CHARSET = 134
GREEK_CHARSET = 161
HANGUL_CHARSET = 129
HEBREW_CHARSET = 177
JOHAB_CHARSET = 130
MAC_CHARSET = 77
OEM_CHARSET = 255  # OS dependent system charset
RUSSIAN_CHARSET = 204
SHIFTJIS_CHARSET = 128
SYMBOL_CHARSET = 2
THAI_CHARSET = 222
TURKISH_CHARSET = 162
VIETNAMESE_CHARSET = 163

# build lookup dictionary to get charset name from its code
CHARSET_NAMES = {}
for (name, value) in locals().copy().items():
    if name.endswith('_CHARSET'):
        CHARSET_NAMES[value] = name

# font pitch constants ('fixed pitch' means 'monospace')
DEFAULT_PITCH = 0
FIXED_PITCH = 1
VARIABLE_PITCH = 2

# Windows font family constants
FF_DONTCARE = 0  # Don't care or don't know
FF_ROMAN = 1  # with serifs, proportional
FF_SWISS = 2  # w/out serifs, proportional
FF_MODERN = 3  # constant stroke width
FF_SCRIPT = 4  # handwritten
FF_DECORATIVE = 5  # novelty


class FONTSIGNATURE(ctypes.Structure):
    # supported code pages and Unicode subranges for the font
    # needed for NEWTEXTMETRICEX structure
    _fields_ = [
        ('sUsb', wintypes.DWORD * 4),  # 128-bit Unicode subset bitfield (USB)
        ('sCsb', wintypes.DWORD * 2)]  # 64-bit, code-page bitfield (CPB)


class NEWTEXTMETRIC(ctypes.Structure):
    # physical font attributes for True Type fonts
    # needed for NEWTEXTMETRICEX structure
    _fields_ = [
        ('tmHeight', wintypes.LONG),
        ('tmAscent', wintypes.LONG),
        ('tmDescent', wintypes.LONG),
        ('tmInternalLeading', wintypes.LONG),
        ('tmExternalLeading', wintypes.LONG),
        ('tmAveCharWidth', wintypes.LONG),
        ('tmMaxCharWidth', wintypes.LONG),
        ('tmWeight', wintypes.LONG),
        ('tmOverhang', wintypes.LONG),
        ('tmDigitizedAspectX', wintypes.LONG),
        ('tmDigitizedAspectY', wintypes.LONG),
        ('mFirstChar', TCHAR),
        ('mLastChar', TCHAR),
        ('mDefaultChar', TCHAR),
        ('mBreakChar', TCHAR),
        ('tmItalic', BYTE),
        ('tmUnderlined', BYTE),
        ('tmStruckOut', BYTE),
        ('tmPitchAndFamily', BYTE),
        ('tmCharSet', BYTE),
        ('tmFlags', wintypes.DWORD),
        ('ntmSizeEM', wintypes.UINT),
        ('ntmCellHeight', wintypes.UINT),
        ('ntmAvgWidth', wintypes.UINT)]

class NEWTEXTMETRICW(ctypes.Structure):
    _fields_ = [
        ('tmHeight', wintypes.LONG),
        ('tmAscent', wintypes.LONG),
        ('tmDescent', wintypes.LONG),
        ('tmInternalLeading', wintypes.LONG),
        ('tmExternalLeading', wintypes.LONG),
        ('tmAveCharWidth', wintypes.LONG),
        ('tmMaxCharWidth', wintypes.LONG),
        ('tmWeight', wintypes.LONG),
        ('tmOverhang', wintypes.LONG),
        ('tmDigitizedAspectX', wintypes.LONG),
        ('tmDigitizedAspectY', wintypes.LONG),
        ('mFirstChar', wintypes.WCHAR),
        ('mLastChar', wintypes.WCHAR),
        ('mDefaultChar', wintypes.WCHAR),
        ('mBreakChar', wintypes.WCHAR),
        ('tmItalic', BYTE),
        ('tmUnderlined', BYTE),
        ('tmStruckOut', BYTE),
        ('tmPitchAndFamily', BYTE),
        ('tmCharSet', BYTE),
        ('tmFlags', wintypes.DWORD),
        ('ntmSizeEM', wintypes.UINT),
        ('ntmCellHeight', wintypes.UINT),
        ('ntmAvgWidth', wintypes.UINT)]

class NEWTEXTMETRICEX(ctypes.Structure):
    # physical font attributes for True Type fonts
    # needed for FONTENUMPROC callback function
    _fields_ = [
        ('ntmTm', NEWTEXTMETRIC),
        ('ntmFontSig', FONTSIGNATURE)]

class NEWTEXTMETRICEXW(ctypes.Structure):
    _fields_ = [
        ('ntmTm', NEWTEXTMETRICW),
        ('ntmFontSig', FONTSIGNATURE)]

# type for a function that is called by the system for
# each font during execution of EnumFontFamiliesEx
FONTENUMPROC = ctypes.WINFUNCTYPE(
    ctypes.c_int,  # return non-0 to continue enumeration, 0 to stop
    ctypes.POINTER(LOGFONT),
    ctypes.POINTER(NEWTEXTMETRICEX),
    wintypes.DWORD,  # font type, a combination of
    #   DEVICE_FONTTYPE
    #   RASTER_FONTTYPE
    #   TRUETYPE_FONTTYPE
    wintypes.LPARAM
)

FONTENUMPROCW = ctypes.WINFUNCTYPE(
    ctypes.c_int,  # return non-0 to continue enumeration, 0 to stop
    ctypes.POINTER(LOGFONTW),
    ctypes.POINTER(NEWTEXTMETRICEXW),
    wintypes.DWORD,
    wintypes.LPARAM
)


# When running 64 bit windows, some types are not 32 bit, so Python/ctypes guesses wrong
gdi32.EnumFontFamiliesExA.argtypes = [
    wintypes.HDC,
    ctypes.POINTER(LOGFONT),
    FONTENUMPROC,
    wintypes.LPARAM,
    wintypes.DWORD]


gdi32.EnumFontFamiliesExW.argtypes = [
    wintypes.HDC,
    ctypes.POINTER(LOGFONTW),
    FONTENUMPROCW,
    wintypes.LPARAM,
    wintypes.DWORD]

def _enum_font_names(logfont, textmetricex, fonttype, param):
    """callback function to be executed during EnumFontFamiliesEx
       call for each font name. it stores names in global variable
    """
    global FONTDB

    lf = logfont.contents
    name = lf.lfFaceName

    # detect font type (vector|raster) and format (ttf)
    # [ ] use Windows constant TRUETYPE_FONTTYPE
    if fonttype & 4:
        vector = True
        fmt = 'ttf'
    else:
        vector = False
        # [ ] research Windows raster format structure
        fmt = 'unknown'

    pitch = lf.lfPitchAndFamily & 0b11
    family = lf.lfPitchAndFamily >> 4

    # [ ] check FIXED_PITCH, VARIABLE_PITCH and FF_MODERN
    #     combination
    #
    # FP T NM     400 CHARSET:   0  DFKai-SB
    # FP T NM     400 CHARSET: 136  DFKai-SB
    # FP T NM     400 CHARSET:   0  @DFKai-SB
    # FP T NM     400 CHARSET: 136  @DFKai-SB
    # VP T M      400 CHARSET:   0  OCR A Extended

    monospace = (pitch == FIXED_PITCH)

    charset = lf.lfCharSet

    FONTDB.append(FontEntry(name, vector, fmt, monospace, family))

    if DEBUG:
        info = ''

        if pitch == FIXED_PITCH:
            info += 'FP '
        elif pitch == VARIABLE_PITCH:
            info += 'VP '
        else:
            info += '   '

        # [ ] check exact fonttype values meaning
        info += '%s ' % {0: 'U', 1: 'R', 4: 'T'}[fonttype]

        if monospace:
            info += 'M  '
        else:
            info += 'NM '

        style = [' '] * 3
        if lf.lfItalic:
            style[0] = 'I'
        if lf.lfUnderline:
            style[1] = 'U'
        if lf.lfStrikeOut:
            style[2] = 'S'
        info += ''.join(style)

        info += ' %s' % lf.lfWeight

        # if pitch == FIXED_PITCH:
        if 1:
            # print('%s CHARSET: %3s  %s' % (info, lf.lfCharSet, lf.lfFaceName))
            print(f'{info} CHARSET: {lf.lfCharSet}  {lf.lfFaceName}')

    return 1  # non-0 to continue enumeration


enum_font_names = FONTENUMPROCW(_enum_font_names)


# --- /define


# --- prepare and call EnumFontFamiliesEx

def query(charset=DEFAULT_CHARSET):
    """
    Prepare and call EnumFontFamiliesEx.

    query()
      - return tuple with sorted list of all available system fonts
    query(charset=ANSI_CHARSET)
      - return tuple sorted list of system fonts supporting ANSI charset

    """
    global FONTDB

    # 1. Get device context of the entire screen
    with device_context(None) as hdc:

        # 2. Call EnumFontFamiliesExA (ANSI version)

        # 2a. Call with empty font name to query all available fonts
        #     (or fonts for the specified charset)
        #
        # NOTES:
        #
        #  * there are fonts that don't support ANSI charset
        #  * for DEFAULT_CHARSET font is passed to callback function as
        #    many times as charsets it supports

        # [ ] font name should be less than 32 symbols with terminating \0
        # [ ] check double purpose - enumerate all available font names
        #      - enumerate all available charsets for a single font
        #      - other params?

        logfont = LOGFONTW(0, 0, 0, 0, 0, 0, 0, 0, charset, 0, 0, 0, 0, '')
        FONTDB = []  # clear cached FONTDB for enum_font_names callback
        res = gdi32.EnumFontFamiliesExW(
            hdc,  # handle to device context
            ctypes.byref(logfont),
            enum_font_names,  # pointer to callback function
            0,  # lParam  - application-supplied data
            0)  # dwFlags - reserved = 0
        # res here is the last value returned by callback function

    return FONTDB


# --- Public API ---

def have_font(name, refresh=False):
    """
    Return True if font with specified `name` is present. The result
    of querying system font names is cached. Set `refresh` parameter
    to True to purge cache and reload font information.
    """
    if not FONTDB or refresh:
        query()
    if any(f.name == name for f in FONTDB):
        return True
    else:
        return False


def font_list(vector_only=False, monospace_only=False):
    """Return list of system installed font names."""

    if not FONTDB:
        query()

    fonts = FONTDB
    if vector_only:
        fonts = [f for f in fonts if f.vector]
    if monospace_only:
        fonts = [f for f in fonts if f.monospace]

    return sorted([f.name for f in fonts])


# TODO: move this into tests/
if __name__ == '__main__':
    import sys

    if sys.argv[1:] == ['debug']:
        DEBUG = True

    if sys.argv[1:] == ['test'] or DEBUG:
        print('Running tests..')
        # test have_font (Windows)
        test_arial = have_font('Arial')
        print('Have font "Arial"? %s' % test_arial)
        print('Have font "missing-one"? %s' % have_font('missing-one'))
        # test cache is not rebuilt
        FONTDB = [FontEntry('stub', False, '', False, FF_MODERN)]
        assert (have_font('Arial') != test_arial)
        # test cache is rebiult
        assert (have_font('Arial', refresh=True) == test_arial)
        if not DEBUG:
            sys.exit()

    if sys.argv[1:] == ['vector']:
        fonts = font_list(vector_only=True)
    elif sys.argv[1:] == ['mono']:
        fonts = font_list(monospace_only=True)
    elif sys.argv[1:] == ['vector', 'mono']:
        fonts = font_list(vector_only=True, monospace_only=True)
    else:
        fonts = font_list()
    print('\n'.join(fonts))

    if DEBUG:
        print(f"Total: {len(font_list())}")


# -- CHAPTER 2: WORK WITH FONT DIMENSIONS --
#
# Essential info about font metrics http://support.microsoft.com/kb/32667
# And about logical units at http://www.winprog.org/tutorial/fonts.html

# x. Convert desired font size from points into logical units (pixels)

# By default logical for the screen units are pixels. This is defined
# by default MM_TEXT mapping mode.

# Point is ancient unit of measurement for physical size of a font.
# 10pt is equal to 3.527mm. To make sure a char on screen has physical
# size equal to 3.527mm, we need to know display size to calculate how
# many pixels are in 3.527mm, and then fetch font that best matches
# this size.

# Essential info about conversion http://support.microsoft.com/kb/74299

# x.1 Get pixels per inch using GetDeviceCaps() or ...


# -- CHAPTER 3: LAYERED FONT API --
#
# y. Font object with several layers of info

# Font object should contains normalized font information. This
# information is split according to usage. For example, level 0 property
# is font id - its name. Level 1 can be information about loaded font
# characters - in pyglet it could be cached/used glyphs and video memory
# taken by those glyphs.

# [ ] (pyglet) investigate if it is possible to get video memory size
#              occupied by the font glyphs

# [ ] (pyglet) investigate if it is possible to unload font from video
#              memory if its unused
