import logging
import os
from typing import Dict
from xml.etree import ElementTree
from urllib.parse import urlparse

import cv2
import imagehash
import librosa
import numpy as np
from PIL import Image
from fastdtw import fastdtw
from scipy.spatial.distance import cosine
from skimage.metrics import structural_similarity as ssim

logger = logging.getLogger("desktopenv.metrics.vlc")


def is_vlc_playing(actual_status_path: str, rule: Dict[str, str]) -> float:
    """
    Checks if VLC is currently playing a file.
    """
    with open(actual_status_path, "rb") as file:
        actual_status = file.read().decode("utf-8")

    tree = ElementTree.fromstring(actual_status)
    status = tree.find("state").text
    logger.info(f"VLC Status: {status}")
    if status == "playing":
        if rule["type"] == "file_name":
            # Try multiple possible paths for file information in VLC XML
            file_paths = [
                'information/category[@name="meta"]/info[@name="filename"]',
                'information/category[@name="meta"]/info[@name="title"]',
                'information/category[@name="meta"]/info[@name="uri"]',
                'information/category[@name="meta"]/info[@name="location"]',
                'information/category[@name="meta"]/info[@name="name"]',
            ]

            file_info = None
            for path in file_paths:
                element = tree.find(path)
                if element is not None and element.text:
                    file_info = element.text
                    break

            if file_info:
                expected_filename = rule["file_name"]

                # Method 1: Direct filename match (most precise)
                actual_basename = os.path.basename(file_info)
                if actual_basename == expected_filename:
                    return 1

                # Method 2: Endswith match (for backward compatibility)
                if file_info.endswith(expected_filename):
                    return 1

                # Method 3: For paths, check if expected filename is in the path
                if expected_filename in file_info:
                    # Additional check to avoid false positives
                    # Make sure it's actually the filename, not just part of a path
                    if file_info.endswith("/" + expected_filename) or file_info.endswith("\\" + expected_filename):
                        return 1

                logger.warning(f"File name mismatch - Expected: {expected_filename}, Found: {file_info}")
                return 0
            else:
                logger.warning(f"Could not find file information in VLC status XML for rule: {rule}")
                return 0
        elif rule["type"] == "url":
            # Try multiple possible paths for URL information in VLC XML
            url_paths = [
                'information/category[@name="meta"]/info[@name="url"]',
                'information/category[@name="meta"]/info[@name="URI"]',
                'information/category[@name="meta"]/info[@name="location"]',
                'information/category[@name="meta"]/info[@name="title"]',  # Sometimes URL is in title for streams
                'information/category[@name="meta"]/info[@name="filename"]',  # Sometimes URL is in filename for streams
                'information/category[@name="Stream 0"]/info[@name="Codec"]',  # Try stream info
                'information/category[@name="Stream 0"]/info[@name="Type"]',
                'information/category[@name="Stream 0"]/info[@name="Language"]',
            ]

            file_info = None
            logger.debug(f"Looking for URL: {rule['url']}")

            for path in url_paths:
                element = tree.find(path)
                if element is not None and element.text:
                    file_info = element.text
                    logger.debug(f"Found URL info at '{path}': {file_info}")
                    break

            if file_info:
                # For URL comparison, check if the rule URL is contained in the file_info
                # This handles cases where VLC might show a longer or modified URL
                expected_url = rule["url"]

                # Method 1: Direct URL match
                if expected_url in file_info or file_info.endswith(expected_url):
                    return 1

                # Method 2: For HLS streams, VLC often shows just the filename instead of full URL
                # Check if the file_info matches the filename part of the expected URL
                try:
                    expected_parsed = urlparse(expected_url)
                    expected_filename = os.path.basename(expected_parsed.path)

                    # If VLC shows just the filename (common for HLS streams)
                    if file_info == expected_filename:
                        logger.info(
                            f"URL filename match - Expected URL: {expected_url}, VLC shows filename: {file_info}"
                        )
                        return 1

                    # Method 3: Check if both are URLs from the same domain and similar path
                    if "://" in file_info:  # file_info is also a URL
                        actual_parsed = urlparse(file_info)
                        # Same domain and similar path structure
                        if (
                            expected_parsed.netloc == actual_parsed.netloc
                            and expected_parsed.path in actual_parsed.path
                        ):
                            return 1
                except Exception as e:
                    logger.debug(f"URL parsing error: {e}")
                    pass

                logger.warning(f"URL mismatch - Expected: {expected_url}, Found: {file_info}")
                return 0
            else:
                logger.warning(f"Could not find URL information in VLC status XML for rule: {rule}")
                return 0
        else:
            logger.error(f"Unknown type: {rule['type']}")
            return 0
    else:
        return 0


