import time

import cv2
import numpy as np
import random
import onnxruntime as ort
from config_files.yolo_config import CLASS_NUM
from typing import List, Tuple


class Inference:
    def __init__(self, onnx_model_path, model_input_shape, classes_txt_file, run_with_cuda):
        self.model_path = onnx_model_path
        self.model_shape = model_input_shape
        self.classes_path = classes_txt_file
        self.cuda_enabled = run_with_cuda
        self.letter_box_for_square = True
        self.model_score_threshold = 0.3
        self.model_nms_threshold = 0.6
        self.classes = []
        self.session = None

        self.load_onnx_network()
        self.load_classes_from_file()

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

    def run_inference(self, input_image):
        model_input = input_image
        # print(input_image)
        if self.letter_box_for_square and self.model_shape[0] == self.model_shape[1]:
            model_input = self.format_to_square(model_input)

        blob = cv2.dnn.blobFromImage(model_input, 1.0 / 255.0, self.model_shape, (0, 0, 0), True, False)

        # Prepare input data as a dictionary
        inputs = {self.session.get_inputs()[0].name: blob}
        # Run model
        outputs = self.session.run(None, inputs)
        outputs_bbox = outputs[0]
        outputs_mask = outputs[1]
        detections = self.process_detections(outputs_bbox, model_input)
        mask_maps = self.process_mask_output(detections, outputs_mask, model_input.shape)
        return detections, mask_maps

    def load_onnx_network(self):
        # Set up the ONNX Runtime session with appropriate device settings
        try:
            if self.cuda_enabled:
                providers = [('CUDAExecutionProvider', {'device_id': 0})]
            else:
                providers = ['CPUExecutionProvider']

            self.session = ort.InferenceSession(self.model_path, providers=providers)
            print(f"Running on {'CUDA' if self.cuda_enabled else 'CPU'}")
            print(f"Model loaded successfully. Input name: {self.session.get_inputs()[0].name}")
        except Exception as e:
            print(f"Failed to load the ONNX model: {e}")
            self.session = None

    def load_classes_from_file(self):
        with open(self.classes_path, 'r') as f:
            self.classes = f.read().strip().split('\n')

    def format_to_square(self, source):
        col, row = source.shape[1], source.shape[0]
        max_side = max(col, row)
        result = np.zeros((max_side, max_side, 3), dtype=np.uint8)
        result[0:row, 0:col] = source
        return result

    def process_detections(self, outputs_bbox, model_input):
        # Assuming outputs_bbox is already in the (x, y, w, h, confidence, class_probs...) format
        x_factor = model_input.shape[1] / self.model_shape[0]
        y_factor = model_input.shape[0] / self.model_shape[1]

        t1 = time.time()
        # Assuming outputs_bbox is an array with shape (N, 4+CLASS_NUM+32) where N is the number of detections
        # Example outputs_bbox.shape -> (batch_size, 4+CLASS_NUM+32, 8400)

        # Extract basic bbox coordinates and scores
        x, y, w, h = outputs_bbox[:, 0], outputs_bbox[:, 1], outputs_bbox[:, 2], outputs_bbox[:, 3]
        scores = outputs_bbox[:, 4:4 + CLASS_NUM]

        # Calculate confidences and class IDs
        confidences = np.max(scores, axis=1)
        class_ids = np.argmax(scores, axis=1)

        # Filter out small boxes
        min_width, min_height = 20, 20
        valid_size = (w >= min_width) & (h >= min_height)

        # Apply confidence threshold
        valid_confidence = (confidences > self.model_score_threshold)

        # Combine all conditions
        valid_detections = valid_size & valid_confidence

        # proto_mask_score
        scores_segmentation = outputs_bbox[:, 4 + CLASS_NUM:]

        # Filter arrays based on valid detections
        filtered_x = x[valid_detections]
        filtered_y = y[valid_detections]
        filtered_w = w[valid_detections]
        filtered_h = h[valid_detections]
        filtered_confidences = confidences[valid_detections]
        filtered_class_ids = class_ids[valid_detections]
        filtered_mask_coefficient = np.transpose(scores_segmentation, (2,0,1))[valid_detections.T]


        # Calculate adjusted box coordinates
        left = (filtered_x - 0.5 * filtered_w) * x_factor
        top = (filtered_y - 0.5 * filtered_h) * y_factor
        width = filtered_w * x_factor
        height = filtered_h * y_factor

        # Prepare final arrays
        boxes = np.vstack([left, top, width, height]).T

        # Change it into int for mask operation
        boxes = boxes.astype(int)
        boxes = boxes.tolist()
        filtered_confidences = filtered_confidences.tolist()
        filtered_class_ids = filtered_class_ids.tolist()
        if not len(boxes) <= 0 :
            indices = cv2.dnn.NMSBoxes(boxes, filtered_confidences, self.model_score_threshold, self.model_nms_threshold)
        else:
            indices = []

        detections = []
        for i in indices:
            idx = i
            result = {
                'class_id': filtered_class_ids[i],
                'confidence': filtered_confidences[i],
                'mask_coefficients': np.array(filtered_mask_coefficient[i]),
                'box': boxes[idx],
                'class_name': self.classes[filtered_class_ids[i]],
                'color': (random.randint(100, 255), random.randint(100, 255), random.randint(100, 255))
            }
            detections.append(result)

        return detections

    def process_mask_output(self, detections, proto_masks, image_shape):
        if not detections:
            return []

        batch_size, num_protos, proto_height, proto_width = proto_masks.shape
        full_masks = np.zeros((len(detections), image_shape[0], image_shape[1]), dtype=np.float32)

        for idx, det in enumerate(detections):
            box = det['box']

            x1, y1, w, h = self.adjust_box_coordinates(box, (image_shape[0], image_shape[1]))

            if w <=1 or h <= 1:
                continue

            # Get the corresponding mask coefficients for this detection
            coeffs = det["mask_coefficients"]

            # Compute the linear combination of proto masks
            # for now, plural batch operation is not supported, and this is the point where you should start.
            # instead of hardcoded proto_masks[0], do some iterative/vectorize operation
            mask = np.tensordot(coeffs, proto_masks[0], axes=[0, 0])  # Dot product along the number of prototypes

            # Resize mask to the bounding box size, using sigmoid to normalize
            resized_mask = cv2.resize(mask, (w, h))
            resized_mask = self.sigmoid(resized_mask)

            # Threshold to create a binary mask
            final_mask = (resized_mask > 0.5).astype(np.uint8)

            # Place the mask in the corresponding location on a full-sized mask image_binary
            full_mask = np.zeros((image_shape[0], image_shape[1]), dtype=np.uint8)
            full_mask[y1:y1+h, x1:x1+w] = final_mask

            # Combine the mask with the masks of other detections
            full_masks[idx] = full_mask


        all_mask = full_masks.sum(axis=0)
        all_mask = np.clip(all_mask, 0, 1)
        # Append a dimension so that cv2 can understand ```all_mask``` argument as an image.
        # This is because for this particular application, there is only single class ```water_body```
        # However, if that is not the case, you must modify this part.
        all_mask = all_mask.reshape((image_shape[0], image_shape[1], 1))
        return all_mask.astype(np.uint8)

    def adjust_box_coordinates(self, box: List[int], image_shape: Tuple[int, int]) -> Tuple[int, int, int, int]:
        """
        Adjusts bounding box coordinates to ensure they lie within image boundaries.
        """
        x1, y1, w, h = box
        x2, y2 = x1 + w, y1 + h

        # Clamp coordinates to image boundaries
        x1 = max(0, x1)
        y1 = max(0, y1)
        x2 = min(image_shape[1], x2)
        y2 = min(image_shape[0], y2)

        # Recalculate width and height
        w = x2 - x1
        h = y2 - y1

        return x1, y1, w, h


    def load_classes_from_file(self):
        with open(self.classes_path, 'r') as f:
            self.classes = f.read().strip().split('\n')

    def format_to_square(self, source):
        col, row = source.shape[1], source.shape[0]
        max_side = max(col, row)
        result = np.zeros((max_side, max_side, 3), dtype=np.uint8)
        result[0:row, 0:col] = source
        return result

