#!/usr/bin/env python3
"""Troca a fonte embutida no Main.swf do Alien Egg Farm.

O Flixel 2.35 embute a "Nokia Cellphone FC" (zeh, fatorcaos.com.br), uma fonte freeware sem licenca de
redistribuicao. Este script reescreve a tag DefineFont3 do SWF com os contornos da Silkscreen (OFL 1.1,
google/fonts), mantendo o mesmo conjunto de caracteres e a mesma metrica vertical (avanco proporcional: borda da
tinta mais um pixel, com a margem esquerda tirada; espaco e sem tinta ficam como antes), de modo que o texto ocupe quase o mesmo espaco. Tira tambem a DefineFontAlignZones (zonas da fonte antiga) e reescreve a
DefineFontName (nome e copyright). O resto do SWF nao muda.

Uso (fontTools necessario, ex.: o venv do projeto):
    python3 -I patch-font.py <Main.swf> <Silkscreen-Regular.ttf> <saida.swf>
"""
import struct
import sys
import zlib

from fontTools.pens.recordingPen import DecomposingRecordingPen
from fontTools.ttLib import TTFont


class Bits:
    def __init__(self):
        self.bits = []

    def u(self, n, v):
        assert 0 <= v < (1 << n) or n == 0, (n, v)
        for i in range(n - 1, -1, -1):
            self.bits.append((v >> i) & 1)

    def s(self, n, v):
        self.u(n, v & ((1 << n) - 1) if n else 0)

    def data(self):
        b = self.bits + [0] * (-len(self.bits) % 8)
        return bytes(int("".join(map(str, b[i:i + 8])), 2) for i in range(0, len(b), 8))


def nbits_signed(*vals):
    n = 1
    for v in vals:
        while not (-(1 << (n - 1)) <= v < (1 << (n - 1))):
            n += 1
    return n


def glyph_shape(contours):
    """contours: listas de pontos (x, y) em unidades SWF (y para baixo); cada uma e um poligono fechado."""
    w = Bits()
    w.u(4, 1)  # NumFillBits
    w.u(4, 0)  # NumLineBits
    cx = cy = 0
    for pts in contours:
        # StyleChangeRecord: sem estilos novos, FillStyle1 = 1, MoveTo
        w.u(1, 0); w.u(1, 0); w.u(1, 0); w.u(1, 1); w.u(1, 0); w.u(1, 1)
        x0, y0 = pts[0]
        nb = nbits_signed(x0, y0)
        w.u(5, nb); w.s(nb, x0); w.s(nb, y0)
        w.u(1, 1)  # FillStyle1 = 1 (NumFillBits = 1)
        cx, cy = x0, y0
        for (x, y) in pts[1:] + [pts[0]]:
            dx, dy = x - cx, y - cy
            if dx == 0 and dy == 0:
                continue
            n = nbits_signed(dx, dy)
            n = max(n, 2)
            w.u(1, 1); w.u(1, 1)  # StraightEdgeRecord
            w.u(4, n - 2)
            w.u(1, 1)  # general line
            w.s(n, dx); w.s(n, dy)
            cx, cy = x, y
    w.u(1, 0); w.u(5, 0)  # EndShapeRecord
    return w.data()


def rect(xmin, xmax, ymin, ymax):
    w = Bits()
    n = nbits_signed(xmin, xmax, ymin, ymax)
    w.u(5, n)
    for v in (xmin, xmax, ymin, ymax):
        w.s(n, v)
    return w.data()


