import math

import cv2
import numpy as np

from .algorithms import (
    ProcessingError,
    bit_plane,
    box_filter,
    contrast_stretch,
    gamma,
    gray_slice,
    gray_to_rgb,
    histogram_equalization,
    logarithmic,
    negative,
    normalize_to_uint8,
    to_gray,
    weighted_average,
    median_filter,
    high_boost,
    ensure_uint8,
)


CH_BASIC = "Basic"
CH3 = "Image Enhancement in the Spatial Domain"
CH4 = "Image Enhancement in the Frequency Domain"
CH6 = "Color Image Processing"


def with_meta(schema, *, label=None, description=None, show_when=None):
    """Attach frontend display metadata to a parameter schema."""

    if label:
        schema["label"] = label
    if description:
        schema["description"] = description
    if show_when:
        schema["show_when"] = show_when
    return schema


def odd_param(default=3, max_value=35, **meta):
    """Build a schema for odd-valued mask parameters such as K or N."""

    return with_meta({"type": "int", "default": default, "min": 3, "max": max_value, "step": 2, "odd": True}, **meta)


def float_param(default, min_value, max_value, step=0.1, **meta):
    """Build a schema for a floating-point slider/input parameter."""

    return with_meta({"type": "float", "default": default, "min": min_value, "max": max_value, "step": step}, **meta)


def int_param(default, min_value, max_value, step=1, **meta):
    """Build a schema for an integer slider/input parameter."""

    return with_meta({"type": "int", "default": default, "min": min_value, "max": max_value, "step": step}, **meta)


def select_param(default, choices, **meta):
    """Build a schema for a dropdown/select parameter."""

    return with_meta({"type": "select", "default": default, "choices": choices}, **meta)


def bool_param(default=False, **meta):
    """Build a schema for a boolean/toggle parameter."""

    return with_meta({"type": "bool", "default": default}, **meta)


def kernel_preview(title, matrix, scale=None):
    """Describe a single matrix preview shown beside an operation."""

    return {"title": title, "matrix": matrix, "scale": scale}


def kernel_pair_preview(title, gx, gy):
    """Describe related Gx/Gy derivative masks shown as one preview."""

    return {"title": title, "kernels": [{"label": "Gx", "matrix": gx}, {"label": "Gy", "matrix": gy}]}


def mask_param(default=3, max_value=35, label="Mask size"):
    """Build the common odd window-size parameter used by order-statistic filters."""

    schema = odd_param(default, max_value)
    schema["label"] = label
    return schema


def histeq(image, params):
    """Apply MATLAB-style histogram equalization to grayscale or RGB channels.

    Use it to automatically improve global contrast without manually choosing gray-level limits.
    """

    if image.ndim == 2:
        return histogram_equalization(image, params)
    channels = [histogram_equalization(image[:, :, idx], params)[:, :, 0] for idx in range(3)]
    return np.stack(channels, axis=2).astype(np.uint8)


def rgb_to_gray_matlab(image, params):
    """Convert RGB to grayscale using configurable MATLAB-style channel weights.

    Use it before intensity-based processing when color is not needed or when matching MATLAB examples.
    """

    if image.ndim == 2:
        return image
    red_weight = float(params.get("red_weight", 0.299))
    green_weight = float(params.get("green_weight", 0.587))
    blue_weight = float(params.get("blue_weight", 0.114))
    total = red_weight + green_weight + blue_weight
    if not np.isfinite(total) or math.isclose(total, 0.0):
        raise ProcessingError("Grayscale weights must have a non-zero finite sum.")
    weights = np.array([red_weight, green_weight, blue_weight], dtype=np.float32) / total
    gray = np.tensordot(image.astype(np.float32), weights, axes=([2], [0]))
    return ensure_uint8(np.round(gray))


def gaussian_noise(image, params):
    """Add Gaussian noise, g = f + n, where n has configurable mean and variance.

    Use it to simulate sensor-like random noise before testing smoothing filters.
    """

    mean = float(params.get("mean", 0))
    variance = float(params.get("variance", 0.01))
    sigma = math.sqrt(max(variance, 0.0)) * 255.0
    noise = np.random.default_rng().normal(mean * 255.0, sigma, size=image.shape)
    return ensure_uint8(np.round(image.astype(np.float32) + noise))


