# coding=UTF-8
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import axes3d, Axes3D
from numpy import random as rand
import numpy as np
import functools as fnc


dimensions = 8


def dist(p1, p2):
    return np.sqrt(
        np.power(p2[0]-p1[0], 2) +
        np.power(p2[1]-p1[1], 2) +
        np.power(p2[2]-p1[2], 2) +
        np.power(p2[3]-p1[3], 2) +
        np.power(p2[4]-p1[4], 2) +
        np.power(p2[5]-p1[5], 2) +
        np.power(p2[6]-p1[6], 2) +
        np.power(p2[7]-p1[7], 2)
    )

# napisałem własną, bo jakoś nie wierzyłem w twoją
def distance(a, b):
    distances = [a[x] - b[x] for x in range(dimensions)]
    distances = [d**2 for d in distances]
    return np.sqrt(sum(distances))

points = [
    (float(x.split()[0]),
     float(x.split()[1]),
     float(x.split()[2]),
     float(x.split()[3]),
     float(x.split()[4]),
     float(x.split()[5]),
     float(x.split()[6]),
     float(x.split()[7])) for x in open('yeast.txt', 'r').readlines()
    ]


# wszystkie wartości w pliku są z przedziału 0 - 1, wystarczy numpy.random, żeby losować takie liczby
# python.random musi mieć argumenty, np nie
clusters = 2
c = [(
         rand.uniform(),
         rand.uniform(),
         rand.uniform(),
         rand.uniform(),
         rand.uniform(),
         rand.uniform(),
         rand.uniform(),
         rand.uniform()
     ) for _ in range(clusters)]


# nie możesz losować pozycji poprzedniego punktu, bo może się okazać, że będzie on bliżej niż aktualny
# musisz mieć pewność, że jest on dalej. Nic nie jest bardziej pewne niż nieskończoność
old_c = [(
             float("inf"),
             float("inf"),
             float("inf"),
             float("inf"),
             float("inf"),
             float("inf"),
             float("inf"),
             float("inf"),
         ) for _ in range(clusters)]
c_moved = [[] for _ in range(clusters)]
c_affiliation = [[] for _ in range(clusters)]

while True:
    for p in points:
        # tmp_c = 0

        # stworzyłem liste odległości punktu od każdego klastru, potem szukam jaki indeks (czyli indeks klastru też)
        # to chyba był błąd krytyczny ten if, nie wiem czemu, ale zawsze wg. niego pierwszy klaster leżał bliżej niż drugi
        # wstawiłem tu nawet warunkowego breakpointa gdy drugi punkt jest bliżej, ale nigdy się nie pokazał
        vDist = []
        for i in range(clusters):
            vDist.append(distance(p, c[i]))
            # if distance(p, c[i]) < distance(p, c[tmp_c]):
            #     tmp_c = i
        iBelong = vDist.index(min(vDist))
        c_affiliation[iBelong].append(p)

    # print(c_affiliation[0])
    # print(c_affiliation[1])
    # print("-------------------------")

    # tu musi być obsluga błędów, bo klaster może nie mieć żadnych punktów
    for i in range(clusters):
        c[i] = (
            fnc.reduce(lambda x, y: x + y, [j[0] for j in c_affiliation[i]]) / len(c_affiliation[i]),
            fnc.reduce(lambda x, y: x + y, [j[1] for j in c_affiliation[i]]) / len(c_affiliation[i]),
            fnc.reduce(lambda x, y: x + y, [j[2] for j in c_affiliation[i]]) / len(c_affiliation[i]),
            fnc.reduce(lambda x, y: x + y, [j[3] for j in c_affiliation[i]]) / len(c_affiliation[i]),
            fnc.reduce(lambda x, y: x + y, [j[4] for j in c_affiliation[i]]) / len(c_affiliation[i]),
            fnc.reduce(lambda x, y: x + y, [j[5] for j in c_affiliation[i]]) / len(c_affiliation[i]),
            fnc.reduce(lambda x, y: x + y, [j[6] for j in c_affiliation[i]]) / len(c_affiliation[i]),
            fnc.reduce(lambda x, y: x + y, [j[7] for j in c_affiliation[i]]) / len(c_affiliation[i])
        )

    error = 0.001
    flag = False
    # for i in range(clusters):
    #     if not (abs(c[i][0] - old_c[i][0]) < error * (len(points[:][0])*0.1) and abs(c[i][1] - old_c[i][1]) < error):
    #         flag = True

    # tutaj wystarczy sprawdzić czy odległość punktu poprzedniego od aktualnego jest większa od błędu, jak tak to lecimy dalej
    # nawet mi się nie chciało czytać tego ifa - tak nasrane tam
    for i in range(clusters):
        if distance(c[i], old_c[i]) > error:
            flag = True

    if flag:
        for i in range(clusters):
            c_moved[i].append(old_c[i])
        old_c = np.copy(c)
        c_affiliation.clear()
        c_affiliation = [[] for _ in range(clusters)]
    else:
        print(c_affiliation[0])
        print(c_affiliation[1])
        break

# print(c_affiliation)
display_points = [[c_affiliation[ci][pi][:3] for ci in range(clusters) for pi in range(len(c_affiliation[ci]))]]
display_centroids = [c[i][:3] for i in range(clusters)]

fig = plt.figure()
#ax = fig.add_subplot(111, projection='3d')
ax = Axes3D(fig)

# for i in range(clusters-1):
#     ax.scatter(*zip(*display_points[i]), marker='x', c=np.random.rand(3, 1))

# nie chciało mi się ogarniać jak Ty to wyświetlasz, ale nawet jak udało mi się podzielić ten zbiór to punkty były
# wyświetlane w tym samym kolorze
c_affiliation[0] = [x[:3] for x in c_affiliation[0]]
c_affiliation[1] = [x[:3] for x in c_affiliation[1]]
print(c_affiliation)

ax.scatter(*zip(*c_affiliation[0]), marker='x', c='black')
ax.scatter(*zip(*c_affiliation[1]), marker='x', c='red')
ax.scatter(*zip(*display_centroids), marker='o', c='red', s=75)
plt.show()