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

# ---------- Ownership mapping for MNIST (28x28 -> 4 quadrants) ----------
def pixel_to_owner(idx):
    row = idx // 28
    col = idx % 28
    if row < 14 and col < 14:
        return 0
    elif row < 14 and col >= 14:
        return 1
    elif row >= 14 and col < 14:
        return 2
    else:
        return 3

owner_indices = {o: [] for o in range(4)}
for idx in range(784):
    owner_indices[pixel_to_owner(idx)].append(idx)

owner_indices_t = {o: torch.tensor(sorted(indices), dtype=torch.long)
                   for o, indices in owner_indices.items()}

# ---------- Ownership-Structured Linear Layer (fixed) ----------
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          # int -> list of 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          # int -> weight

        # Use string keys for ParameterDict
        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]                     # (batch, in_dim_o)
            w = self.weights[str(o)]
            b = self.biases[str(o)]
            out_o = F.linear(x_o, w, b)             # (batch, out_per_owner)
            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)   # recover integer owner
            norm_sq += self.owner_weights[o] * (w_param.norm('fro') ** 2)
        return norm_sq

# ---------- Full Model (unchanged) ----------
class OwnershipMLP(nn.Module):
    def __init__(self, hidden_per_owner=64, owner_weights=None):
        super().__init__()
        self.owner_linear = OwnerLinear(
            in_features=784,
            out_features_per_owner=hidden_per_owner,
            owner_indices=owner_indices_t,
            owner_weights=owner_weights
        )
        self.fc_out = nn.Linear(self.owner_linear.total_out, 10)

    def forward(self, x):
        x = x.view(x.size(0), -1)
        x = self.owner_linear(x)
        x = F.relu(x)
        x = self.fc_out(x)
        return x

    def semantic_norm_loss(self):
        return self.owner_linear.semantic_norm()

# ---------- Training & Evaluation (unchanged) ----------
def train(model, device, train_loader, optimizer, epoch, lambda_norm=1e-4):
    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.semantic_norm_loss()
        loss = ce_loss + norm_penalty
        loss.backward()
        optimizer.step()
        if batch_idx % 100 == 0:
            print(f'Train Epoch: {epoch} [{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}, 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}")

    transform = transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize((0.1307,), (0.3081,))
    ])
    train_dataset = datasets.MNIST('./data', train=True, download=True, transform=transform)
    test_dataset = datasets.MNIST('./data', train=False, transform=transform)
    train_loader = DataLoader(train_dataset, batch_size=128, shuffle=True)
    test_loader = DataLoader(test_dataset, batch_size=1000, shuffle=False)

    model = OwnershipMLP(hidden_per_owner=64).to(device)
    optimizer = optim.Adam(model.parameters(), lr=1e-3)

    for epoch in range(1, 16):
        train(model, device, train_loader, optimizer, epoch, lambda_norm=1e-4)
        test(model, device, test_loader)

if __name__ == "__main__":
    main()