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
import numpy as np

# ---------- Ownership mapping for MNIST (28x28 -> 4 quadrants) ----------
def pixel_to_owner(idx):
    """Return owner (0..3) for pixel index in 0..783 (row-major)."""
    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

# Build list of indices per owner
owner_indices = {o: [] for o in range(4)}
for idx in range(784):
    owner_indices[pixel_to_owner(idx)].append(idx)

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

# ---------- Ownership-Structured Linear Layer ----------
class OwnerLinear(nn.Module):
    def __init__(self, in_features, out_features_per_owner, owner_indices, owner_weights=None):
        """
        in_features: total input dimension (e.g., 784)
        out_features_per_owner: hidden size per owner (same for all owners)
        owner_indices: dict {owner: list of input indices}
        owner_weights: optional dict {owner: weight} for semantic norm (default 1.0)
        """
        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

        # Create per-owner weight and bias
        self.weights = nn.ParameterDict()
        self.biases = nn.ParameterDict()
        for o, indices in owner_indices.items():
            in_dim = len(indices)
            self.weights[o] = nn.Parameter(torch.randn(out_features_per_owner, in_dim) * 0.01)
            self.biases[o] = nn.Parameter(torch.zeros(out_features_per_owner))

    def forward(self, x):
        # x: (batch, in_features)
        outputs = []
        for o, indices in self.owner_indices.items():
            # slice input for this owner
            x_o = x[:, indices]  # (batch, in_dim_o)
            # linear transform
            out_o = F.linear(x_o, self.weights[o], self.biases[o])  # (batch, out_per_owner)
            outputs.append(out_o)
        # concatenate along feature dimension
        return torch.cat(outputs, dim=1)

    def semantic_norm(self):
        """Compute ||W||_omega^2 = sum_o w(o) * ||W_o||_F^2."""
        norm_sq = 0.0
        for o, w in self.owner_weights.items():
            norm_sq += w * (self.weights[o].norm('fro') ** 2)
        return norm_sq

# ---------- Full Model ----------
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)  # flatten
        x = self.owner_linear(x)
        x = F.relu(x)
        x = self.fc_out(x)
        return x

    def semantic_norm_loss(self):
        """Add semantic norm penalty to the loss."""
        return self.owner_linear.semantic_norm()

# ---------- Training & Evaluation ----------
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}")

    # Data loading
    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, optimizer
    model = OwnershipMLP(hidden_per_owner=64).to(device)
    optimizer = optim.Adam(model.parameters(), lr=1e-3)

    # Train
    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()