"""

A Module to translate pathaia csv to json annotation for micromap.

It uses networkx to handle graph structures.

"""

import json

import pandas as pd

import networkx as nx

import openslide

import os

from .types import PathLike

from typing import Dict, Iterable, Tuple

import warnings

class Error(Exception):

    """

    Base of custom errors.

    **********************

    """

    pass

class BottomLeftNotFound(Error):

    """

    Raise when trying to access unknown level.

    *********************************************

    """

    pass

class NextPointNotFound(Error):

    """

    Raise when trying to access unknown level.

    *********************************************

    """

    pass

class NoPathFound(Error):

    """

    Raise when trying to access unknown level.

    *********************************************

    """

    pass

class OutOfBound(Error):

    """

    Raise when trying to access unknown level.

    *********************************************

    """

    pass

colorCycle = [

    "#f44336", "#8bc34a", "#ffeb3b", "#673ab7", "#e91e63", "#cddc39", "#9c27b0",

    "#ffc107", "#3f51b5", "#ff9800", "#2196f3", "#ff5722", "#03a9f4", "#795548",

    "#00bcd4", "#607d8b", "#009688", "#4caf50"

]

def handle_predicted_patches(

    patch_file: PathLike,

    level: int,

    column: str

):

    """

    Read a patch file.

    Read lines of the patch csv looking for 'column' label.

    Args:

        patch_file (str): absolute path to a csv patch file.

        level (int): pyramid level to query patches in the csv.

        column (str): header of the column to use to label individual patches.

    Yields:

        tuple: position and label of patches (x, y, label).

    """

    df = pd.read_csv(patch_file)

    level_df = df[df["level"] == level]

    for _, row in level_df.iterrows():

        yield row["x"], row["y"], row["dx"], row[column], column

def get_category(

    val: float,

    thresholds: Dict[int, Tuple[float, float]]

):

    """

    Return the break-apart categorical label from estimation.

    *********************************************************

    """

    for label, bounds in thresholds.items():

        low, high = bounds

        if val >= low and val < high:

            return label

    raise OutOfBound(

        "Value: {} is out of bounds for thresholds: {}!".format(val, thresholds)

    )

def gen_categorical_from_floatpreds(

    patch_file: PathLike,

    level: int,

    column: str,

    thresholds: Dict[int, Tuple[float, float]]

):

    """

    Yield categorical patches from float predictions.

    *************************************************

    """

    for patch in handle_predicted_patches(

        patch_file, level, column

    ):

        x, y, d, val, author = patch

        try:

            yield x, y, d, get_category(val, thresholds), author

        except OutOfBound:

            pass

def get_categorical_layer_edges(

    categorical_patch_generator: Iterable,

    color_dict: Dict[int, str],

    classname_dict: Dict[int, str]

):

    """

    Create graph features from patches for every layer of annotation.

    *******************************************************************

    """

    layer_nodes = dict()

    layer_edges = dict()

    layer_meta = dict()

    interval = None

    for patch in categorical_patch_generator:

        x, y, d, cl, author = patch

        if interval is None:

            interval = d

        cl_name = classname_dict[cl]

        if cl_name not in layer_nodes:

            layer_nodes[cl_name] = set()

            layer_meta[cl_name] = {

                "label": "{}_{}".format(author, cl_name),

                "author": "{}".format(author),

                "text": "",

                "color": color_dict[cl],

                "date": ""

            }

        # (x, y) is just the top left corner, to plot the polygon,

        # we will need the four corners

        layer_nodes[cl_name].add((x, y))

        layer_nodes[cl_name].add((x + interval, y))

        layer_nodes[cl_name].add((x, y + interval))

        layer_nodes[cl_name].add((x + interval, y + interval))

    for layer, nodes in layer_nodes.items():

        layer_edges[layer] = set()

        for node in nodes:

            x, y = node

            for neighbor in [

                (x + interval, y),

                (x - interval, y),

                (x, y + interval),

                (x, y - interval),

                (x - interval, y - interval),

                (x - interval, y + interval),

                (x + interval, y + interval),

                (x + interval, y - interval)

            ]:

                if neighbor in nodes:

                    layer_edges[layer].add((node, neighbor))

    return layer_edges, layer_meta, interval

def get_categorical_segments_from_edges(layer_edges: Dict):

    """

    Create segments from layer edges.

    *********************************

    """

    layer_segments = dict()

    for layer, edges in layer_edges.items():

        layer_segments[layer] = []

        # create a graph

        layer_graph = nx.Graph()

        layer_graph.add_edges_from(edges)

        for c in nx.connected_components(layer_graph):

            layer_segments[layer].append(layer_graph.subgraph(c).copy())

    return layer_segments

def get_contour_points(segment, adj=8):

    """

    Find contour points of a segment.

    *********************************

    """

    contour = []

    for pt in segment.nodes:

        if segment.degree[pt] < adj:

            contour.append(pt)

    return contour

