"""Exact logical BCE gradient with block recomputation of frontier histories."""
import jax
import jax.numpy as jnp


def make_loss_and_grad(width, block_size=32):
    indices = jnp.arange(1 << width, dtype=jnp.int32)

    @jax.jit
    def evaluate(dets, labels, probabilities, masks, measured):
        nops, batch = probabilities.shape
        padding = (-nops) % block_size
        p = jnp.pad(probabilities, ((0, padding), (0, 0)))
        m = jnp.pad(masks, (0, padding))
        d = jnp.pad(measured, (0, padding), constant_values=-1)
        blocks = (p.reshape(-1, block_size, batch), m.reshape(-1, block_size),
                  d.reshape(-1, block_size))

        def forward(f, args):
            probability, mask, detector = args

            def error(f):
                out = (1 - probability[:, None]) * f + probability[:, None] * f[:, indices ^ mask]
                return out, jnp.ones(batch)

            def project(f):
                dst = (indices[None, :] & ~mask) | (dets[:, detector, None].astype(jnp.int32) * mask)
                g = jnp.take_along_axis(f, dst, axis=1) * ((indices & mask) == 0)
                norm = jnp.maximum(g.sum(axis=1), 1e-30)
                return g / norm[:, None], norm

            out, norm = jax.lax.cond(detector < 0, error, project, f)
            return out, (f, norm)

        def forward_block(f, args):
            def step(carry, item):
                result, _ = forward(carry, item)
                return result, None
            out, _ = jax.lax.scan(step, f, args)
            return out, f

        initial = jnp.zeros((batch, 1 << width), jnp.float32).at[:, 0].set(1)
        f, checkpoints = jax.lax.scan(forward_block, initial, blocks)
        indicator = ((indices[None, :] & 1) == labels[:, None])
        correct = jnp.maximum(jnp.sum(f * indicator, axis=1), 1e-10)
        prediction = jnp.sum(f[:, 1::2], axis=1)
        terminal = 1 - indicator / correct[:, None]

        def backward(b, args):
            probability, mask, detector, old, norm = args

            def error(b):
                flipped = b[:, indices ^ mask]
                grad = jnp.sum(old * (flipped - b), axis=1)
                return (1 - probability[:, None]) * b + probability[:, None] * flipped, grad

            def project(b):
                obs = ((indices[None, :] & mask) == dets[:, detector, None].astype(jnp.int32) * mask)
                values = b[:, indices & ~mask]
                mean = jnp.sum(old * obs * values, axis=1) / norm
                return (values - mean[:, None]) * obs / norm[:, None], jnp.zeros(batch)

            return jax.lax.cond(detector < 0, error, project, b)

        def backward_block(b, args):
            probabilities, masks, measured, checkpoint = args
            _, (history, norms) = jax.lax.scan(forward, checkpoint, (probabilities, masks, measured))
            return jax.lax.scan(backward, b, (probabilities, masks, measured, history, norms), reverse=True)

        _, gradients = jax.lax.scan(backward_block, terminal, (*blocks, checkpoints), reverse=True)
        return -jnp.log(correct), prediction, gradients.reshape(-1, batch)[:nops]

    return evaluate