import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

# =====================================================================
# 1. Ownership mappings
# =====================================================================

def quadrant_owner(row, col):
    """4 coarse owners: the four 14x14 quadrants."""
    return (0 if row < 14 else 2) + (0 if col < 14 else 1)

def sub_quadrant_owner(row, col):
    """16 fine owners: each quadrant split into 4 sub-quadrants."""
    q = quadrant_owner(row, col)
    r, c = row % 14, col % 14
    sub = (0 if r < 7 else 2) + (0 if c < 7 else 1)
    return q * 4 + sub

def build_owner_indices(owner_fn, num_owners):
    owner_indices = {o: [] for o in range(num_owners)}
    for idx in range(784):
        owner_indices[owner_fn(idx // 28, idx % 28)].append(idx)
    return {o: torch.tensor(sorted(v), dtype=torch.long)
            for o, v in owner_indices.items()}

owner_indices_4  = build_owner_indices(quadrant_owner,     4)   # coarse
owner_indices_16 = build_owner_indices(sub_quadrant_owner, 16)  # fine

# =====================================================================
# 2. Ownership-Structured Linear Layer (fixed, from original)
# =====================================================================

class OwnerLinear(nn.Module):
    def __init__(self, in_features, out_features_per_owner, owner_indices,
                 owner_weights=None):
        super().__init__()
        self.owner_indices = owner_indices
        self.num_owners = len(owner_indices)
        self.out_per_owner = out_features_per_owner
        self.total_out = self.num_owners * out_features_per_owner

        if owner_weights is None:
            owner_weights = {o: 1.0 for o in range(self.num_owners)}
        self.owner_weights = owner_weights

        self.weights = nn.ParameterDict()
        self.biases = nn.ParameterDict()
        for o, indices in owner_indices.items():
            in_dim = len(indices)
            self.weights[str(o)] = nn.Parameter(
                torch.randn(out_features_per_owner, in_dim) * 0.01)
            self.biases[str(o)] = nn.Parameter(
                torch.zeros(out_features_per_owner))

    def forward(self, x):
        outputs = []
        for o, indices in self.owner_indices.items():
            x_o = x[:, indices]
            out_o = F.linear(x_o, self.weights[str(o)], self.biases[str(o)])
            outputs.append(out_o)
        return torch.cat(outputs, dim=1)

    def semantic_norm(self):
        norm_sq = 0.0
        for o_str, w_param in self.weights.items():
            o = int(o_str)
            norm_sq += self.owner_weights[o] * (w_param.norm('fro') ** 2)
        return norm_sq

# =====================================================================
# 3. Owner-structured BatchNorm (governance, T7)
# =====================================================================

class OwnerBatchNorm1d(nn.Module):
    def __init__(self, num_owners, per_owner):
        super().__init__()
        self.num_owners = num_owners
        self.per_owner = per_owner
        self.bns = nn.ModuleDict({str(o): nn.BatchNorm1d(per_owner)
                                  for o in range(num_owners)})

    def forward(self, x):
        # x is (B, num_owners*per_owner), concatenated in owner order
        return torch.cat([
            self.bns[str(o)](x[:, o * self.per_owner:(o + 1) * self.per_owner])
            for o in range(self.num_owners)
        ], dim=1)

# =====================================================================
# 4. Cross-Owner Lifting layer (T5/T6): recover correction terms C_{o,o'}
# =====================================================================

class CrossOwnerLinear(nn.Module):
    """Stage 2: each owner's output = governed sum over ALL owners' inputs.
       out_o = sum_{o'} a_{o,o'} * (W_{o,o'} @ x_{o'}) + b_o
       Diagonal a_{o,o}  = owner-local term
       Off-diagonal       = correction terms C_{o,o'} (the terms T5 drops)"""
    def __init__(self, num_owners, in_per_owner, out_per_owner):
        super().__init__()
        self.num_owners = num_owners
        self.in_per_owner = in_per_owner
        self.out_per_owner = out_per_owner

        self.W = nn.ParameterDict({
            f"{o}_{o2}": nn.Parameter(torch.randn(out_per_owner, in_per_owner) * 0.01)
            for o in range(num_owners) for o2 in range(num_owners)
        })
        self.b = nn.ParameterDict({str(o): nn.Parameter(torch.zeros(out_per_owner))
                                   for o in range(num_owners)})
        # Governed admission weights a_{o,o'} (diagonal-dominant init)
        self.admit = nn.Parameter(
            torch.eye(num_owners) * 1.0 + torch.randn(num_owners, num_owners) * 0.02)

    def forward(self, x):
        xs = x.view(x.size(0), self.num_owners, self.in_per_owner)  # (B, O, in)
        outs = []
        for o in range(self.num_owners):
            acc = self.b[str(o)]
            for o2 in range(self.num_owners):
                acc = acc + self.admit[o, o2] * (xs[:, o2] @ self.W[f"{o}_{o2}"].T)
            outs.append(acc)
        return torch.cat(outs, dim=1)

# =====================================================================
# 5. Deep Hierarchical Ownership Model
# =====================================================================

class DeepOwnershipMLP(nn.Module):
    def __init__(self, per_owner=64):
        super().__init__()
        # Stage 1: fine-grained local features (16 sub-owners)
        self.local = OwnerLinear(784, per_owner, owner_indices_16)   # 16*64 = 1024
        self.bn1 = OwnerBatchNorm1d(16, per_owner)
        # Stage 2: cross-owner lifting over the 16 owners (correction terms)
        self.cross = CrossOwnerLinear(16, per_owner, per_owner)
        self.bn2 = OwnerBatchNorm1d(16, per_owner)
        # Stage 3: collapse to 4 coarse quadrants (hierarchical aggregation)
        self.coarse = nn.Linear(16 * per_owner, 4 * per_owner)
        self.fc_out = nn.Linear(4 * per_owner, 10)

    def forward(self, x):
        x = x.view(x.size(0), -1)
        x = F.relu(self.bn1(self.local(x)))      # owner-local features
        x = F.relu(self.bn2(self.cross(x)))      # correction terms (T5)
        x = F.relu(self.coarse(x))               # hierarchical aggregation
        return self.fc_out(x)

    def governed_norm_loss(self):
        """Governance-aware regularization (T4/T8):
           stale owners (small gradient) decay faster."""
        loss = 0.0
        for o_str, w in self.local.weights.items():
            g = w.grad.norm() if w.grad is not None else 0.0
            decay = 1.0 / (1.0 + g)
            loss = loss + decay * (w.norm('fro') ** 2)
        return loss

# =====================================================================
# 6. Training & Evaluation
# =====================================================================

def train(model, device, train_loader, optimizer, epoch, lambda_norm=1e-5):
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader):
        data, target = data.to(device), target.to(device)
        optimizer.zero_grad()
        output = model(data)
        ce_loss = F.cross_entropy(output, target)
        norm_penalty = lambda_norm * model.governed_norm_loss()
        loss = ce_loss + norm_penalty
        loss.backward()
        optimizer.step()
        if batch_idx % 100 == 0:
            print(f'Train Epoch: {epoch} '
                  f'[{batch_idx * len(data)}/{len(train_loader.dataset)} '
                  f'({100. * batch_idx / len(train_loader):.0f}%)]\tLoss: {loss.item():.6f}')

def test(model, device, test_loader):
    model.eval()
    test_loss = 0
    correct = 0
    with torch.no_grad():
        for data, target in test_loader:
            data, target = data.to(device), target.to(device)
            output = model(data)
            test_loss += F.cross_entropy(output, target, reduction='sum').item()
            pred = output.argmax(dim=1, keepdim=True)
            correct += pred.eq(target.view_as(pred)).sum().item()
    test_loss /= len(test_loader.dataset)
    accuracy = 100. * correct / len(test_loader.dataset)
    print(f'\nTest set: Average loss: {test_loss:.4f}, '
          f'Accuracy: {correct}/{len(test_loader.dataset)} ({accuracy:.2f}%)\n')
    return accuracy

def main():
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    print(f"Using device: {device}")

    # Mild augmentation (biggest cheap win for MLPs on MNIST)
    train_transform = transforms.Compose([
        transforms.RandomAffine(degrees=8, translate=(0.08, 0.08),
                                scale=(0.95, 1.05)),
        transforms.ToTensor(),
        transforms.Normalize((0.1307,), (0.3081,)),
    ])
    test_transform = transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize((0.1307,), (0.3081,)),
    ])

    train_dataset = datasets.MNIST('./data', train=True, download=True,
                                   transform=train_transform)
    test_dataset = datasets.MNIST('./data', train=False, transform=test_transform)
    train_loader = DataLoader(train_dataset, batch_size=128, shuffle=True)
    test_loader = DataLoader(test_dataset, batch_size=1000, shuffle=False)

    model = DeepOwnershipMLP(per_owner=64).to(device)
    optimizer = optim.AdamW(model.parameters(), lr=1e-3)
    scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=40)

    best = 0.0
    for epoch in range(1, 41):
        train(model, device, train_loader, optimizer, epoch, lambda_norm=1e-5)
        acc = test(model, device, test_loader)
        scheduler.step()
        best = max(best, acc)
    print(f'Best test accuracy: {best:.2f}%')

if __name__ == "__main__":
    main()