"""Sparse affine-hyperplane recovery by twisted binary convolution.

Physical addresses are (u, c), with u a d-bit integer, c in {0,1};
c=1 stores a scalar source in GF(2**m), c=0 stores scalar parity.
All arithmetic is exact. This is a reference codec, not a storage protocol.
"""
from itertools import product

from affine_core import Field, inverse


def dot(a, b):
    return (a & b).bit_count() & 1


def binary_apply(rows, value):
    return sum(dot(row, value) << j for j, row in enumerate(rows))


def binary_inverse(rows):
    d = len(rows)
    matrix = [[(row >> j) & 1 for j in range(d)] for row in rows]
    inv = inverse(matrix, Field(2))
    return [sum(x << j for j, x in enumerate(row)) for row in inv]


def binary_transpose(rows):
    return [sum(((rows[j] >> i) & 1) << j for j in range(len(rows)))
            for i in range(len(rows))]


def independent_binary_basis(values, dimension):
    """Extend independent bit-vector labels to the requested dimension."""
    chosen, span = [], {0}
    for value in values:
        if value in span:
            raise ValueError("dependent initial field elements")
        chosen.append(value)
        span |= {x ^ value for x in tuple(span)}
    if len(chosen) > dimension:
        raise ValueError("too many initial elements")
    candidate = 1
    while len(chosen) < dimension:
        if candidate not in span:
            chosen.append(candidate)
            span |= {x ^ candidate for x in tuple(span)}
        candidate += 1
    return chosen


def optimal_kernel(d, field):
    """Alphabet-optimal construction; support ceil(3*d/2), for d>=2.

Returns (T, kernel), with T represented by binary row masks. The support
count is an achieved bound, not a general minimum-support theorem.
"""
    if field.p != 2 or d < 1:
        raise ValueError("binary characteristic and positive dimension required")
    if d == 1:
        if field.n < 2:
            raise ValueError("dimension one requires at least GF(4)")
        return [1], {0: 1, 1: 2}
    blocks = (d + 1) // 2
    if field.n < blocks:
        raise ValueError("alphabet degree below the exact existence threshold")
    rows, kernel = [0] * d, {}
    if d % 2 == 0:
        basis = [1 << i for i in range(blocks)]
        basis[0] = 1
        for value in basis[1:]:
            basis[0] ^= value
        offset, weights = 0, basis
    else:
        alpha = 2
        square = field.mul(alpha, alpha)
        lam, v = square ^ alpha, 1 ^ square
        basis = independent_binary_basis([lam, v], blocks)
        nu = v
        for value in basis[2:]:
            nu ^= value
        kernel.update({1: lam, 2: nu, 4: lam ^ nu, 5: square, 6: nu})
        rows[:3] = [1, 3, 6]
        offset, weights = 3, basis[2:]
    for i, weight in enumerate(weights):
        j = offset + 2*i
        a, b = 1 << j, 1 << (j+1)
        kernel[a] = kernel[b] = kernel[a ^ b] = weight
        rows[j], rows[j+1] = b, a ^ b
    if any(not x for x in kernel.values()):
        raise AssertionError("construction unexpectedly contains a zero weight")
    # rows is R=T^{-t} on normal vectors.
    transform = binary_transpose(binary_inverse(rows))
    return transform, kernel