# fixme: part of this function can be moved to getters
def is_vlc_recordings_folder(actual_config_path: str, rule: Dict[str, str]) -> float:
    """
    Checks if VLC's recording folder is set to the expected value.
    """
    with open(actual_config_path, "rb") as file:
        config_file = file.read().decode("utf-8")

    expected_recording_file_path = rule["recording_file_path"]

    try:
        for line in config_file.split("\n"):
            # Skip comments and empty lines
            if line.startswith("#") or not line.strip():
                continue
            # Check if the line contains the recording path setting
            if "input-record-path" in line:
                # Extract the value of the recording path and remove surrounding whitespace
                current_path = line.split("=")[-1].strip()
                # Compare with the Desktop path
                if current_path == expected_recording_file_path:
                    return 1
                else:
                    return 0
        # The configuration key was not found in the file
        return 0
    except FileNotFoundError:
        logger.error("VLC configuration file not found.")
        return 0
    except Exception as e:
        logger.error(f"An error occurred: {e}")
        return 0


def is_vlc_fullscreen(actual_window_size, screen_size):
    if screen_size is None or actual_window_size is None:
        # if the screen size is not available, means that the window is not fullscreen
        return 0

    if actual_window_size["width"] == screen_size["width"] and actual_window_size["height"] == screen_size["height"]:
        return 1
    else:
        return 0


def compare_images(image1_path, image2_path, **options):
    # You would call this function with the paths to the two images you want to compare:
    # score = compare_images('path_to_image1', 'path_to_image2')
    # print("Similarity score:", score)

    if not image1_path or not image2_path:
        return 0

    base_score = options.get("reference_base_result", None)

    # Open the images and convert to grayscale
    image1 = Image.open(image1_path).convert("L")
    image2 = Image.open(image2_path).convert("L")

    # Resize images to the smaller one's size for comparison
    image1_size = image1.size
    image2_size = image2.size
    new_size = min(image1_size, image2_size)

    image1 = image1.resize(new_size, Image.Resampling.LANCZOS)
    image2 = image2.resize(new_size, Image.Resampling.LANCZOS)

    # Convert images to numpy arrays
    image1_array = np.array(image1)
    image2_array = np.array(image2)

    # Calculate SSIM between two images
    similarity_index = ssim(image1_array, image2_array)

    epsilon = 0.01
    if base_score is not None:
        if similarity_index >= base_score + epsilon:
            return (similarity_index - base_score) / (1 - base_score)
        else:
            return 0
    else:
        return similarity_index


def compare_audios(audio_path_1, audio_path_2):
    """
    Compare two audio files and return a similarity score in the range [0, 1].
    audio_path_1, audio_path_2: paths to the audio files to compare
    """
    # similarity = compare_audios_simple('path_to_audio1.mp3', 'path_to_audio2.mp3')
    # print(f'Similarity Score: {similarity}')

    if not audio_path_1 or not audio_path_2:
        return 0

    y1, y2 = None, None
    try:
        y1, sr1 = librosa.load(audio_path_1)
    except Exception:
        logger.warning(f"Could not load audio from {os.path.basename(audio_path_1)}. It might be empty or corrupt.")

    try:
        y2, sr2 = librosa.load(audio_path_2)
    except Exception:
        logger.warning(f"Could not load audio from {os.path.basename(audio_path_2)}. It might be empty or corrupt.")

    # Handle cases where one or both audio files are empty or corrupt.
    is_y1_bad = (y1 is None) or (y1.shape[0] == 0)
    is_y2_bad = (y2 is None) or (y2.shape[0] == 0)

    if is_y1_bad and is_y2_bad:
        logger.info("Both audio files are empty or corrupt. Considering them perfectly similar.")
        return 1.0

    if is_y1_bad or is_y2_bad:
        logger.warning("One audio file is empty/corrupt, the other is not. Similarity is 0.")
        return 0.0

    try:
        logger.info(f"Audio 1 ({os.path.basename(audio_path_1)}): sr={sr1}, len={len(y1)}")
        logger.info(f"Audio 2 ({os.path.basename(audio_path_2)}): sr={sr2}, len={len(y2)}")

        # Extract MFCC features
        mfcc1 = librosa.feature.mfcc(y=y1, sr=sr1)
        mfcc2 = librosa.feature.mfcc(y=y2, sr=sr2)
    except Exception as e:
        logger.error(f"Error during MFCC extraction: {e}")
        return 0.0

    # Normalize the MFCC features
    mfcc1 = librosa.util.normalize(mfcc1, axis=1)
    mfcc2 = librosa.util.normalize(mfcc2, axis=1)
    logger.info("MFCCs normalized.")

    # Define a function to compute cosine distance
    def dist_func(x, y):
        return cosine(x, y)

    # Use the DTW algorithm to find the best alignment path
    distance, path = fastdtw(mfcc1.T, mfcc2.T, dist=dist_func)
    logger.info(f"DTW distance: {distance:.4f}, Path length: {len(path)}")

    # Normalize the DTW distance by the length of the alignment path.
    if len(path) == 0:
        normalized_distance = np.inf
    else:
        normalized_distance = distance / len(path)
    logger.info(f"Normalized DTW distance: {normalized_distance:.4f}")

    # Convert the normalized distance to a similarity score using an exponential decay function.
    similarity = np.exp(-normalized_distance)

    return similarity


