import deps

import numpy as np
import cv2
import collections
import scipy
import scipy.cluster
import tensorflow as tf
import os

model_h5_path = "data/laps_models/laps.h5"
try:
    NEURAL_MODEL = tf.keras.models.load_model(model_h5_path, compile=False)
    from tensorflow.keras.optimizers import RMSprop
    NEURAL_MODEL.compile(RMSprop(learning_rate=0.001),
                        loss='categorical_crossentropy',
                        metrics=['categorical_accuracy'])
except Exception as e:
    print(f"Warning: Could not load model from {model_h5_path}: {e}")
    from deps.laps import model as NEURAL_MODEL


def laps_intersections(lines):
    __lines = [[(a[0], a[1]), (b[0], b[1])] for a, b in lines]
    return deps.geometry.isect_segments(__lines)


def laps_cluster(points, max_dist=10):
    Y = scipy.spatial.distance.pdist(points)
    Z = scipy.cluster.hierarchy.single(Y)
    T = scipy.cluster.hierarchy.fcluster(Z, max_dist, 'distance')
    clusters = collections.defaultdict(list)
    for i in range(len(T)):
        clusters[T[i]].append(points[i])
    clusters = clusters.values()
    clusters = map(lambda arr: (np.mean(np.array(arr)[:, 0]),
                                np.mean(np.array(arr)[:, 1])), clusters)
    return list(clusters)


def laps_detector(img):
    global NC_LAYER

    hashid = str(hash(img.tostring()))

    img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    img = cv2.threshold(img, 0, 255, cv2.THRESH_OTSU)[1]
    img = cv2.Canny(img, 0, 255)
    img = cv2.resize(img, (21, 21), interpolation=cv2.INTER_CUBIC)

    imgd = img

    X = [np.where(img > int(255/2), 1, 0).ravel()]
    X = X[0].reshape([-1, 21, 21, 1])

    img = cv2.dilate(img, None)
    mask = cv2.copyMakeBorder(img, top=1, bottom=1, left=1, right=1,
                              borderType=cv2.BORDER_CONSTANT, value=[255, 255, 255])
    mask = cv2.bitwise_not(mask)
    i = 0
    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL,
                                   cv2.CHAIN_APPROX_NONE)

    _c = np.zeros((23, 23, 3), np.uint8)

    for cnt in contours:
        (x, y), radius = cv2.minEnclosingCircle(cnt)
        x, y = int(x), int(y)
        approx = cv2.approxPolyDP(cnt, 0.1*cv2.arcLength(cnt, True), True)
        if len(approx) == 4 and radius < 14:
            cv2.drawContours(_c, [cnt], 0, (0, 255, 0), 1)
            i += 1
        else:
            cv2.drawContours(_c, [cnt], 0, (0, 0, 255), 1)

    if i == 4:
        return (True, 1)

    pred = NEURAL_MODEL.predict(X)
    a, b = pred[0][0], pred[0][1]
    t = a > b and b < 0.03 and a > 0.975

    if t:
        return (True, pred[0])
    else:
        return (False, pred[0])

################################################################################


def LAPS(img, lines, size=10):

    __points, points = laps_intersections(lines), []

    for pt in __points:
        pt = list(map(int, pt))

        lx1 = max(0, int(pt[0]-size-1))
        lx2 = max(0, int(pt[0]+size))
        ly1 = max(0, int(pt[1]-size))
        ly2 = max(0, int(pt[1]+size+1))

        dimg = img[ly1:ly2, lx1:lx2]
        dimg_shape = np.shape(dimg)

        if dimg_shape[0] <= 0 or dimg_shape[1] <= 0:
            continue

        re_laps = laps_detector(dimg)
        if not re_laps[0]:
            continue

        if pt[0] < 0 or pt[1] < 0:
            continue
        points += [pt]
    points = laps_cluster(points)

    return points