def salt_pepper_noise(image, params):
    """Add impulse noise by randomly replacing pixels with black or white values.

    Use it to test order-statistic denoising, especially the median filter.
    """

    amount = float(params.get("amount", 0.03))
    salt_ratio = float(params.get("salt_ratio", 0.5))
    output = image.copy()
    rng = np.random.default_rng()
    mask = rng.random(image.shape[:2])
    salt = mask < amount * salt_ratio
    pepper = (mask >= amount * salt_ratio) & (mask < amount)
    output[salt] = 255
    output[pepper] = 0
    return output


def noise_filter(image, params):
    """Dispatch the selected noise model from the single public Noise Filter operation.

    Use it to keep noise experiments in one UI action while changing only the noise type.
    """

    kind = params.get("kind", "gaussian")
    if kind == "salt_pepper":
        return salt_pepper_noise(image, params)
    return gaussian_noise(image, params)


def average_noisy_copies(image, params):
    """Generate N Gaussian-noisy copies of one image and average them into one result.

    Use it to demonstrate how averaging many independent noisy observations reduces random Gaussian noise.
    """

    count = int(params.get("N", 100))
    if count < 1 or count > 500:
        raise ProcessingError("N must be between 1 and 500.")
    kind = params.get("kind", "gaussian")
    if kind != "gaussian":
        raise ProcessingError("Only gaussian noise is supported for noisy-copy averaging.")
    mean = float(params.get("mean", 0))
    variance = float(params.get("variance", 0.01))
    if not np.isfinite(mean) or not np.isfinite(variance) or variance < 0:
        raise ProcessingError("Gaussian mean must be finite and variance must be non-negative.")

    rng = np.random.default_rng()
    sigma = math.sqrt(variance) * 255.0
    source = image.astype(np.float32)
    total = np.zeros_like(source, dtype=np.float32)
    for _ in range(count):
        noise = rng.normal(mean * 255.0, sigma, size=image.shape)
        total += np.clip(source + noise, 0, 255)
    return ensure_uint8(np.round(total / count))


def gaussian_filter(image, params):
    """Apply a Gaussian low-pass filter controlled by mask size K and variance Q.

    Use it to reduce Gaussian noise with a smoother, more natural blur than a box filter.
    """

    size = int(params.get("K", params.get("size", 3)))
    variance = float(params.get("Q", params.get("variance", 1.0)))
    if size < 3 or size % 2 == 0:
        raise ProcessingError("K must be an odd integer >= 3.")
    sigma = math.sqrt(max(variance, 1e-8))
    return cv2.GaussianBlur(image, (size, size), sigmaX=sigma, sigmaY=sigma, borderType=cv2.BORDER_REFLECT)


def max_filter(image, params):
    """Apply a max filter that replaces each pixel with the local neighborhood maximum.

    Use it to expand bright regions or reduce isolated dark pepper noise.
    """

    size = int(params.get("mask_size", params.get("N", params.get("size", 3))))
    if size < 3 or size % 2 == 0:
        raise ProcessingError("Mask size must be an odd integer >= 3.")
    return cv2.dilate(image, np.ones((size, size), np.uint8))


def min_filter(image, params):
    """Apply a min filter that replaces each pixel with the local neighborhood minimum.

    Use it to expand dark regions or reduce isolated bright salt noise.
    """

    size = int(params.get("mask_size", params.get("N", params.get("size", 3))))
    if size < 3 or size % 2 == 0:
        raise ProcessingError("Mask size must be an odd integer >= 3.")
    return cv2.erode(image, np.ones((size, size), np.uint8))


def box_denoise(image, params):
    """Apply the average/box filter using a K x K normalized mask.

    Use it as the simplest low-pass filter for smoothing and basic noise reduction.
    """

    return box_filter(image, {"size": params.get("K", params.get("mask_size", params.get("size", 3)))})


def weighted_denoise(image, params):
    """Apply the fixed 3 x 3 weighted average filter with 1/16 normalization.

    Use it when you want mild smoothing that keeps the center pixel more important.
    """

    return weighted_average(image, {"size": 3})


def median_denoise(image, params):
    """Apply median filtering with an odd local window, useful for salt-and-pepper noise.

    Use it when impulse noise appears as random black and white pixels.
    """

    return median_filter(image, {"size": params.get("mask_size", params.get("N", params.get("size", 3)))})