class TwistedCodec:
    def __init__(self, d, field, transform, kernel):
        if field.p != 2 or not isinstance(d, int) or d < 1:
            raise ValueError("positive dimension and characteristic two required")
        self.d, self.f, self.n = d, field, 1 << d
        if len(transform) != d or any(x not in range(self.n) for x in transform):
            raise ValueError("invalid binary transform")
        self.transform = tuple(transform)
        self.inverse_transform = tuple(binary_inverse(transform))
        if any(w not in range(self.n) or a not in range(field.q)
               for w, a in kernel.items()):
            raise ValueError("invalid kernel entry")
        self.kernel = {w: a for w, a in kernel.items() if a}
        self.forward = [binary_apply(transform, u) for u in range(self.n)]
        self.backward = [binary_apply(self.inverse_transform, z) for z in range(self.n)]
        self.normal_transform = binary_transpose(self.inverse_transform)
        self.sigma = field.sum(self.kernel.values())
        self._plan_cache = {}

    @classmethod
    def optimal(cls, d, field=None):
        """Explicit alphabet-optimal family; its support need not be minimal."""
        if field is None:
            field = Field(2, 2 if d == 1 else (d+1)//2)
        transform, kernel = optimal_kernel(d, field)
        return cls(d, field, transform, kernel)

    @classmethod
    def minimum_support_example(cls,d):
        """Finite exact examples attaining both optima in dimensions 2..6."""
        if d==2:
            return cls.optimal(2)
        cases={
            3:([1,1,3,2],[2,4,3]),
            4:([1,3,1,3,1],[7,10,9,12]),
            5:([4,6,3,7,2,5],[14,7,17,25,2]),
            6:([3,7,5,4,2,2,4],[14,28,32,20,7,63]),
        }
        if d not in cases:
            raise ValueError("finite examples are supplied only for d=2..6")
        weights,normal_rows=cases[d]
        degree=(d+1)//2
        field=Field(2,degree,[1,1,1] if degree==2 else [1,1,0,1])
        kernel={0:weights[0]}|{1<<i:weights[i+1] for i in range(d)}
        return cls(d,field,binary_transpose(binary_inverse(normal_rows)),kernel)

    def quadratic(self, a):
        """Evaluate a^t S T^{-t}a using exact sparse moment sums."""
        b = binary_apply(self.normal_transform, a)
        ma = mb = mixed = 0
        for w, coefficient in self.kernel.items():
            aw, bw = dot(a, w), dot(b, w)
            if aw:
                ma ^= coefficient
            if bw:
                mb ^= coefficient
            if aw and bw:
                mixed ^= coefficient
        return self.f.mul(self.sigma, mixed) ^ self.f.mul(ma, mb)

    def certificate(self):
        """Exhaustive small moment certificate, independent of packet values."""
        if not self.sigma:
            return {"valid": False, "failure": "zero augmentation", "normal": 0}
        for a in range(1, self.n):
            if not self.quadratic(a):
                return {"valid": False, "failure": "zero quadratic value", "normal": a}
        return {"valid": True, "normal_checks": self.n-1,
                "support": len(self.kernel), "alphabet_size": self.f.q}

    def obstruction(self):
        """Return a bad hyperplane and a nonzero invisible source difference.

        A valid encoder returns None. A rejected encoder receives an exact
        collision witness over its original coding field, not an extension.
        """
        certificate = self.certificate()
        if certificate["valid"]:
            return None
        if not self.sigma:
            return {"plane":(0,1,1),"difference":[1]*self.n,
                    "reason":"zero augmentation"}
        a = certificate["normal"]
        b = binary_apply(self.normal_transform,a)
        difference = [0]*self.n
        if a == b:
            halves = [0,0]
            for w,value in self.kernel.items():
                halves[dot(a,w)] ^= value
            zero_half = next(i for i,x in enumerate(halves) if x == 0)
            plane = (a,1 ^ zero_half,0)
            for u in range(self.n):
                if self.on((u,1),plane):
                    difference[u]=1
        else:
            plane=(a,0,0)
            table=[[0,0],[0,0]]
            for w,value in self.kernel.items():
                table[dot(b,w)][dot(a,w)^1] ^= value
            row=next((r for r in table if any(r)),None)
            vector=[row[1],row[0]] if row is not None else [1,0]
            assert any(vector) and all(self.f.sum(self.f.mul(x,y) for x,y in zip(r,vector))==0
                                      for r in table)
            for u in range(self.n):
                z=self.forward[u]
                if dot(b,z)==0:
                    difference[u]=vector[dot(a,z)]
        assert any(difference)
        return {"plane":plane,"difference":difference,"reason":"zero quadratic value"}

    def on(self, address, plane):
        u, c = address
        a, beta, tau = plane
        return (dot(a, u) ^ (beta & c)) == tau

    def hyperplanes(self):
        for a in range(self.n):
            for beta in (0, 1):
                if a or beta:
                    for tau in (0, 1):
                        yield a, beta, tau

    def containing_hyperplane(self, erased):
        """Infer a containing hyperplane from erased physical addresses."""
        erased = list(erased)
        if any(not isinstance(s, tuple) or len(s) != 2 or
               s[0] not in range(self.n) or s[1] not in (0, 1) for s in erased):
            raise ValueError("invalid erased address")
        if not erased:
            return 0, 1, 0
        rows = [u | (c << self.d) | (1 << (self.d+1)) for u, c in erased]
        width, pivot_cols, r = self.d+2, [], 0
        for col in range(width):
            pivot = next((i for i in range(r, len(rows)) if (rows[i] >> col) & 1), None)
            if pivot is None:
                continue
            rows[r], rows[pivot] = rows[pivot], rows[r]
            for i in range(len(rows)):
                if i != r and (rows[i] >> col) & 1:
                    rows[i] ^= rows[r]
            pivot_cols.append(col)
            r += 1
            if r == len(rows):
                break
        free = next((c for c in range(width) if c not in pivot_cols), None)
        if free is None:
            raise ValueError("erased set is not contained in an affine hyperplane")
        vector = 1 << free
        for row, col in zip(rows, pivot_cols):
            if dot(row, vector):
                vector |= 1 << col
        a = vector & (self.n-1)
        beta, tau = (vector >> self.d) & 1, (vector >> (self.d+1)) & 1
        if not (a or beta) or not all(self.on(s, (a,beta,tau)) for s in erased):
            raise AssertionError("invalid inferred hyperplane")
        return a, beta, tau

    def encode(self, source):
        if len(source) != self.n or any(x not in range(self.f.q) for x in source):
            raise ValueError("one valid source scalar per data site required")
        parity, mul = [0]*self.n, self.f.multiplication
        for u, value in enumerate(source):
            if value:
                z = self.forward[u]
                for w, coefficient in self.kernel.items():
                    parity[z ^ w] ^= mul[coefficient][value]
        return {(u,1): x for u,x in enumerate(source)} | {(v,0): y for v,y in enumerate(parity)}

    def _plan(self, plane):
        plane = tuple(plane)
        if plane in self._plan_cache:
            return self._plan_cache[plane]
        if len(plane) != 3:
            raise ValueError("plane must be (normal,beta,offset)")
        a, beta, tau = plane
        if a not in range(self.n) or beta not in (0,1) or tau not in (0,1) or not (a or beta):
            raise ValueError("invalid affine hyperplane")
        missing = [u for u in range(self.n) if self.on((u,1), plane)]
        live = [v for v in range(self.n) if not self.on((v,0), plane)]
        plan = {"missing": missing, "missing_set": set(missing), "live": live,
                "live_set": set(live), "plane": plane}
        if a == 0:
            plan["kind"] = "slab" if missing else "parity"
        else:
            b = binary_apply(self.normal_transform, a)
            s, t = tau ^ beta, tau ^ 1
            if a == b:
                group = [w for w in range(self.n) if not dot(a,w)]
                z0 = next(z for z in range(self.n) if dot(b,z) == s)
                v0 = next(v for v in range(self.n) if dot(a,v) == t)
                kernel = {w ^ v0 ^ z0: value for w,value in self.kernel.items()
                          if not dot(a, w ^ v0 ^ z0)}
                delta = self.f.sum(kernel.values())
                plan.update(kind="coincident", group=group, sources=[z0], targets=[v0],
                            kernels=[[kernel]], delta=delta)
            else:
                group = [w for w in range(self.n) if not dot(a,w) and not dot(b,w)]
                zs = [next(z for z in range(self.n) if dot(a,z) == i and dot(b,z) == s)
                      for i in (0,1)]
                vs = [next(v for v in range(self.n) if dot(a,v) == t and dot(b,v) == i)
                      for i in (0,1)]
                kernels = [[{} for _ in (0,1)] for _ in (0,1)]
                for w, value in self.kernel.items():
                    row, col = dot(b,w) ^ s, dot(a,w) ^ t
                    shift = w ^ vs[row] ^ zs[col]
                    assert not dot(a,shift) and not dot(b,shift)
                    kernels[row][col][shift] = value
                aug = [[self.f.sum(h.values()) for h in row] for row in kernels]
                delta = self.f.mul(aug[0][0],aug[1][1]) ^ self.f.mul(aug[0][1],aug[1][0])
                plan.update(kind="independent", group=group, sources=zs, targets=vs,
                            kernels=kernels, delta=delta)
            if not plan["delta"]:
                raise ValueError("singular recovery cut")
        self._plan_cache[plane] = plan
        return plan

    def _convolve(self, kernel, values, group):
        mul = self.f.multiplication
        result = {w: 0 for w in group}
        for shift, coefficient in kernel.items():
            row = mul[coefficient]
            for w in group:
                result[w] ^= row[values[w ^ shift]]
        return result

    def decode(self, observed, plane=None, verify=True):
        if any(not isinstance(s,tuple) or len(s) != 2 or s[0] not in range(self.n)
               or s[1] not in (0,1) or value not in range(self.f.q)
               for s,value in observed.items()):
            raise ValueError("invalid observed address or scalar")
        if plane is None:
            erased = [(u,c) for u in range(self.n) for c in (0,1) if (u,c) not in observed]
            plane = self.containing_hyperplane(erased)
        plan = self._plan(plane)
        missing, live = plan["missing_set"], plan["live_set"]
        if any((u,1) not in observed for u in range(self.n) if u not in missing) or any(
                (v,0) not in observed for v in live):
            raise ValueError("erasures extend outside the containing hyperplane")
        residual = {v: observed[(v,0)] for v in live}
        mul = self.f.multiplication
        for u in range(self.n):
            if u not in missing:
                value, z = observed[(u,1)], self.forward[u]
                if value:
                    for w, coefficient in self.kernel.items():
                        v = z ^ w
                        if v in live:
                            residual[v] ^= mul[coefficient][value]
        source = [0 if u in missing else observed[(u,1)] for u in range(self.n)]
        kind = plan["kind"]
        layers = 0
        if kind == "slab":
            if not self.sigma:
                raise ValueError("singular all-data slab")
            values = self._convolve(self.kernel,residual,range(self.n))
            scale = self.f.inv(self.f.mul(self.sigma,self.sigma))
            for z, value in values.items():
                source[self.backward[z]] = mul[scale][value]
            layers = 1
        elif kind in ("coincident","independent"):
            group, kernels = plan["group"], plan["kernels"]
            ys = [{w: residual[v ^ w] for w in group} for v in plan["targets"]]
            if kind == "coincident":
                xs = [self._convolve(kernels[0][0],ys[0],group)]
                layers = 1
            else:
                h00,h01 = kernels[0]
                h10,h11 = kernels[1]
                p0,q0 = self._convolve(h11,ys[0],group),self._convolve(h01,ys[1],group)
                p1,q1 = self._convolve(h10,ys[0],group),self._convolve(h00,ys[1],group)
                adj = [{w:p0[w]^q0[w] for w in group},{w:p1[w]^q1[w] for w in group}]
                xs = []
                for values in adj:
                    left = self._convolve(h00,self._convolve(h11,values,group),group)
                    right = self._convolve(h01,self._convolve(h10,values,group),group)
                    xs.append({w:left[w]^right[w] for w in group})
                layers = 3
            scale = self.f.inv(self.f.mul(plan["delta"],plan["delta"]))
            for z0, values in zip(plan["sources"],xs):
                for w,value in values.items():
                    source[self.backward[z0 ^ w]] = mul[scale][value]
        if verify:
            rebuilt = self.encode(source)
            if any(rebuilt[s] != value for s,value in observed.items()):
                raise ValueError("surviving observations are inconsistent")
        return source, {"kind":kind,"convolution_layers":layers,
                        "missing_data":len(missing),"live_parity":len(live),
                        "plane":list(plane)}