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) ----------
# Each owner owns a 14x14 spatial quadrant.
#   owner 0: top-left     owner 1: top-right
#   owner 2: bottom-left  owner 3: bottom-right
owner_regions = {
    0: (slice(0, 28), slice(0, 28)),    # top-left
    1: (slice(0, 28), slice(14, 28)),   # top-right
    2: (slice(0, 14), slice(0, 28)),   # bottom-left
    3: (slice(14, 28), slice(0, 28)),  # bottom-right
}

# ---------- Ownership-Structured Conv2D Layer (fixed) ----------
class OwnerConv2DLinear(nn.Module):
    def __init__(self, in_channels, out_features_per_owner, owner_regions, owner_weights=None):
        super().__init__()
        self.owner_regions = owner_regions          # int -> (row_slice, col_slice)
        self.num_owners = len(owner_regions)
        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 ModuleDict
        self.convs = nn.ModuleDict()
        for o, (rs, cs) in owner_regions.items():
            # Full-quadrant kernel: equivalent to Linear(14*14 -> out_per_owner)
            conv = nn.Conv2d(in_channels, out_features_per_owner, kernel_size=(14, 14), bias=True)
            nn.init.normal_(conv.weight, std=0.01)
            nn.init.zeros_(conv.bias)
            self.convs[str(o)] = conv

    def forward(self, x):
        outputs = []
        for o, (rs, cs) in self.owner_regions.items():
            x_o = x[:, :, rs, cs]                    # (batch, C, 14, 14)
            out_o = self.convs[str(o)](x_o)          # (batch, out_per_owner, 1, 1)
            out_o = out_o.flatten(1)                 # (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, conv in self.convs.items():
            o = int(o_str)   # recover integer owner
            norm_sq += self.owner_weights[o] * (conv.weight.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_conv = OwnerConv2DLinear(
            in_channels=1,
            out_features_per_owner=hidden_per_owner,
            owner_regions=owner_regions,
            owner_weights=owner_weights
        )
        self.fc_out = nn.Linear(self.owner_conv.total_out, 10)

    def forward(self, x):
        x = self.owner_conv(x)
        x = F.relu(x)
        x = self.fc_out(x)
        return x

    def semantic_norm_loss(self):
        return self.owner_conv.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()