def convert_coord(coord, slide_dims):

    """

    Compute relative coords from abs.

    *********************************

    """

    sx, sy = slide_dims

    x, y = coord

    return float(x) / sx, float(y) / sy

def find_bottom_left(pts):

    """

    Find bottom left point.

    ***********************

    """

    ymax = max([pt[1] for pt in pts])

    xmin = 100000000000

    bl = None

    for pt in pts:

        x, y = pt

        if y == ymax:

            if x <= xmin:

                bl = x, y

    if bl is not None:

        return bl

    raise BottomLeftNotFound("Did not find bottom left point of the cloud !!!")

def turn_left(orientation):

    """

    Compute a new orientation after turning on the left.

    **************************************************

    """

    new_orientation = dict()

    new_orientation["front"] = orientation["left"]

    new_orientation["left"] = orientation["back"]

    new_orientation["back"] = orientation["right"]

    new_orientation["right"] = orientation["front"]

    return new_orientation

def turn_right(orientation):

    """

    Compute a new orientation after turning on the right.

    *****************************************************

    """

    new_orientation = dict()

    new_orientation["front"] = orientation["right"]

    new_orientation["left"] = orientation["front"]

    new_orientation["back"] = orientation["left"]

    new_orientation["right"] = orientation["back"]

    return new_orientation

def turn_back(orientation):

    """

    Compute a new orientation after turning back.

    *********************************************

    """

    # basically, it's just 'turn_right' twice...

    new_orientation = turn_right(orientation)

    new_new_orientation = turn_right(new_orientation)

    return new_new_orientation

def go_to_next_point(pt, orientation, perimeter):

    """

    Compute next point in the path.

    *******************************

    """

    x, y = pt

    front = x + orientation["front"][0], y + orientation["front"][1]

    left = x + orientation["left"][0], y + orientation["left"][1]

    right = x + orientation["right"][0], y + orientation["right"][1]

    back = x + orientation["back"][0], y + orientation["back"][1]

    if left in perimeter:

        new_orientation = turn_left(orientation)

        return left, new_orientation

    if front in perimeter:

        return front, orientation

    if right in perimeter:

        new_orientation = turn_right(orientation)

        return right, new_orientation

    if back in perimeter:

        new_orientation = turn_back(orientation)

        return back, new_orientation

    raise NextPointNotFound(

        "Point {} \nhas no next point in neighborhood {} \nthat is in perimeter {}".format(

            pt, {"left": left, "front": front, "right": right, "back": back}, perimeter

        )

    )

def compute_path(pts, d):

    """

    Compute the path around a segment.

    **********************************

    """

    path = []

    # first set remaining points to the whole cloud

    perimeter = set(pts)

    # find the bottom left point

    start_point = find_bottom_left(perimeter)

    path.append(start_point)

    # set the initial orientation

    start_orientation = {

        "front": (0, -d),

        "left": (-d, 0),

        "back": (0, d),

        "right": (d, 0)

    }

    current_point, orientation = go_to_next_point(

        start_point, start_orientation, perimeter

    )

    while current_point != start_point:

        path.append(current_point)

        # remaining.remove(current_point)

        next_point, next_orientation = go_to_next_point(

            current_point, orientation, perimeter

        )

        current_point = next_point

        orientation = next_orientation

    if len(path) > 0:

        return path

    else:

        raise NoPathFound(

            "No path found for {}, with interval {}!!!".format(pts, d)

        )

def layer_segment_to_json_struct(

    interval,

    layer_segments,

    layer_meta,

    slide

):

    """

    Create the json annotation file from the segments.

    **************************************************

    """

    slide_id = os.path.basename(slide._filename)

    # annotations = {"slide_id": slide_id, "layers": dict()}

    annotations = {"slide_id": slide_id, "layers": []}

    for layer, segments in layer_segments.items():

        meta = layer_meta[layer]

        layer_annotation = {

            "id": meta["label"],

            "color": meta["color"],

            "shapes": []

        }

        # annotations["layers"][layer] = dict()

        for idx, segment in enumerate(segments):

            # create one annotation by segment

            try:

                contour = get_contour_points(segment, adj=8)

                polygon = compute_path(contour, interval)

                polygon = [convert_coord(

                    pt, slide.dimensions

                ) for pt in polygon]

                shape = {

                    "points": [

                        {"x": x * 100, "y": y * 100,

                         "status": "written"} for x, y in polygon

                    ],

                    "id": str(idx),

                    "author": meta["author"],

                    "text": meta["text"],

                    "color": meta["color"],

                    "label": meta["label"],

                    "date": meta["date"]

                }

                layer_annotation["shapes"].append(shape)

            except (NoPathFound, NextPointNotFound, BottomLeftNotFound) as e:

                warnings.warn(str(e))

        annotations["layers"].append(layer_annotation)

    return annotations