from skimage.io import imread,imsave, imshow
from skimage import img_as_float
import skimage
import numpy
from PIL import Image
import os

class DataImage():
    def __init__(self,input_image_path):
        self.im_float = ""
        self.input_image_path = input_image_path

    def resize_image(self):
        input_image_path = self.input_image_path
        size = (35, 35)
        output_image_path = "asx.png"
        original_image = Image.open(input_image_path)
        width, height = original_image.size


        resized_image = original_image.resize(size)
        width, height = resized_image.size

        resized_image.save(output_image_path)
        self.output = output_image_path

    def image(self):
        numpy.set_printoptions(threshold=numpy.nan)
        im = imread(self.output)
        im_float = img_as_float(im)
        im_float = numpy.asarray(skimage.color.rgb2grey(im_float))
        imsave("123.png",im_float)

        return im_float.reshape(-1)





class NeuralNet:
    def __init__(self, inp, hid, out, epsilon):

        self.inp = inp
        self.hid = hid
        self.out = out

        import random
        self.wa = []
        self.wb = []

        for i in range(self.inp):
            weights_row = []
            for j in range(self.hid):
                weights_row.append(random.uniform(-epsilon, epsilon))
            self.wa.append(weights_row)

        for i in range(self.hid):
            weights_row = []
            for j in range(self.out):
                weights_row.append(random.uniform(-epsilon, epsilon))
            self.wb.append(weights_row)

    def sigmoid(self, x):
        return 1 / (1 + math.exp(-x))

    def y(self, x):

        hidden_values = []
        for j in range(self.hid):
            yj = 0
            for i in range(self.inp):
                yj += x[i] * self.wa[i][j]

            yj = self.sigmoid(yj)
            hidden_values.append(yj)

        output_values = []
        for k in range(self.out):
            zk = 0
            for j in range(self.hid):
                zk += hidden_values[j] * self.wb[j][k]

            zk = self.sigmoid(zk)
            output_values.append(zk)

        return output_values

    def train(self, x_data, y_data, eta):
        for t in range(len(x_data)):

            hidden_values = []
            for j in range(self.hid):
                yj = 0
                for i in range(self.inp):
                    yj += x_data[t][i] * self.wa[i][j]

                yj = self.sigmoid(yj)
                hidden_values.append(yj)

            output_values = []
            for k in range(self.out):
                zk = 0
                for j in range(self.hid):
                    zk += hidden_values[j] * self.wb[j][k]

                zk = self.sigmoid(zk)
                output_values.append(zk)

            delta_k = []
            for k in range(self.out):
                delta_k.append((output_values[k] - y_data[t][k]) * output_values[k] * (1 - output_values[k]))

            delta_j = []
            for j in range(self.hid):
                s = 0
                for k in range(self.out):
                    s += delta_k[k] * self.wb[j][k]
                delta_j.append(s * hidden_values[j] * (1 - hidden_values[j]))

            for j in range(self.hid):
                for k in range(self.out):
                    self.wb[j][k] -= eta * delta_k[k] * hidden_values[j]

            for i in range(self.inp):
                for j in range(self.hid):
                    self.wa[i][j] -= eta * delta_j[j] * x_data[t][i]


import random
import pickle
import numpy as np
import matplotlib.pyplot as plt
import time
import math
import os

nn = NeuralNet(1225,400,160,0.1)

main_directory = "C:\\shared\\MAILHACK\\train"
not_main_directory = os.listdir(main_directory)
count = 0
number =1000000

for l in range(len(not_main_directory)):
    i = random.randint(0,len(not_main_directory)-1 )
    files = os.listdir("C:\\shared\\MAILHACK\\train\\" + not_main_directory[i])
    for k in range(len(files)-1):
        j = random.randint(0,len(files)-1)
        count +=1
        if files[j][files[j].find("."):] == ".jpg" or files[j][files[j].find("."):] == ".png":
            im = DataImage("C:\\shared\\MAILHACK\\train\\" + not_main_directory[i] + '\\' + files[j])
            im.resize_image()
            pix = im.image()
            number = int(not_main_directory[i][:not_main_directory[i].find(" ")]) + 1
            mass = [0] * 160
            mass[number] = 1
            prediction = np.array(nn.y(pix))
            real = mass
            loss = 0.5 * np.sum((prediction - real) ** 2)
            print(prediction)
            print(real)
            print(loss)
            print(count)
            print(files[j])
            x_train = [pix]
            y_train = [real]
            nn.train(x_train, y_train, 0.1)