# -*- coding: cp1251 -*-

#Задания 1 и 2
#Нужная функция-активатор подставляется в конструктор нейронной сети
#Да здравствует ООП и инкапсуляция! Нет сишному подходу с кучей несявязанных данных!
import typing
import math



class AbstractNeuronInput:
    def calculate(self) -> float:
        pass

#Decorator pattern
#Взвешенный вход нейросети
class NeuronWeightedInput(AbstractNeuronInput):
    __weight: float
    __input: AbstractNeuronInput

    def __init__(self, weight: float, input: AbstractNeuronInput):
        self.__weight = weight
        self.__input = input

    def calculate(self) -> float:
        return self.__weight * self.__input.calculate()

#Первичный вход нейросети, получающий
#числа на вход
class PrimaryNeuronInput(AbstractNeuronInput):
    __value: float = 0.0

    def upgrade(self, value: float) -> None:
        self.__value = value;

    def calculate(self) -> float:
        return self.__value


InputsList = typing.List[NeuronWeightedInput]
PrimaryInputsList = typing.List[PrimaryNeuronInput]
ActivatorFunction = typing.Callable[[float], float]
#Каждый нейрон может стать входом для другого нейрона
class Neuron(AbstractNeuronInput):
    __activator: ActivatorFunction
    __inputs: InputsList
    __bias: float

    def __init__(self, bias: float, activator: ActivatorFunction, inputs: InputsList):
        self.__activator = activator
        self.__inputs = inputs
        self.__bias = bias

    def calculate(self) -> float:
        return self.__activator(sum(input.calculate() for input in self.__inputs) + self.__bias)


#Строится нейросеть из нейронов
#При этом любая нейросеть может
#быть частью другой нейросети
class CustomNeuralNetwork(AbstractNeuronInput):
    __inputs: PrimaryInputsList = []
    __root: AbstractNeuronInput

    def __init__(self, activator: ActivatorFunction) -> None:
        input_1 = PrimaryNeuronInput()
        input_2 = PrimaryNeuronInput()

        internal_1 = Neuron(0, activator, [
                NeuronWeightedInput(0, input_1),
                NeuronWeightedInput(1, input_2),
            ])
        internal_2 = Neuron(0, activator, [
                NeuronWeightedInput(0, input_1),
                NeuronWeightedInput(1, input_2),
            ])

        self.__root = Neuron(0, activator, [
                NeuronWeightedInput(0, internal_1),
                NeuronWeightedInput(1, internal_2),
            ])

        self.__inputs.append(input_1)
        self.__inputs.append(input_2)

    def calculate(self) -> float:
        return self.__root.calculate()

    #Обновляем только в случае, если
    #нам прислали на вход столько же
    #значений, сколько входов у нейросети
    def upgrade(self, values: typing.List[float]):
        if(len(self.__inputs) == len(values)):
            for index in range(len(values)):
                self.__inputs[index].upgrade(values[index])

        return self



def sigmoid(x: float) -> float:
    return 1 / (1 + math.exp(-x))
def relu(x: float) -> float:
    return max(x, 0)

#Можно подставить любую функцию-активатор
#activator = math.tanh
#activator = sigmoid
activator = relu

network = CustomNeuralNetwork(activator)
print(network.upgrade([2, 3]).calculate())