def compare_audios_by_dl_model(audio_path_1, audio_path_2):
    pass


def compare_videos(video_path1, video_path2, max_frames_to_check=100, threshold=5):
    # Open both video files
    cap1 = cv2.VideoCapture(video_path1)
    cap2 = cv2.VideoCapture(video_path2)

    frames_checked = 0
    mismatch_count = 0

    while frames_checked < max_frames_to_check:
        # Read frames from both videos
        ret1, frame1 = cap1.read()
        ret2, frame2 = cap2.read()

        # If a video ends, then check if both ended to confirm they are of the same length
        if not ret1 or not ret2:
            return 1.0 if ret1 == ret2 else 0.0  # return float only

        # Convert frames to PIL Images
        frame1 = Image.fromarray(cv2.cvtColor(frame1, cv2.COLOR_BGR2RGB))
        frame2 = Image.fromarray(cv2.cvtColor(frame2, cv2.COLOR_BGR2RGB))

        # Compute the perceptual hash for each frame
        hash1 = imagehash.phash(frame1)
        hash2 = imagehash.phash(frame2)

        # Increment the frames checked
        frames_checked += 1

        # Compute the difference in the hashes
        if hash1 - hash2 > threshold:
            mismatch_count += 1
            # If there's a significant difference, the frames are not the same
            if mismatch_count > threshold:
                return 0.0

    # If we reach here, the content appears to be the same
    return 1.0


def check_qt_bgcone(actual_config_path, rule):
    with open(actual_config_path, "rb") as file:
        config_file = file.read().decode("utf-8")

    expected_qt_bgcone = rule["expected_qt_bgcone"]
    if isinstance(expected_qt_bgcone, int):
        expected_qt_bgcone = str(expected_qt_bgcone)

    try:
        # The default value of qt_bgcone is 1, which means it is enabled
        qt_bgcone = "1"
        for line in config_file.split("\n"):
            # Check if the line contains the recording path setting
            if "qt-bgcone=" in line:
                # Extract the value of the recording path and remove surrounding whitespace
                qt_bgcone = line.split("=")[-1].strip()
            # The configuration key was not found in the file

        if qt_bgcone == expected_qt_bgcone:
            return 1
        else:
            return 0
    except FileNotFoundError:
        logger.error("VLC configuration file not found.")
        return 0
    except Exception as e:
        logger.error(f"An error occurred: {e}")
        return 0


def check_qt_max_volume(actual_config_path, rule):
    with open(actual_config_path, "rb") as file:
        config_file = file.read().decode("utf-8")

    expected_qt_max_volume = rule["expected_qt_max_volume"]
    if isinstance(expected_qt_max_volume, int):
        expected_qt_max_volume = str(expected_qt_max_volume)

    try:
        qt_max_volume = "125"
        for line in config_file.split("\n"):
            if "qt-max-volume=" in line:
                qt_max_volume = line.split("=")[-1].strip()
            # The configuration key was not found in the file

        if qt_max_volume == expected_qt_max_volume:
            return 1
        else:
            return 0
    except FileNotFoundError:
        logger.error("VLC configuration file not found.")
        return 0
    except Exception as e:
        logger.error(f"An error occurred: {e}")
        return 0


