import random
from micrograd.engine import Value

class Module:
    """
    神经网络模块的基类，类似于 PyTorch 中的 nn.Module。
    所有的神经组件（Neuron, Layer, MLP）都继承自它。
    """
    def zero_grad(self):
        """
        在每一轮训练开始前，将所有参数的梯度清零。
        这是为了防止梯度在多次反向传播中累加，导致更新步长错误。
        """
        for p in self.parameters():
            p.grad = 0

    def parameters(self):
        """
        返回该模块内所有可训练的参数（Value 对象）。
        基类默认返回空列表，由子类具体实现。
        """
        return []

class Neuron(Module):
    """
    单个神经元：实现 y = Activation(sum(w_i * x_i) + b)
    """
    def __init__(self, nin, nonlin=True):
        """
        nin: 输入神经元的数量（输入维度）
        nonlin: 是否使用非线性激活函数（这里默认使用 ReLU）
        """
        # 随机初始化权重 w，范围在 -1 到 1 之间
        self.w = [Value(random.uniform(-1,1)) for _ in range(nin)]
        # 初始化偏置 b 为 0
        self.b = Value(0)
        # 是否开启非线性激活
        self.nonlin = nonlin

    def __call__(self, x):
        """
        前向传播逻辑：计算 w * x + b
        """
        # 计算加权和：sum(wi * xi for wi, xi in zip(self.w, x)) + b
        # 第二个参数 self.b 是 sum 的初始值
        act = sum((wi*xi for wi,xi in zip(self.w, x)), self.b)
        
        # 如果开启非线性，则应用 ReLU 激活函数
        return act.relu() if self.nonlin else act

    def parameters(self):
        """
        返回该神经元的所有参数：权重列表 + 偏置
        """
        return self.w + [self.b]

    def __repr__(self):
        """打印神经元时的格式化输出"""
        return f"{'ReLU' if self.nonlin else 'Linear'}Neuron({len(self.w)})"



class Layer(Module):
    """
    神经网络层：由多个神经元并行组成
    """
    def __init__(self, nin, nout, **kwargs):
        """
        nin: 输入维度
        nout: 输出维度（即这一层有多少个神经元）
        """
        # 这一层由 nout 个神经元组成，每个神经元都有 nin 个输入
        self.neurons = [Neuron(nin, **kwargs) for _ in range(nout)]

    def __call__(self, x):
        """
        前向传播：将输入 x 传给层内的每一个神经元
        """
        out = [n(x) for n in self.neurons]
        # 如果只有一个输出神经元，直接返回该值；否则返回列表
        return out[0] if len(out) == 1 else out

    def parameters(self):
        """
        收集并返回这一层所有神经元的所有参数
        """
        return [p for n in self.neurons for p in n.parameters()]

    def __repr__(self):
        """打印层信息时的格式化输出"""
        return f"Layer of [{', '.join(str(n) for n in self.neurons)}]"

class MLP(Module):
    """
    多层感知机 (Multi-Layer Perceptron)：将多个层串联起来
    """
    def __init__(self, nin, nouts):
        """
        nin: 整个网络的输入特征数
        nouts: 一个列表，定义了每一层输出的神经元数量
               例如 [4, 4, 1] 表示有两个隐藏层（各有4个神经元）和一个输出层（1个神经元）
        """
        # 将输入维度和各层输出维度合并：[nin, out1, out2, ...]
        sz = [nin] + nouts
        # 串联各层。注意：最后一层通常不使用非线性激活（nonlin=False）
        self.layers = [Layer(sz[i], sz[i+1], nonlin=i!=len(nouts)-1) for i in range(len(nouts))]

    def __call__(self, x):
        """
        前向传播：数据逐层传递（x = LayerN(...Layer1(x)...)）
        """
        for layer in self.layers:
            x = layer(x)
        return x

    def parameters(self):
        """
        递归收集整个神经网络中所有层的所有参数
        """
        return [p for layer in self.layers for p in layer.parameters()]

    def __repr__(self):
        """打印整个网络结构时的格式化输出"""
        return f"MLP of [{', '.join(str(layer) for layer in self.layers)}]"



# 使用示例：
# x = [2.0, 3.0, -1.0]
# n = MLP(3, [4, 4, 1]) # 输入维度3，两个隐藏层(4)，输出层(1)
# print(n(x))           # 得到最终预测值（一个 Value 对象）