def gaussian_denoise(image, params):
    """Apply Gaussian smoothing using K for mask size and Q for variance.

    Use it for denoising random Gaussian noise while avoiding the blocky look of a box filter.
    """

    size = params.get("K", params.get("mask_size", params.get("size", 3)))
    variance = params.get("Q", params.get("variance", 1.0))
    return gaussian_filter(image, {"K": size, "Q": variance})


def high_boost_slide(image, params):
    """Apply high-boost filtering with slide-style parameters A and K.

    Use it to make edges and fine structures stronger after smoothing has removed the low-frequency background.
    """

    return high_boost(image, {"amplification": params.get("A", params.get("amplification", 1.5)), "size": params.get("K", params.get("size", 3))})


def laplacian_slide(image, params):
    """Sharpen with one of the two taught Laplacian sharpening masks.

    Use it to highlight fine detail with the same cross or diagonal masks shown in the slides.
    """

    mask_name = params.get("mask", "cross")
    kernels = {
        "cross": np.array([[0, 1, 0], [1, -5, 1], [0, 1, 0]], dtype=np.float32),
        "diagonal": np.array([[1, 1, 1], [1, -9, 1], [1, 1, 1]], dtype=np.float32),
    }
    kernel = kernels.get(mask_name)
    if kernel is None:
        raise ProcessingError("Unknown Laplacian mask.")
    if image.ndim == 2:
        return ensure_uint8(cv2.filter2D(image.astype(np.float32), cv2.CV_32F, kernel, borderType=cv2.BORDER_REFLECT))
    channels = [cv2.filter2D(image[:, :, idx], cv2.CV_32F, kernel, borderType=cv2.BORDER_REFLECT) for idx in range(image.shape[2])]
    result = np.stack(channels, axis=2)
    return ensure_uint8(result)


def gradient_abs_sum(image, params):
    """Compute Sobel or Roberts edges as abs(imfilter(f,Gx)) + abs(imfilter(f,Gy)).

    Use it to emphasize prominent edges before combining them with a sharpened image.
    """

    operator = params.get("operator", "sobel")
    gray = to_gray(image).astype(np.float32)
    if operator == "roberts":
        gx = np.array([[-1, 0], [0, 1]], dtype=np.float32)
        gy = np.array([[0, -1], [1, 0]], dtype=np.float32)
    else:
        gx = np.array([[-1, -2, -1], [0, 0, 0], [1, 2, 1]], dtype=np.float32)
        gy = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]], dtype=np.float32)
    fx = cv2.filter2D(gray, cv2.CV_32F, gx, borderType=cv2.BORDER_REFLECT)
    fy = cv2.filter2D(gray, cv2.CV_32F, gy, borderType=cv2.BORDER_REFLECT)
    return gray_to_rgb(normalize_to_uint8(np.abs(fx) + np.abs(fy)))


def rgb_channel(image, params):
    """Extract one RGB channel and show it as a grayscale image.

    Use it to inspect how much information each color component contributes.
    """

    if image.ndim == 2:
        return image
    channel = params.get("channel", "r")
    index = {"r": 0, "g": 1, "b": 2}.get(channel, 0)
    return gray_to_rgb(image[:, :, index])


def fft_spectrum(image, params):
    """Display the DFT magnitude, log magnitude, or phase spectrum of an image.

    Use it to understand whether image information is concentrated in low or high frequencies.
    """

    gray = to_gray(image).astype(np.float32)
    spectrum = np.fft.fftshift(np.fft.fft2(gray))
    mode = params.get("mode", "log_magnitude")
    if mode == "phase":
        return gray_to_rgb(normalize_to_uint8(np.angle(spectrum)))
    magnitude = np.abs(spectrum)
    if mode == "log_magnitude":
        magnitude = np.log1p(magnitude)
    return gray_to_rgb(normalize_to_uint8(magnitude))


def operation(id, label, chapter, slide_group, func, params=None, supports="both", matrices=None, formula="", repeatable=True):
    """Create one operation registry entry consumed by the API and frontend."""

    return {
        "id": id,
        "label": label,
        "chapter": chapter,
        "slide_group": slide_group,
        "params": params or {},
        "supports": supports,
        "matrices": matrices or [],
        "formula": formula,
        "repeatable": repeatable,
        "func": func,
    }


