"""Regenerates the BMFont sprite sheets in this folder from their .bmfc files.

Each Fonts\<Family>\ folder holds a <Family>-ttf.7z of its TrueType files and one .bmfc per face and size, such as
LiberationSans-Bold-16px.bmfc.  The faces of one size share a single page, <Family>-<size>_0.png, with each face's own
.fnt pointing into it, so mixed regular and bold text draws from one texture.  The .ttf files stay packed to keep the
tree small.  This unpacks them under Junk, runs BMFont there, lays each size's pages out as one and copies the results
back.

Usage:

    python MakeFonts.py                       every size except the frozen ones
    python MakeFonts.py LiberationSans        every size of one family
    python MakeFonts.py LiberationSans-16px   all the faces at one size, which always rebuild together
    python MakeFonts.py --check               regenerate into Junk only, and report which sizes would change
    python MakeFonts.py --fit                 first set each sheet's page size in its .bmfc to the smallest that fits
    python MakeFonts.py --check --fit         report any sheet whose page could be smaller, and change nothing
    python MakeFonts.py --unpack Philosopher  unpack the fonts and stop, to open a .bmfc in the BMFont window

A frozen size is rebuilt only when named.  Needs Pillow to lay out a size with more than one face.  See ..\BMFont\README
for the tool itself.
"""
import hashlib
import math
import os
import re
import shutil
import struct
import subprocess
import sys

FONTS = os.path.dirname(os.path.abspath(__file__))
BMFONT = os.path.join(FONTS, '..', 'BMFont', 'bmfont64.exe')
SEVEN_ZIP = os.path.join(FONTS, '..', '7-Zip', '7zr.exe')
JUNK = os.path.join(FONTS, '..', '..', 'Junk', 'Fonts')

# Sizes whose checked-in pixels must not change, because GDI on another machine would rasterize a few glyphs a pixel
# differently.  See Philosopher\README.
FROZEN = {'Philosopher-32px'}

STAMP = '.archive-sha256'

# A sheet takes a second or two, so this only catches a hang.
RUN_TIMEOUT_SECONDS = 120

# A page too small for its glyphs can make BMFont hang, so a fit that runs this long is a miss.
FIT_TIMEOUT_SECONDS = 15

# The sides a page can have.  Powers of two, so the page suits any texture hardware.
PAGE_SIDES = (32, 64, 128, 256, 512)

# The first face of a size sits at the top left of its page, and the others follow in name order.
FIRST_FACE = 'Regular'

SHEET_NAME = re.compile(r'^(?P<family>.+)-(?P<face>[A-Za-z]+)-(?P<size>\d+px)$')

BLOCK_COMMON = 2
BLOCK_PAGES = 3
BLOCK_CHARS = 4
CHAR_RECORD_BYTES = 20


def sha256Of(path):
    return hashlib.sha256(open(path, 'rb').read()).hexdigest()


def archiveOf(root, family):
    return os.path.join(root, family, family + '-ttf.7z')


def familiesIn(root):
    """The folders that hold a font archive, by name."""
    return sorted(name for name in os.listdir(root) if os.path.exists(archiveOf(root, name)))


def groupsOf(root, family):
    """Maps each size, such as Philosopher-18px, to the sheets that share its page, such as Philosopher-Regular-18px."""
    groups = {}

    for name in sorted(os.listdir(os.path.join(root, family))):
        if not name.endswith('.bmfc'):
            continue

        sheet = name[:-len('.bmfc')]
        match = SHEET_NAME.match(sheet)
        if not match or match.group('family') != family:
            raise SystemExit(name + ' is not named ' + family + '-<Face>-<size>px.bmfc')

        groups.setdefault(family + '-' + match.group('size'), []).append(sheet)

    for group, sheets in groups.items():
        sheets.sort(key=lambda sheet: (SHEET_NAME.match(sheet).group('face') != FIRST_FACE, sheet))

    return groups