def build_font(old, ttf):
    fid, flags, lang, nl = struct.unpack_from("<HBBB", old, 0)
    name = old[5:5 + nl]
    assert flags == 0b10000100, bin(flags)  # HasLayout + WideCodes, offsets de 16 bits
    ng = struct.unpack_from("<H", old, 5 + nl)[0]
    tbl = 5 + nl + 2
    cto = struct.unpack_from("<H", old, tbl + 2 * ng)[0]
    cstart = tbl + cto
    codes = struct.unpack_from("<%dH" % ng, old, cstart)
    ce = cstart + 2 * ng
    asc, desc, lead = struct.unpack_from("<hhh", old, ce)
    adv = struct.unpack_from("<%dh" % ng, old, ce + 6)

    cmap = ttf.getBestCmap()
    gs = ttf.getGlyphSet()
    scale = 20480 / ttf["head"].unitsPerEm
    shapes, bounds, newadv = [], [], []
    for code, oadv in zip(codes, adv):
        pen = DecomposingRecordingPen(gs)
        # a Silkscreen nao tem G/g com breve (U+011E/U+011F): usa G e g
        gs[cmap.get(code) or cmap[{0x11E: 0x47, 0x11F: 0x67}[code]]].draw(pen)
        contours, cur = [], None
        for op, args in pen.value:
            if op == "moveTo":
                cur = [args[0]]
            elif op == "lineTo":
                cur.append(args[0])
            elif op == "closePath":
                if cur and cur[0] == cur[-1] and len(cur) > 1:
                    cur.pop()
                if len(cur) >= 3:
                    contours.append(cur)
                cur = None
            else:
                raise SystemExit("contorno com curva: %s" % op)
        # sem o pixel de margem esquerda da Silkscreen (125 unidades): o texto fica mais estreito, perto do antigo
        sc = [[(round((x - 125) * scale), -round(y * scale)) for x, y in c] for c in contours]
        shapes.append(glyph_shape(sc))
        xs = [p[0] for c in sc for p in c] or [0]
        ys = [p[1] for c in sc for p in c] or [0]
        bounds.append(rect(min(xs), max(xs), min(ys), max(ys)))
        # avanco proporcional: borda direita da tinta + 1 pixel (125 de 1000 unidades); sem tinta, o da fonte antiga
        newadv.append(max(xs) + round(125 * scale) if contours else oadv)

    offs, pos = [], 2 * ng + 2  # a tabela de offsets (ng * 2) + o CodeTableOffset (2)
    for s in shapes:
        offs.append(pos)
        pos += len(s)
    assert pos < 65536
    out = struct.pack("<HBBB", fid, flags, lang, nl) + name + struct.pack("<H", ng)
    out += struct.pack("<%dH" % ng, *offs) + struct.pack("<H", pos)
    out += b"".join(shapes)
    out += struct.pack("<%dH" % ng, *codes)
    out += struct.pack("<hhh", asc, desc, lead)
    out += struct.pack("<%dh" % ng, *newadv)
    out += b"".join(bounds)
    out += struct.pack("<H", 0)  # sem kerning
    return fid, out


def main():
    src, ttfpath, dst = sys.argv[1:4]
    raw = open(src, "rb").read()
    assert raw[:3] == b"CWS"
    body = zlib.decompress(raw[8:])
    ttf = TTFont(ttfpath)
    nrect = (body[0] >> 3)
    pos = (5 + 4 * nrect + 7) // 8 + 4
    tags, font_id = [], None
    while pos < len(body):
        h = struct.unpack_from("<H", body, pos)[0]
        t, l = h >> 6, h & 63
        hl = 2
        if l == 63:
            l = struct.unpack_from("<I", body, pos + 2)[0]
            hl = 6
        tags.append((t, body[pos + hl:pos + hl + l]))
        pos += hl + l

    def tag(t, d):
        if len(d) < 63:
            return struct.pack("<H", (t << 6) | len(d)) + d
        return struct.pack("<HI", (t << 6) | 63, len(d)) + d

    out, done = [], {75: 0, 73: 0, 88: 0}
    for t, d in tags:
        if t == 75:
            font_id, nd = build_font(d, ttf)
            d = nd
            done[75] += 1
        elif t == 73:
            assert struct.unpack_from("<H", d, 0)[0] == font_id
            done[73] += 1
            continue
        elif t == 88:
            assert struct.unpack_from("<H", d, 0)[0] == font_id
            d = (struct.pack("<H", font_id) + b"Silkscreen\0" +
                 b"Copyright 2001 The Silkscreen Project Authors (https://github.com/googlefonts/silkscreen), SIL Open Font License 1.1\0")
            done[88] += 1
        out.append(tag(t, d))
    assert done == {75: 1, 73: 1, 88: 1}, done
    nb = b"".join(out)
    # cabecalho (RECT + taxa + contagem de quadros) igual ao original
    head_len = (5 + 4 * nrect + 7) // 8 + 4
    new_body = body[:head_len] + nb
    hdr = b"CWS" + raw[3:4] + struct.pack("<I", 8 + len(new_body))
    c = zlib.compressobj(9)
    open(dst, "wb").write(hdr + c.compress(new_body) + c.flush())


main()