OPERATIONS = [
    operation("histeq", "Histogram Equalization", CH_BASIC, "Histogram", histeq, formula="Default histeq: map gray levels by the cumulative histogram CDF.", repeatable=False),
    operation("negative", "Negative", CH3, "Point Processing", negative, formula="s = 255 - r", repeatable=False),
    operation("log", "Log", CH3, "Point Processing", logarithmic, {"c": float_param(1.44, 0.1, 5, 0.05, description="Scale factor in s = c log(1 + r).")}, formula="s = c log(1 + r)", repeatable=False),
    operation("gamma", "Power-Law / Gamma", CH3, "Point Processing", gamma, {"gamma": float_param(1.0, 0.1, 5, 0.05, description="Exponent gamma in s = c r^gamma."), "c": float_param(1.0, 0.1, 3, 0.05, description="Scale factor c in s = c r^gamma.")}, formula="s = c r^gamma", repeatable=False),
    operation("contrast_stretch", "Gray-Level Dynamic Range", CH3, "Piecewise Linear", contrast_stretch, {"low": int_param(30, 0, 254, description="Input gray level mapped toward 0."), "high": int_param(220, 1, 255, description="Input gray level mapped toward 255.")}, formula="Stretch [low, high] to [0, 255].", repeatable=False),
    operation("gray_slice", "Gray-Level Slicing", CH3, "Piecewise Linear", gray_slice, {"start": int_param(96, 0, 255, description="Lower bound A of highlighted range [A, B]."), "end": int_param(160, 0, 255, description="Upper bound B of highlighted range [A, B]."), "preserve_background": bool_param(True, description="Keep original background outside [A, B].")}, formula="Highlight gray range A <= r <= B.", repeatable=False),
    operation("bit_plane", "Bit-Plane Slicing", CH3, "Piecewise Linear", bit_plane, {"bit": int_param(7, 0, 7, description="Bit plane index, 0 least significant through 7 most significant.")}, formula="Output bit k of each gray level.", repeatable=False),
    operation("noise_filter", "Noise Filter", CH3, "Noise and Denoising", noise_filter, {
        "kind": select_param("gaussian", ["gaussian", "salt_pepper"], description="Select the noise model."),
        "mean": float_param(0, -1, 1, 0.01, description="Gaussian mean in normalized intensity units.", show_when={"param": "kind", "value": "gaussian"}),
        "variance": float_param(0.01, 0, 0.2, 0.005, description="Gaussian variance; sigma = sqrt(variance).", show_when={"param": "kind", "value": "gaussian"}),
        "amount": float_param(0.03, 0, 0.5, 0.01, description="Salt-and-pepper probability per pixel.", show_when={"param": "kind", "value": "salt_pepper"}),
        "salt_ratio": float_param(0.5, 0, 1, 0.05, description="Fraction of impulse noise assigned to salt.", show_when={"param": "kind", "value": "salt_pepper"}),
    }, formula="Gaussian: g=f+n. Salt-pepper: pixels become 0 or 255."),
    operation("average_noisy_copies", "Average N Noisy Copies", CH3, "Noise and Denoising", average_noisy_copies, {
        "N": int_param(100, 1, 500, description="Number of independent noisy copies to generate and average."),
        "kind": select_param("gaussian", ["gaussian"], description="Noise type used for generated copies."),
        "mean": float_param(0, -1, 1, 0.01, description="Gaussian mean in normalized intensity units."),
        "variance": float_param(0.01, 0, 0.2, 0.005, description="Gaussian variance; lower values add weaker noise."),
    }, formula="result = (1/N) sum_i (f + n_i), with gaussian n_i.", repeatable=False),
    operation("box_filter", "Average / Box Filter", CH3, "Linear Low-Pass Filters", box_denoise, {"K": odd_param(3, 35, description="Odd mask dimension K for the K x K average mask.")}, matrices=[kernel_preview("1 / K^2 box mask", [["1", "1", "1"], ["1", "1", "1"], ["1", "1", "1"]], "1 / K^2")], formula="g = imfilter(f, ones(K,K)/K^2)"),
    operation("weighted_average", "Weighted Average Filter", CH3, "Linear Low-Pass Filters", weighted_denoise, matrices=[kernel_preview("Weighted average mask", [[1, 2, 1], [2, 4, 2], [1, 2, 1]], "1 / 16")], formula="g = imfilter(f, weighted mask)"),
    operation("gaussian_filter", "Gaussian Filter", CH3, "Linear Low-Pass Filters", gaussian_denoise, {"K": odd_param(3, 35, description="Odd Gaussian mask dimension K."), "Q": float_param(1.0, 0.01, 25, 0.1, description="Variance Q of the Gaussian mask.")}, formula="Gaussian mask controlled by K and variance Q."),
    operation("median_filter", "Median Filter", CH3, "Order-Statistics Filters", median_denoise, {"mask_size": mask_param(3, 25, "Window size")}, formula="g(x,y) = median of neighborhood."),
    operation("max_filter", "Max Filter", CH3, "Order-Statistics Filters", max_filter, {"mask_size": mask_param(3, 25, "Window size")}, formula="g(x,y) = max of neighborhood."),
    operation("min_filter", "Min Filter", CH3, "Order-Statistics Filters", min_filter, {"mask_size": mask_param(3, 25, "Window size")}, formula="g(x,y) = min of neighborhood."),
    operation("laplacian_slide", "Laplacian Sharpening Masks", CH3, "Sharpening Spatial Filters", laplacian_slide, {"mask": select_param("cross", ["cross", "diagonal"], description="Choose one of the taught sharpening masks.")}, matrices=[
        kernel_preview("Sharpening cross mask", [[0, 1, 0], [1, -5, 1], [0, 1, 0]]),
        kernel_preview("Sharpening diagonal mask", [[1, 1, 1], [1, -9, 1], [1, 1, 1]]),
    ], formula="Sharpen with selected Laplacian mask."),
    operation("gradient_abs_sum", "Gradient Operators", CH3, "Gradient Operator", gradient_abs_sum, {"operator": select_param("sobel", ["sobel", "roberts"], description="Choose Gx/Gy pair.")}, matrices=[
        kernel_pair_preview("Roberts Cross-Gradient", [[-1, 0], [0, 1]], [[0, -1], [1, 0]]),
        kernel_pair_preview("Sobel", [[-1, -2, -1], [0, 0, 0], [1, 2, 1]], [[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]]),
    ], formula="Gradient image = abs(imfilter(f,Gx)) + abs(imfilter(f,Gy))."),
    operation("high_boost", "High-Boost / Edge Emphasis", CH3, "High-Boost Filtering", high_boost_slide, {"A": float_param(1.5, 1, 6, 0.1, description="Boost factor A, where A >= 1."), "K": odd_param(3, 35, description="Odd averaging mask size used for the blurred image.")}, formula="f_hb = A f - blurred(f)."),
    operation("fft_spectrum", "FFT/DFT Spectrum View", CH4, "DFT and FFT", fft_spectrum, {"mode": select_param("log_magnitude", ["magnitude", "log_magnitude", "phase"], description="Choose magnitude, log magnitude, or phase display.")}, formula="F(u,v) = DFT{f(x,y)}", repeatable=False),
    operation("rgb_to_gray", "Convert to Grayscale", CH6, "Color Conversion", rgb_to_gray_matlab, {"red_weight": float_param(0.299, 0, 1, 0.001, description="R coefficient in gray = aR + bG + cB."), "green_weight": float_param(0.587, 0, 1, 0.001, description="G coefficient in gray = aR + bG + cB."), "blue_weight": float_param(0.114, 0, 1, 0.001, description="B coefficient in gray = aR + bG + cB.")}, formula="gray = 0.299R + 0.587G + 0.114B by default.", repeatable=False),
    operation("rgb_channel", "RGB Channel View", CH6, "RGB color model", rgb_channel, {"channel": select_param("r", ["r", "g", "b"], description="Select the RGB channel to view.")}, formula="Show one RGB channel as grayscale.", repeatable=False),
]

OPERATION_MAP = {item["id"]: item for item in OPERATIONS}


def operation_metadata():
    """Return public operation definitions without executable Python callables."""

    return [{key: value for key, value in item.items() if key != "func"} for item in OPERATIONS]


def apply_registered_operation(image, operation_id, params=None):
    """Apply one registered operation, optionally repeating it with the hidden _repeat value.

    Use repetition to apply the same filter several times in one saved state.
    """

    item = OPERATION_MAP.get(operation_id)
    if item is None:
        raise ProcessingError(f"Unsupported operation '{operation_id}'.")
    operation_params = dict(params or {})
    repeat_count = int(operation_params.pop("_repeat", 1))
    if repeat_count < 1 or repeat_count > 20:
        raise ProcessingError("N must be between 1 and 20.")
    result = ensure_uint8(image)
    for _ in range(repeat_count):
        result = ensure_uint8(item["func"](result, operation_params))
    return result