def unpack(family):
    """Extracts the family's fonts under Junk, unless that's already done for this archive.  Returns the folder."""
    archive = archiveOf(FONTS, family)
    stage = os.path.join(JUNK, family)
    stamp = os.path.join(stage, STAMP)
    hashed = sha256Of(archive)

    if os.path.exists(stamp) and open(stamp).read() == hashed:
        return stage

    if os.path.exists(stage):
        shutil.rmtree(stage)

    os.makedirs(stage)
    subprocess.run([SEVEN_ZIP, 'x', '-y', '-o' + stage, archive], check=True, stdout=subprocess.DEVNULL)
    open(stamp, 'w').write(hashed)
    return stage


def blocksOf(data):
    """Yields each block of a binary .fnt as (type, body)."""
    if data[:4] != b'BMF\x03':
        raise SystemExit('Not a binary BMFont file')

    pos = 4
    while pos < len(data):
        size = struct.unpack_from('<i', data, pos + 1)[0]
        yield data[pos], data[pos + 5:pos + 5 + size]
        pos += 5 + size


def pageNamesIn(fntPath):
    """The page file names a binary .fnt records."""
    for blockType, body in blocksOf(open(fntPath, 'rb').read()):
        if blockType == BLOCK_PAGES:
            return [name.decode('utf-8') for name in body.split(b'\0') if name]

    return []


def codepointsIn(fntPath):
    """Every codepoint a binary .fnt has a glyph for."""
    returnMe = set()
    for blockType, body in blocksOf(open(fntPath, 'rb').read()):
        if blockType == BLOCK_CHARS:
            for offset in range(0, len(body), CHAR_RECORD_BYTES):
                returnMe.add(struct.unpack_from('<I', body, offset)[0])

    return returnMe


def codepointsAskedFor(bmfcText):
    """Every codepoint a .bmfc selects with chars= or imports with icon=."""
    returnMe = set(range(32, 127))
    for line in bmfcText.splitlines():
        if line.startswith('chars='):
            for part in line[len('chars='):].split(','):
                low, _, high = part.partition('-')
                returnMe.update(range(int(low), int(high or low) + 1))
        elif line.startswith('icon='):
            returnMe.add(int(line.split(',')[1]))

    return returnMe


def glyphGaps(bmfcPath, fntPath):
    """The codepoints a sheet's .bmfc asks for that its .fnt has no glyph for, such as ones its font lacks."""
    asked = codepointsAskedFor(open(bmfcPath, 'rb').read().decode('utf-8'))
    return sorted(asked - codepointsIn(fntPath))


def glyphCountIn(fntPath):
    return sum(len(body) // CHAR_RECORD_BYTES
               for blockType, body in blocksOf(open(fntPath, 'rb').read()) if blockType == BLOCK_CHARS)


def retarget(fntPath, pageName, left, top, pageSize):
    """The .fnt's bytes with its page renamed, the page's size changed, and every glyph moved by (left, top)."""
    returnMe = bytearray(b'BMF\x03')

    for blockType, body in blocksOf(open(fntPath, 'rb').read()):
        body = bytearray(body)

        if blockType == BLOCK_COMMON:
            struct.pack_into('<HH', body, 4, *pageSize)
        elif blockType == BLOCK_PAGES:
            body = bytearray(pageName.encode('utf-8') + b'\0')
        elif blockType == BLOCK_CHARS:
            for offset in range(0, len(body), CHAR_RECORD_BYTES):
                x, y = struct.unpack_from('<HH', body, offset + 4)
                if x + left > 0xFFFF or y + top > 0xFFFF:
                    raise SystemExit(fntPath + ' does not fit a page this big')

                struct.pack_into('<HH', body, offset + 4, x + left, y + top)

        returnMe += bytes([blockType]) + struct.pack('<i', len(body)) + body

    return bytes(returnMe)


def powerOfTwoAtLeast(value):
    returnMe = 1
    while returnMe < value:
        returnMe *= 2

    return returnMe


def gridFor(count, tileSize):
    """Picks how many columns to lay `count` equal tiles out in: the smallest page, and the squarest of those."""
    returnMe = None
    best = None

    for columns in range(1, count + 1):
        rows = math.ceil(count / columns)
        width = powerOfTwoAtLeast(columns * tileSize[0])
        height = powerOfTwoAtLeast(rows * tileSize[1])
        rank = (width * height, max(width, height) / min(width, height))

        if best is None or rank < best:
            returnMe = columns
            best = rank

    return returnMe


