import numpy as np
import re

def main():

    choiceSettings = input("Use file settings?(y/n): ")

    if choiceSettings.lower() == "y":
        settingsFile = open("Settings.txt", "r")
        buffer = settingsFile.readlines()
        settingsFile.close()

        inputLayerSize, hiddenLayersCount, outputLayerSize = [int(i) for i in buffer[0].split()]

        hiddenLayerSize = [float(i) for i in buffer[1].split()]

        rangeValuesInput = [list(i) for i in list(zip(*[iter([float(i) for i in buffer[2].split()])] * 2))]

        rangeValuesOutput = [list(i) for i in list(zip(*[iter([float(i) for i in buffer[3].split()])] * 2))]
    else:
        #Entering params of NN
        inputLayerSize = int(input("InputLayerSize: "))
        hiddenLayersCount = int(input("HiddenLayersCount: "))
        hiddenLayerSize = [0] * hiddenLayersCount
        for i in range(hiddenLayersCount):
            hiddenLayerSize[i] = int(input("HiddenLayerSize[" + str(i) + "]: "))
        outputLayerSize = int(input("OutputLayerSize: "))

        rangeValuesInput = [0] * inputLayerSize
        for i in range(inputLayerSize):
            rangeValuesInput[i] = [float(j) for j in input("RangeValuesInput[" + str(i) + "]: ").split()]

        rangeValuesOutput = [0] * outputLayerSize
        for i in range(outputLayerSize):
            rangeValuesOutput[i] = [float(j) for j in input("RangeValuesOutput[" + str(i) + "]: ").split()]

        ##############################################
        settingsFile = open("Settings.txt", "w")
        buffer = [""] * 4
        buffer[0] = str(inputLayerSize) + " " + str(hiddenLayersCount) + " " + str(outputLayerSize) + "\n"
        for i in range(hiddenLayersCount):
            buffer[1] += (str(hiddenLayerSize[i]))
            if i != hiddenLayersCount - 1:
                buffer[1] += " "
            else:
                buffer[1] += "\n"

        for i in range(inputLayerSize):
            buffer[2] += str(rangeValuesInput[i][0]) + " " + str(rangeValuesInput[i][1])
            if i != inputLayerSize - 1:
                buffer[2] += " "
            else:
                buffer[2] += "\n"

        for i in range(outputLayerSize):
            buffer[3] += str(rangeValuesOutput[i][0]) + " " + str(rangeValuesOutput[i][1])
            if i != outputLayerSize - 1:
                buffer[3] += " "
            else:
                buffer[3] += "\n"

        settingsFile.writelines(buffer)
        settingsFile.close()
        ##############################################

    choiceTests = input("Use file tests?(y/n): ")

    if choiceTests.lower() == "y":
        testsFile = open("Tests.txt", "r")
        buffer = testsFile.readlines()
        testsFile.close()

        testsCount = int(buffer[0])

        tests = [list(i) for i in list(zip(*[iter([float(i) for i in buffer[1].split()])] * inputLayerSize))]

        answers = [list(i) for i in list(zip(*[iter([float(i) for i in buffer[2].split()])] * outputLayerSize))]

        iterationsCount = int(buffer[3])
        epsError = float(buffer[4])
    else:
        testsCount = int(input("TestsCount: "))

        tests = [0] * testsCount
        answers = [0] * testsCount

        for i in range(testsCount):
            #Entering tests of NN
            tests[i] = [float(j) for j in input("Test[" + str(i) + "]: ").split()]

            answers[i] = [float(j) for j in input("Answer[" + str(i) + "]: ").split()]

            #Scaling data
            for j in range(inputLayerSize):
                tests[i][j] = scale(tests[i][j], rangeValuesInput[j][0], rangeValuesInput[j][1], 0, 1)

            for j in range(outputLayerSize):
                answers[i][j] = scale(answers[i][j], rangeValuesOutput[j][0], rangeValuesOutput[j][1], 0, 1)

        iterationsCount = int(input("IterationsCount: "))
        #Minimum error
        epsError = float(input("EpsError: "))

        ##############################################
        testsFile = open("Tests.txt", "w")

        buffer = [""] * 5
        buffer[0] = str(testsCount) + "\n"
        for i in range(testsCount):
            for j in range(inputLayerSize):
                buffer[1] += str(tests[i][j])
                if i != inputLayerSize - 1 or i != testsCount - 1:
                    buffer[1] += " "
            if i == testsCount - 1:
                buffer[1] += "\n"

        for i in range(testsCount):
            for j in range(outputLayerSize):
                buffer[2] += str(answers[i][j])
                if j != outputLayerSize - 1 or i != testsCount - 1:
                    buffer[2] += " "
            if i == testsCount - 1:
                buffer[2] += "\n"

        buffer[3] = str(iterationsCount) + "\n"
        buffer[4] = str(epsError) + "\n"

        testsFile.writelines(buffer)
        testsFile.close()
        ##############################################

    choiceWeights = "n"
    if choiceSettings.lower() == "y" and choiceTests.lower() == "y":
        choiceWeights = input("Use file weights?(y/n): ")

    if choiceWeights.lower() == "y":
        weights = []
        for i in range(hiddenLayersCount + 1):
            weights.append(np.loadtxt("Weights.txt"))
        print(weights)
    else:

        #Making np.array from list
        mTests = np.array(tests)
        mAnswers = np.array(answers)

        weights = [0] * (hiddenLayersCount + 1)
        #Randomize weights
        weights[0] = 2 * np.random.random((inputLayerSize, hiddenLayerSize[0])) - 1
        for i in range(1, hiddenLayersCount):
            weights[i] = 2 * np.random.random((hiddenLayerSize[i-1], hiddenLayerSize[i])) - 1
        weights[hiddenLayersCount] = 2 * np.random.random((hiddenLayerSize[hiddenLayersCount - 1], outputLayerSize)) - 1

        layers = [0] * (hiddenLayersCount + 2)
        layers[0] = mTests

        errors = [0] * (hiddenLayersCount + 1)
        deltas = [0] * (hiddenLayersCount + 1)

        #Main loop of learning
        for i in range(iterationsCount):
            #Calculating layers
            for j in range(1, hiddenLayersCount + 2):
                layers[j] = sigmoid(np.dot(layers[j - 1], weights[j - 1]))

            #Main error
            errors[hiddenLayersCount] = mAnswers - layers[hiddenLayersCount + 1]

            #Checking the value of main error
            if (np.mean(np.abs(errors[hiddenLayersCount])) < epsError):
                break

            #The last delta
            deltas[hiddenLayersCount] = sigmoid(layers[hiddenLayersCount + 1], True) * errors[hiddenLayersCount]

            #Calculating errors and deltas
            for j in range(hiddenLayersCount, 0, -1):
                errors[j - 1] = np.dot(deltas[j], weights[j].T)
                deltas[j - 1] = sigmoid(layers[j], True) * errors[j - 1]

            #Changing weights
            for j in range(hiddenLayersCount + 1, 0, -1):
                weights[j - 1] += np.dot(layers[j-1].T, deltas[j - 1])

            if i % 100 == 0:
                print("Error:", str(np.mean(np.abs(errors[hiddenLayersCount]))))

        buffer = []
        for i in weights:
            buffer.append(" ".join(str(i).split()))
        fileWeights = open("Weights.txt", "w")
        #print(buffer)

    #Main loop of working
    while True:
        #Input data
        inputLayer  = [float(i) for i in input("InputLayer: ").split()]

        #Calculating layers
        layers[0] = np.array(inputLayer)
        for i in range(1, hiddenLayersCount + 2):
            layers[i] = sigmoid(np.dot(layers[i - 1], weights[i - 1]))

        #Output data
        for i in range(outputLayerSize):
            print("Answer[" + str(i) + "]: " + str(int(scale(layers[hiddenLayersCount + 1][i], 0, 1, rangeValuesOutput[i][0], rangeValuesOutput[i][1]) + 0.5)))

"""
sigmoid(x, deriv = False)
returns sigmoid if deriv = False
else returns derivative if x = sigmoid(a)
"""
def sigmoid(x, deriv = False):
    if deriv:
        return x * (1 - x)
    return 1 / (1 + np.exp(-x))

def scale(oldValue, oldMin, oldMax, newMin, newMax):
    return (((oldValue - oldMin) * (newMax - newMin)) / (oldMax - oldMin)) + newMin

if __name__ == "__main__":
    main()