def overlay_mask(image, mask, color=(0, 255, 0), alpha=0.5):
    """
    Overlays a mask onto an image_binary using a specified color and transparency level.

    Parameters:
        image (np.ndarray): The original image_binary.
        mask (np.ndarray): The mask to overlay. Must be the same size as the image_binary.
        color (tuple): The color for the mask overlay in BGR format (default is green).
        alpha (float): Transparency factor for the mask; 0 is fully transparent, 1 is opaque.

    Returns:
        np.ndarray: The image_binary with the overlay.
    """
    assert alpha <= 1 and 0 <= alpha, (f"Error! invalid alpha value, it must be float, inbetween including 0 to 1, "
                                       f"\n given alpha : {alpha}")

    # Ensure the mask is a binary mask
    mask = (mask > 0).astype(np.uint8)  # Convert mask to binary if not already

    # Create an overlay with the same size as the image_binary but only using the mask area
    overlay = np.zeros_like(image, dtype=np.uint8)
    overlay[mask == 1] = color

    # Blend the overlay with the image_binary using the alpha factor
    return cv2.addWeighted(src1=overlay, alpha=alpha, src2=image, beta=1 - alpha, gamma=0)


def test():
    import time

    # Path to your ONNX model and classes text file
    model_path = 'yoloseg/weight/best.onnx'
    classes_txt_file = 'config_files/yolo_config.txt'
    # image_path = 'yoloseg/img3.jpg'
    image_path = 'yoloseg/img3.jpg'

    model_input_shape = (640, 640)
    inference_engine = Inference(
        onnx_model_path=model_path,
        model_input_shape=model_input_shape,
        classes_txt_file=classes_txt_file,
        run_with_cuda=True
    )

    # Load an image_binary
    img = cv2.imread(image_path)
    if img is None:
        print("Error loading image_binary")
        return
    img = cv2.resize(img, model_input_shape)
    # Run inference

    for i in range(10):
        t1 = time.time()
        detections, mask_maps = inference_engine.run_inference(img)
        t2 = time.time()
        print(t2 - t1)



    # Display results
    for detection in detections:
        x, y, w, h = detection['box']
        class_name = detection['class_name']
        confidence = detection['confidence']
        cv2.rectangle(img, (x, y), (x+w, y+h), detection['color'], 2)
        label = f"{class_name}: {confidence:.2f}"
        cv2.putText(img, label, (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, detection['color'], 2)

    # Show the image_binary
    # cv2.imshow('Detections', img)
    # cv2.waitKey(0)
    # cv2.destroyAllWindows()

    # If you also want to display segmentation maps, you would need additional handling here
    # Example for displaying first mask if available:
    if len(mask_maps) != 0:

        seg_image = overlay_mask(img, mask_maps[:,:,0], color=(0, 255, 0), alpha=0.3)
        cv2.imshow("segmentation", seg_image)
        cv2.waitKey(0)
        cv2.destroyAllWindows()


if __name__ == "__main__":
    test()