def check_qt_minimal_view(actual_config_path, rule):
    with open(actual_config_path, "rb") as file:
        config_file = file.read().decode("utf-8")

    expected_qt_minimal_view = rule["expected_qt_minimal_view"]
    if isinstance(expected_qt_minimal_view, int):
        expected_qt_minimal_view = str(expected_qt_minimal_view)

    try:
        qt_minimal_view = "0"
        for line in config_file.split("\n"):
            if "qt-minimal-view=" in line:
                qt_minimal_view = line.split("=")[-1].strip()

        if qt_minimal_view == expected_qt_minimal_view:
            return 1
        else:
            return 0
    except FileNotFoundError:
        logger.error("VLC configuration file not found.")
        return 0
    except Exception as e:
        logger.error(f"An error occurred: {e}")
        return 0


def check_qt_slider_colours(actual_config_path, rule):
    with open(actual_config_path, "rb") as file:
        config_file = file.read().decode("utf-8")

    try:
        qt_slider_colours = "153;210;153;20;210;20;255;199;15;245;39;29"
        for line in config_file.split("\n"):
            if "qt-slider-colours" in line:
                qt_slider_colours = line.split("=")[-1].strip()
            # The configuration key was not found in the file

        if rule["type"] == "match":
            expected_qt_slider_colours = rule["expected_qt_slider_colours"]
            if qt_slider_colours == expected_qt_slider_colours:
                return 1
            else:
                return 0
        elif rule["type"] == "blackish":

            def is_color_blackish(rgb_values, threshold=100):
                # decide if the color is blackish
                return all(value < threshold for value in rgb_values)

            def parse_qt_slider_colours(colours_string):
                # parse the string of colours into a list of RGB tuples
                values = [int(x) for x in colours_string.split(";")]
                colors = list(zip(values[0::3], values[1::3], values[2::3]))
                return colors

            colors = parse_qt_slider_colours(qt_slider_colours)

            # check if all colors are blackish
            for color in colors:
                if is_color_blackish(color):
                    pass
                else:
                    return 0
            return 1

    except FileNotFoundError:
        logger.error("VLC configuration file not found.")
        return 0
    except Exception as e:
        logger.error(f"An error occurred: {e}")
        return 0


def check_global_key_play_pause(actual_config_path, rule):
    """
    # Play/Pause (str)
    #global-key-play-pause=

    # Play/Pause (str)
    #key-play-pause=Space
    """
    with open(actual_config_path, "rb") as file:
        config_file = file.read().decode("utf-8")

    expected_global_key_play_pause = rule["expected_global_key_play_pause"]

    if isinstance(expected_global_key_play_pause, int):
        expected_global_key_play_pause = str(expected_global_key_play_pause)

    try:
        global_key_play_pause = "0"
        for line in config_file.split("\n"):
            # Check if the line contains the recording path setting
            if "global-key-play-pause=" in line:
                global_key_play_pause = "0" if line.split("=")[-1].strip() == "" else "1"

        if global_key_play_pause == expected_global_key_play_pause:
            return 1
        else:
            return 0
    except FileNotFoundError:
        logger.error("VLC configuration file not found.")
        return 0
    except Exception as e:
        logger.error(f"An error occurred: {e}")
        return 0


def check_one_instance_when_started_from_file(actual_config_path, rule):
    with open(actual_config_path, "rb") as file:
        config_file = file.read().decode("utf-8")

    expected_one_instance_when_started_from_file = rule["expected_one_instance_when_started_from_file"]

    if isinstance(expected_one_instance_when_started_from_file, int):
        expected_one_instance_when_started_from_file = str(expected_one_instance_when_started_from_file)

    try:
        one_instance_when_started_from_file = "1"
        for line in config_file.split("\n"):
            # Check if the line contains the recording path setting
            if "one-instance-when-started-from-file=" in line:
                one_instance_when_started_from_file = line.split("=")[-1].strip()

        if one_instance_when_started_from_file == expected_one_instance_when_started_from_file:
            return 1
        else:
            return 0
    except FileNotFoundError:
        logger.error("VLC configuration file not found.")
        return 0
    except Exception as e:
        logger.error(f"An error occurred: {e}")
        return 0