def layOutPages(pagePaths, outputPath):
    """Writes one page holding the given pages in a grid.  Returns each one's (left, top) and the page's size."""
    from PIL import Image

    pages = [Image.open(path).convert('RGBA') for path in pagePaths]
    tileSize = (max(page.width for page in pages), max(page.height for page in pages))
    columns = gridFor(len(pages), tileSize)
    rows = math.ceil(len(pages) / columns)
    size = (powerOfTwoAtLeast(columns * tileSize[0]), powerOfTwoAtLeast(rows * tileSize[1]))

    # A page's empty pixels are all zero, in every channel, so the padding is too.
    laidOut = Image.new('RGBA', size, (0, 0, 0, 0))
    corners = []

    for index, page in enumerate(pages):
        corner = ((index % columns) * tileSize[0], (index // columns) * tileSize[1])
        laidOut.paste(page, corner)
        corners.append(corner)

    laidOut.save(outputPath, optimize=True)
    return corners, size


def generate(family, sheet, pageSize=None, timeout=RUN_TIMEOUT_SECONDS):
    """Runs BMFont on one sheet in the family's Junk folder, at `pageSize` if given.  Returns the .fnt and its page."""
    source = os.path.join(FONTS, family)
    stage = unpack(family)
    stem = sheet if pageSize is None else sheet + '.fit'

    # BMFont records the -o path in the .fnt, so run beside the files and give it a bare name.
    for name in os.listdir(source):
        if name.endswith('-angle.png'):
            shutil.copy(os.path.join(source, name), os.path.join(stage, name))

    text = open(os.path.join(source, sheet + '.bmfc'), 'rb').read().decode('utf-8')
    if pageSize is not None:
        text = withPageSize(text, pageSize)

    open(os.path.join(stage, stem + '.bmfc'), 'wb').write(text.encode('utf-8'))

    outputs = [os.path.join(stage, stem + '.fnt'), os.path.join(stage, stem + '_0.png')]
    for output in outputs:
        if os.path.exists(output):
            os.remove(output)

    subprocess.run([BMFONT, '-c', stem + '.bmfc', '-o', stem + '.fnt'], cwd=stage, check=True,
                   stdout=subprocess.DEVNULL, timeout=timeout)

    for output in outputs:
        if not os.path.exists(output):
            raise RuntimeError('BMFont did not write ' + output)

    pages = pageNamesIn(outputs[0])
    if pages != [stem + '_0.png']:
        raise RuntimeError(stem + '.fnt names its pages ' + repr(pages) + ', which is not just ' + stem + '_0.png')

    return outputs


def pageSizeIn(text):
    return int(re.search(r'outWidth=(\d+)', text).group(1)), int(re.search(r'outHeight=(\d+)', text).group(1))


def withPageSize(text, pageSize):
    text = re.sub(r'outWidth=\d+', 'outWidth=%d' % pageSize[0], text)
    return re.sub(r'outHeight=\d+', 'outHeight=%d' % pageSize[1], text)


def candidatePages():
    """Every page size to try, smallest area first and squarest among equals."""
    sizes = [(width, height) for width in PAGE_SIDES for height in PAGE_SIDES]
    return sorted(sizes, key=lambda size: (size[0] * size[1], max(size) / min(size), size))


def smallestPage(family, sheet):
    """Finds the smallest page that holds every glyph of the sheet on one page."""
    wanted = glyphCountIn(generate(family, sheet)[0])

    for size in candidatePages():
        try:
            fnt, _ = generate(family, sheet, pageSize=size, timeout=FIT_TIMEOUT_SECONDS)
        except (RuntimeError, subprocess.SubprocessError):
            continue

        if glyphCountIn(fnt) == wanted:
            return size

    raise SystemExit(sheet + ' does not fit a page of any size tried')


def fit(family, sheet, check):
    """Sets the sheet's .bmfc to the smallest page that fits, or only reports it.  Returns whether it was too big."""
    path = os.path.join(FONTS, family, sheet + '.bmfc')
    raw = open(path, 'rb').read().decode('utf-8')
    current = pageSizeIn(raw)
    smallest = smallestPage(family, sheet)

    if smallest == current:
        print('fits     %s  %dx%d' % (sheet, *current))
        return False

    print('%s  %s  %dx%d -> %dx%d' % ('smaller  ' if check else 'fit      ', sheet, *current, *smallest))
    if not check:
        open(path, 'wb').write(withPageSize(raw, smallest).encode('utf-8'))

    return True


def build(family, group, sheets):
    """Generates the sheets of one size and joins them into one page.  Returns the built files, keyed by name."""
    stage = os.path.join(unpack(family), 'built')
    if os.path.exists(stage):
        shutil.rmtree(stage)

    os.makedirs(stage)
    generated = [generate(family, sheet) for sheet in sheets]
    pageName = group + '_0.png'
    pagePath = os.path.join(stage, pageName)

    if len(generated) == 1:
        shutil.copy(generated[0][1], pagePath)
        corners = [(0, 0)]
        pageSize = struct.unpack('>II', open(pagePath, 'rb').read()[16:24])
    else:
        corners, pageSize = layOutPages([page for _, page in generated], pagePath)

    returnMe = {pageName: pagePath}
    for sheet, (fnt, _), (left, top) in zip(sheets, generated, corners):
        path = os.path.join(stage, sheet + '.fnt')
        open(path, 'wb').write(retarget(fnt, pageName, left, top, pageSize))
        returnMe[sheet + '.fnt'] = path

    return returnMe


def sameFile(built, kept):
    """Whether the file is unchanged.  A page counts by its pixels, since the PNG encoding is the library's."""
    if not os.path.exists(kept):
        return False

    if open(built, 'rb').read() == open(kept, 'rb').read():
        return True

    if not built.endswith('.png'):
        return False

    from PIL import Image
    left = Image.open(built).convert('RGBA')
    right = Image.open(kept).convert('RGBA')
    return left.size == right.size and left.tobytes() == right.tobytes()


def selected(names, family, group, sheets):
    return not names or family in names or group in names or any(sheet in names for sheet in sheets)


def run(names, check, fitFirst):
    returnMe = 0

    for family in familiesIn(FONTS):
        for group, sheets in groupsOf(FONTS, family).items():
            if not selected(names, family, group, sheets):
                continue

            if group in FROZEN and group not in names and not any(sheet in names for sheet in sheets):
                print('frozen   ' + group)
                continue

            if fitFirst:
                tooBig = [fit(family, sheet, check) for sheet in sheets]
                if check:
                    returnMe = returnMe or int(any(tooBig))
                    continue

            built = build(family, group, sheets)
            for sheet in sheets:
                gaps = glyphGaps(os.path.join(FONTS, family, sheet + '.bmfc'), built[sheet + '.fnt'])
                if gaps:
                    print('MISSING  ' + sheet + '  no glyph for ' + ' '.join('U+%04X' % codepoint for codepoint in gaps))
                    returnMe = 1

            kept = {name: os.path.join(FONTS, family, name) for name in built}
            changed = [name for name in built if not sameFile(built[name], kept[name])]

            if check:
                print(('same     ' if not changed else 'differs  ') + group + '  ' + ' '.join(changed))
                returnMe = returnMe or int(bool(changed))
                continue

            for name in changed:
                shutil.copy(built[name], kept[name])

            print(('rebuilt  ' if changed else 'same     ') + group + '  ' + ' '.join(changed))

    return returnMe


def main(arguments):
    check = '--check' in arguments
    fitFirst = '--fit' in arguments
    unpackOnly = '--unpack' in arguments
    names = [argument for argument in arguments if not argument.startswith('--')]
    families = familiesIn(FONTS)
    known = set(families)

    for family in families:
        for group, sheets in groupsOf(FONTS, family).items():
            known.add(group)
            known.update(sheets)

    for name in names:
        if name not in known:
            raise SystemExit('No family, size or sheet named ' + name + '.  Families: ' + ', '.join(families))

    if unpackOnly:
        for family in [name for name in names if name in families] or families:
            print(unpack(family))
        return 0

    try:
        return run(names, check, fitFirst)
    except RuntimeError as problem:
        raise SystemExit(str(problem))


if __name__ == '__main__':
    sys.exit(main(sys.argv[1:]))