#!/usr/bin/env python3
"""The QR code of the first-run guide's TMDb step (resources/media/onboarding/qr_tmdb.png, docs/plan/onboarding).

A minimal QR encoder (byte mode, error correction M, version 3, mask 0; the algorithm of Project Nayuki's reference
encoder) so that no library is needed: the URL is fixed. Check the result with any QR reader after a change.
"""
import os

from PIL import Image

URL = 'https://www.themoviedb.org/settings/api'
OUT = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'onboarding', 'qr_tmdb.png')
VERSION, SIZE = 3, 29
DATA_CODEWORDS, EC_CODEWORDS = 44, 26          # version 3-M: one block
ALIGNMENT = (6, 22)
FORMAT_M_MASK0 = 0b101010000010010
SCALE, QUIET = 10, 4


def _multiply(x, y):
    z = 0
    for i in reversed(range(8)):
        z = (z << 1) ^ ((z >> 7) * 0x11D)
        z ^= ((y >> i) & 1) * x
    return z


def _divisor(degree):
    result = [0] * (degree - 1) + [1]
    root = 1
    for _ in range(degree):
        for j in range(degree):
            result[j] = _multiply(result[j], root)
            if j + 1 < degree:
                result[j] ^= result[j + 1]
        root = _multiply(root, 0x02)
    return result


def _remainder(data, divisor):
    result = [0] * len(divisor)
    for byte in data:
        factor = byte ^ result.pop(0)
        result.append(0)
        for i, coefficient in enumerate(divisor):
            result[i] ^= _multiply(coefficient, factor)
    return result


def codewords(text):
    payload = text.encode('utf-8')
    bits = [0, 1, 0, 0] + [(len(payload) >> i) & 1 for i in reversed(range(8))]
    for byte in payload:
        bits += [(byte >> i) & 1 for i in reversed(range(8))]
    capacity = DATA_CODEWORDS * 8
    if len(bits) > capacity:
        raise ValueError('too long for version 3-M')
    bits += [0] * min(4, capacity - len(bits))
    bits += [0] * (-len(bits) % 8)
    data = [int(''.join(map(str, bits[i:i + 8])), 2) for i in range(0, len(bits), 8)]
    pad = 0xEC
    while len(data) < DATA_CODEWORDS:
        data.append(pad)
        pad ^= 0xEC ^ 0x11
    return data + _remainder(data, _divisor(EC_CODEWORDS))


def matrix(text):
    modules = [[False] * SIZE for _ in range(SIZE)]
    function = [[False] * SIZE for _ in range(SIZE)]

    def put(x, y, dark):
        modules[y][x] = dark
        function[y][x] = True

    for i in range(SIZE):                                   # timing
        put(6, i, i % 2 == 0)
        put(i, 6, i % 2 == 0)
    for cx, cy in ((3, 3), (SIZE - 4, 3), (3, SIZE - 4)):   # finders with separators
        for dy in range(-4, 5):
            for dx in range(-4, 5):
                x, y = cx + dx, cy + dy
                if 0 <= x < SIZE and 0 <= y < SIZE:
                    put(x, y, max(abs(dx), abs(dy)) not in (2, 4))
    for cx in ALIGNMENT:                                    # alignment (not over the finders)
        for cy in ALIGNMENT:
            if (cx, cy) in ((6, 6), (6, 22), (22, 6)):
                continue
            for dy in range(-2, 3):
                for dx in range(-2, 3):
                    put(cx + dx, cy + dy, max(abs(dx), abs(dy)) != 1)
    bit = lambda i: (FORMAT_M_MASK0 >> i) & 1 == 1
    for i in range(6):
        put(8, i, bit(i))
    put(8, 7, bit(6))
    put(8, 8, bit(7))
    put(7, 8, bit(8))
    for i in range(9, 15):
        put(14 - i, 8, bit(i))
    for i in range(8):
        put(SIZE - 1 - i, 8, bit(i))
    for i in range(8, 15):
        put(8, SIZE - 15 + i, bit(i))
    put(8, SIZE - 8, True)                                  # the dark module
    data = codewords(text)
    i = 0
    right = SIZE - 1
    while right >= 1:
        if right == 6:
            right = 5
        for vert in range(SIZE):
            for j in range(2):
                x = right - j
                upward = ((right + 1) & 2) == 0
                y = SIZE - 1 - vert if upward else vert
                if not function[y][x] and i < len(data) * 8:
                    modules[y][x] = (data[i >> 3] >> (7 - (i & 7))) & 1 == 1
                    i += 1
        right -= 2
    for y in range(SIZE):                                   # mask 0
        for x in range(SIZE):
            if not function[y][x] and (x + y) % 2 == 0:
                modules[y][x] = not modules[y][x]
    return modules


def main():
    modules = matrix(URL)
    side = (SIZE + 2 * QUIET) * SCALE
    image = Image.new('L', (side, side), 255)
    for y, row in enumerate(modules):
        for x, dark in enumerate(row):
            if dark:
                left, top = (x + QUIET) * SCALE, (y + QUIET) * SCALE
                image.paste(0, (left, top, left + SCALE, top + SCALE))
    os.makedirs(os.path.dirname(OUT), exist_ok=True)
    image.save(OUT)
    print(OUT)


if __name__ == '__main__':
    main()
