wallswitch 0.60.1

//! Julia Set fractal generator overlay.
//!
//! This module provides the implementation of the Julia Set fractal renderer,
//! using pre-programmed coordinate presets. It generates mathematical overlays
//! dynamically fitted to the display dimensions and blends them seamlessly
//! using high-contrast dual-tone chromatic borders and 3D shadow depth offsets.

use crate::effects::{
    FractalPreset, MAX_ITERATIONS, MIN_ITERATIONS, ProceduralEffect, Viewport, ViewportSpecs,
    blend_and_vignette_pixel, calculate_distance_estimator, calculate_smooth_potential,
    compute_escape_iterations, get_rotation_steps, partition_rows, rotate_point,
};
use crate::{
    ImageEffect, NEON_PALETTES, NeonColor, WallSwitchError, WallSwitchResult, get_random_integer,
    smoothstep,
};
use image::RgbImage;
use std::{io::Error, path::Path, thread};

/// Implementation of the [`ImageEffect`] trait for rendering Julia Set fractals.
impl ImageEffect for JuliaGenerator {
    /// Applies the Julia Set procedural overlay onto an in-memory image buffer.
    fn apply(&self, rgb_img: &mut RgbImage) {
        self.apply_effect_in_memory(rgb_img);
    }

    /// Returns formatting diagnostic information about the active generator.
    fn info(&self) -> String {
        format!(
            "fractal [{}]\n\
            f(z) = z² + c, where c = {:.5} {} {:.5}i (iter = {:3}, zoom = {:.2}), color: {}",
            self.preset.fractal_name,
            self.preset.center_re,
            if self.preset.center_im >= 0.0 {
                "+"
            } else {
                "-"
            },
            self.preset.center_im.abs(),
            self.scan_iterations,
            self.zoom,
            self.color_palette
        )
    }
}

/// A procedural generator for rendering Julia Set fractals onto desktop backgrounds.
///
/// Combines mathematical coordinate presets with viewport fitting, lighting shaders,
/// and color interpolation to produce high-definition digital art overlays.
pub struct JuliaGenerator {
    /// The active coordinate preset, enclosing the center points and metadata.
    pub preset: FractalPreset,
    /// The maximum iteration limit for escape-time calculations.
    pub scan_iterations: u32,
    /// The base color palette selected for the neon glow.
    pub color_palette: NeonColor,
    /// The viewport zoom level.
    pub zoom: f64,
    /// The cosine of the rotation angle.
    pub cos_angle: f64,
    /// The sine of the rotation angle.
    pub sin_angle: f64,
}

impl Default for JuliaGenerator {
    /// Returns the default fallback instance of the Julia Set generator.
    fn default() -> Self {
        Self {
            preset: FractalPreset {
                center_re: -0.7,
                center_im: 0.27015,
                fractal_name: "Classic dendrite",
                effect_name: ProceduralEffect::JuliaSet,
            },
            scan_iterations: get_random_integer(MIN_ITERATIONS, MAX_ITERATIONS),
            color_palette: NEON_PALETTES[5],
            zoom: 3.0,
            cos_angle: 1.0,
            sin_angle: 0.0,
        }
    }
}

impl JuliaGenerator {
    /// Generates a randomized Julia Set configuration fitted to the target aspect ratio.
    ///
    /// Selects one of the 44 built-in coordinate presets, assigns a neon color palette,
    /// rotates the coordinate system randomly, and optimizes the viewport fit.
    pub fn random(monitor: &crate::Monitor) -> Self {
        let width = monitor.resolution.width as u32;
        let height = monitor.resolution.height as u32;

        let presets: [FractalPreset; 36] = [
            FractalPreset {
                center_re: -0.4,
                center_im: 0.6,
                fractal_name: "Classic cloud swirls",
                effect_name: ProceduralEffect::JuliaSet,
            },
            FractalPreset {
                center_re: -0.8,
                center_im: 0.156,
                fractal_name: "Detailed spirals",
                effect_name: ProceduralEffect::JuliaSet,
            },
            FractalPreset {
                center_re: -0.7269,
                center_im: 0.1889,
                fractal_name: "Lace structures",
                effect_name: ProceduralEffect::JuliaSet,
            },
            FractalPreset {
                center_re: -0.75,
                center_im: 0.11,
                fractal_name: "Feathery branches",
                effect_name: ProceduralEffect::JuliaSet,
            },
            FractalPreset {
                center_re: -0.1,
                center_im: 0.651,
                fractal_name: "Cosmic dust style",
                effect_name: ProceduralEffect::JuliaSet,
            },
            FractalPreset {
                center_re: -0.70176,
                center_im: -0.3842,
                fractal_name: "Dragon-like curves",
                effect_name: ProceduralEffect::JuliaSet,
            },
            FractalPreset {
                center_re: 0.355,
                center_im: 0.355,
                fractal_name: "Spiral galaxy arms",
                effect_name: ProceduralEffect::JuliaSet,
            },
            FractalPreset {
                center_re: -0.4,
                center_im: -0.59,
                fractal_name: "Swirling vortexes",
                effect_name: ProceduralEffect::JuliaSet,
            },
            FractalPreset {
                center_re: -0.54,
                center_im: 0.54,
                fractal_name: "Ornamental lace borders",
                effect_name: ProceduralEffect::JuliaSet,
            },
            FractalPreset {
                center_re: -0.74543,
                center_im: 0.11301,
                fractal_name: "Dense filigree patterns",
                effect_name: ProceduralEffect::JuliaSet,
            },
            FractalPreset {
                center_re: -0.835,
                center_im: -0.2321,
                fractal_name: "Lightning rods",
                effect_name: ProceduralEffect::JuliaSet,
            },
            FractalPreset {
                center_re: -0.77269,
                center_im: 0.12428,
                fractal_name: "Coral reefs",
                effect_name: ProceduralEffect::JuliaSet,
            },
            FractalPreset {
                center_re: -0.51251,
                center_im: 0.5213,
                fractal_name: "Fine lace filaments",
                effect_name: ProceduralEffect::JuliaSet,
            },
            FractalPreset {
                center_re: -0.55,
                center_im: 0.55,
                fractal_name: "Intricate leaf outlines",
                effect_name: ProceduralEffect::JuliaSet,
            },
            FractalPreset {
                center_re: -0.624,
                center_im: 0.435,
                fractal_name: "Crystalline snowflake patterns",
                effect_name: ProceduralEffect::JuliaSet,
            },
            FractalPreset {
                center_re: -0.12,
                center_im: 0.85,
                fractal_name: "Flowing plasma plumes",
                effect_name: ProceduralEffect::JuliaSet,
            },
            FractalPreset {
                center_re: -0.742,
                center_im: 0.1345,
                fractal_name: "Intricate branching nodes",
                effect_name: ProceduralEffect::JuliaSet,
            },
            FractalPreset {
                center_re: -0.391,
                center_im: -0.587,
                fractal_name: "Swirling storm clouds",
                effect_name: ProceduralEffect::JuliaSet,
            },
            FractalPreset {
                center_re: 0.0,
                center_im: 0.8,
                fractal_name: "Classic symmetric dendritic structure",
                effect_name: ProceduralEffect::JuliaSet,
            },
            FractalPreset {
                center_re: -0.73,
                center_im: 0.21,
                fractal_name: "Feathery dendritic lace",
                effect_name: ProceduralEffect::JuliaSet,
            },
            FractalPreset {
                center_re: -0.81,
                center_im: 0.2,
                fractal_name: "Spiral galaxy filaments",
                effect_name: ProceduralEffect::JuliaSet,
            },
            FractalPreset {
                center_re: -0.68,
                center_im: 0.34,
                fractal_name: "Delicate coral spirals",
                effect_name: ProceduralEffect::JuliaSet,
            },
            FractalPreset {
                center_re: -0.76,
                center_im: 0.08,
                fractal_name: "Lightning tree branches",
                effect_name: ProceduralEffect::JuliaSet,
            },
            FractalPreset {
                center_re: -0.72,
                center_im: 0.22,
                fractal_name: "Dendritic pine branches",
                effect_name: ProceduralEffect::JuliaSet,
            },
            FractalPreset {
                center_re: 0.285,
                center_im: 0.01,
                fractal_name: "Cosmic galaxy vortex swirls",
                effect_name: ProceduralEffect::JuliaSet,
            },
            FractalPreset {
                center_re: -0.743643,
                center_im: 0.13182,
                fractal_name: "Highly intricate Seahorse Valley filaments",
                effect_name: ProceduralEffect::JuliaSet,
            },
            FractalPreset {
                center_re: -0.8,
                center_im: 0.17,
                fractal_name: "Spidery lace dendrites",
                effect_name: ProceduralEffect::JuliaSet,
            },
            FractalPreset {
                center_re: -0.7269,
                center_im: -0.1889,
                fractal_name: "Conjugate lace structures",
                effect_name: ProceduralEffect::JuliaSet,
            },
            FractalPreset {
                center_re: -0.835,
                center_im: 0.2321,
                fractal_name: "Conjugate lightning rods",
                effect_name: ProceduralEffect::JuliaSet,
            },
            FractalPreset {
                center_re: -0.75,
                center_im: 0.05,
                fractal_name: "Dense branching coral reef",
                effect_name: ProceduralEffect::JuliaSet,
            },
            FractalPreset {
                center_re: -0.70176,
                center_im: 0.3842,
                fractal_name: "Conjugate dragon-like curves",
                effect_name: ProceduralEffect::JuliaSet,
            },
            FractalPreset {
                center_re: -0.48176,
                center_im: -0.53165,
                fractal_name: "Extremely fine branching stellar dust",
                effect_name: ProceduralEffect::JuliaSet,
            },
            FractalPreset {
                center_re: -0.74543,
                center_im: -0.11301,
                fractal_name: "Dense conjugate filigree",
                effect_name: ProceduralEffect::JuliaSet,
            },
            FractalPreset {
                center_re: -0.8,
                center_im: 0.16,
                fractal_name: "Deep sea coral spirals",
                effect_name: ProceduralEffect::JuliaSet,
            },
            FractalPreset {
                center_re: -0.722,
                center_im: 0.246,
                fractal_name: "Dendritic pine branch variation",
                effect_name: ProceduralEffect::JuliaSet,
            },
            FractalPreset {
                center_re: -0.2,
                center_im: 0.65,
                fractal_name: "Soft flame plasma plumes",
                effect_name: ProceduralEffect::JuliaSet,
            },
        ];

        let p_idx: usize = get_random_integer(0, NEON_PALETTES.len() - 1);
        let color_palette = NEON_PALETTES[p_idx];

        let angle_degrees: f64 = get_random_integer(0, 359);
        let radians = angle_degrees.to_radians();

        let preset_idx: usize = get_random_integer(0, presets.len() - 1);
        let selected_preset: FractalPreset = presets[preset_idx];

        let mut julia = Self {
            preset: selected_preset,
            scan_iterations: get_random_integer(MIN_ITERATIONS, MAX_ITERATIONS),
            color_palette,
            zoom: 3.0,
            cos_angle: radians.cos(),
            sin_angle: radians.sin(),
        };

        julia.optimize_fit(width, height);
        julia
    }

    /// Optimizes the viewport boundaries by scanning complex boundaries and finding a balanced zoom.
    pub fn optimize_fit(&mut self, width: u32, height: u32) {
        let w_f = width as f64;
        let h_f = height as f64;
        let min_dim = w_f.min(h_f);

        let c_abs = (self.preset.center_re * self.preset.center_re
            + self.preset.center_im * self.preset.center_im)
            .sqrt();
        let r_bound = (1.0 + (1.0 + 4.0 * c_abs).sqrt()) / 2.0;
        let search_limit = r_bound * 1.2;

        let steps = 128;
        let inv_steps_minus_1 = 1.0 / (steps - 1) as f64;
        let range = 2.0 * search_limit;

        let scan_iterations = self.scan_iterations;
        let mut active_points = Vec::with_capacity(steps * steps / 2);

        for step_y in 0..steps {
            let ry = -search_limit + (step_y as f64 * inv_steps_minus_1) * range;
            for step_x in 0..steps {
                let rx = -search_limit + (step_x as f64 * inv_steps_minus_1) * range;

                let (i, _, _, _, _) = compute_escape_iterations(
                    ProceduralEffect::JuliaSet,
                    rx,
                    ry,
                    self.preset.center_re,
                    self.preset.center_im,
                    scan_iterations,
                );

                if i > 3 && i < scan_iterations {
                    active_points.push((rx, ry));
                }
            }
        }

        if !active_points.is_empty() {
            let mut best_zoom = f64::MAX;
            let mut best_cos = self.cos_angle;
            let mut best_sin = self.sin_angle;

            for (_rad, cos_t, sin_t) in get_rotation_steps() {
                let mut max_cx_abs = 0.0_f64;
                let mut max_cy_abs = 0.0_f64;

                for &(rx, ry) in &active_points {
                    let (cx, cy) = rotate_point(rx, ry, cos_t, sin_t);

                    max_cx_abs = max_cx_abs.max(cx.abs());
                    max_cy_abs = max_cy_abs.max(cy.abs());
                }

                let zoom_x = 2.0 * max_cx_abs * min_dim / w_f;
                let zoom_y = 2.0 * max_cy_abs * min_dim / h_f;
                let required_zoom = zoom_x.max(zoom_y);

                if required_zoom < best_zoom {
                    best_zoom = required_zoom;
                    best_cos = cos_t;
                    best_sin = sin_t;
                }
            }

            self.zoom = best_zoom * 1.10;
            self.cos_angle = best_cos;
            self.sin_angle = best_sin;
        } else {
            self.zoom = 2.0 * r_bound * 1.10;
        }
    }

    /// Renders the Julia Set in-place over the active background memory buffer.
    pub fn apply_effect_in_memory(&self, rgb_img: &mut RgbImage) {
        let (width, height) = rgb_img.dimensions();
        let w_f = width as f64;
        let h_f = height as f64;

        let specs = ViewportSpecs {
            center_re: self.preset.center_re,
            center_im: self.preset.center_im,
            zoom: self.zoom,
            cos_angle: self.cos_angle,
            sin_angle: self.sin_angle,
            is_julia: true,
        };
        let viewport = Viewport::new(w_f, h_f, &specs);

        let scan_iterations = self.scan_iterations;
        let center_re = self.preset.center_re;
        let center_im = self.preset.center_im;

        let (mut rows, width_usize) = partition_rows(rgb_img);

        let cores = thread::available_parallelism()
            .map(|n| n.get())
            .unwrap_or(4);
        let chunk_size = (rows.len() / cores).max(1);

        let inv_half_w = 2.0 / w_f;
        let inv_half_h = 2.0 / h_f;

        let min_dim = w_f.min(h_f);
        let scale = self.zoom / min_dim;

        thread::scope(|scope| {
            let viewport_ref = &viewport;
            let color_palette = self.color_palette.to_array();
            for chunk in rows.chunks_mut(chunk_size) {
                scope.spawn(move || {
                    for (y, row_data) in chunk.iter_mut() {
                        let y_f = *y as f64;

                        let dy_vignette = (y_f * inv_half_h - 1.0) as f32;
                        let dy_vignette_sq = dy_vignette * dy_vignette;

                        for x in 0..width_usize {
                            let x_f = x as f64;

                            let (rx, ry) = viewport_ref.map(x_f, y_f);

                            let (i, z_re, z_im, dz_re, dz_im) = compute_escape_iterations(
                                ProceduralEffect::JuliaSet,
                                rx,
                                ry,
                                center_re,
                                center_im,
                                scan_iterations,
                            );

                            let t = calculate_smooth_potential(i, scan_iterations, z_re, z_im);

                            let (fractal_rgb, alpha, s_alpha) = if t > 0.005 && i < scan_iterations
                            {
                                let dist_complex = calculate_distance_estimator(
                                    i,
                                    scan_iterations,
                                    z_re,
                                    z_im,
                                    dz_re,
                                    dz_im,
                                );
                                let dist_pixels = (dist_complex / scale) as f32;

                                // Base physical thickness (2.5px radius) for ultra-thin vector profiles
                                let thickness = 2.5_f32;
                                let max_radius = thickness * 2.0;
                                let shadow_radius = max_radius * 1.5;

                                if dist_pixels < shadow_radius {
                                    let norm_dist = dist_pixels / max_radius;

                                    // 1. Razor-sharp vector core line (1.2px width)
                                    let core = if dist_pixels < 1.2 {
                                        1.0 - (dist_pixels / 1.2)
                                    } else {
                                        0.0
                                    };

                                    // 2. Infinite nested structural ripples
                                    let ripple_freq = 12.0_f32;
                                    let ripple_wave =
                                        (t * std::f32::consts::PI * ripple_freq).sin().abs();
                                    let nested_detail = (1.0
                                        - smoothstep(0.0, 0.4, 1.0 - ripple_wave))
                                        * (1.0 - norm_dist);

                                    // 3. Compact ambient outer glow (Sharp 6th-power attenuation curve)
                                    let glow = if dist_pixels < max_radius {
                                        (1.0 - norm_dist * norm_dist).powi(6) * 0.45
                                    } else {
                                        0.0
                                    };

                                    let profile = core * 0.65 + nested_detail * 0.20 + glow * 0.15;

                                    // 4. Parallax drop shadow profile
                                    let norm_shadow = dist_pixels / shadow_radius;
                                    let shadow_profile =
                                        (1.0 - norm_shadow * norm_shadow).powi(2) * 0.35;

                                    // 3D Specular Light Approximation
                                    let angle = z_im.atan2(z_re);
                                    let light =
                                        0.65_f32 + 0.35_f32 * (angle * 4.0).cos().abs() as f32;

                                    // Multi-cycle recurring color gradient
                                    let t_cycled = (t * 2.0) % 1.0;
                                    let secondary_color =
                                        [color_palette[1], color_palette[2], color_palette[0]];

                                    let r_grad = if t_cycled < 0.5 {
                                        let factor = t_cycled * 2.0;
                                        color_palette[0] * (1.0 - factor)
                                            + secondary_color[0] * factor
                                    } else {
                                        let factor = (t_cycled - 0.5) * 2.0;
                                        secondary_color[0] * (1.0 - factor)
                                            + color_palette[0] * factor
                                    };
                                    let g_grad = if t_cycled < 0.5 {
                                        let factor = t_cycled * 2.0;
                                        color_palette[1] * (1.0 - factor)
                                            + secondary_color[1] * factor
                                    } else {
                                        let factor = (t_cycled - 0.5) * 2.0;
                                        secondary_color[1] * (1.0 - factor)
                                            + color_palette[1] * factor
                                    };
                                    let b_grad = if t_cycled < 0.5 {
                                        let factor = t_cycled * 2.0;
                                        color_palette[2] * (1.0 - factor)
                                            + secondary_color[2] * factor
                                    } else {
                                        let factor = (t_cycled - 0.5) * 2.0;
                                        secondary_color[2] * (1.0 - factor)
                                            + color_palette[2] * factor
                                    };

                                    let core_color = [r_grad, g_grad, b_grad];

                                    // High-saturation chromatic edge inversion
                                    let mut border_color =
                                        [1.0 - r_grad, 1.0 - g_grad, 1.0 - b_grad];
                                    let max_val =
                                        border_color[0].max(border_color[1]).max(border_color[2]);
                                    if max_val > 0.0 {
                                        border_color[0] /= max_val;
                                        border_color[1] /= max_val;
                                        border_color[2] /= max_val;
                                    }

                                    let color_blend = norm_dist.powi(2);

                                    let r_blended = core_color[0] * (1.0 - color_blend)
                                        + border_color[0] * color_blend;
                                    let g_blended = core_color[1] * (1.0 - color_blend)
                                        + border_color[1] * color_blend;
                                    let b_blended = core_color[2] * (1.0 - color_blend)
                                        + border_color[2] * color_blend;

                                    // Emissive HDR brightness boost
                                    let brightness_boost = 1.20_f32;

                                    let rgb = [
                                        (r_blended * light * brightness_boost).clamp(0.0, 1.0),
                                        (g_blended * light * brightness_boost).clamp(0.0, 1.0),
                                        (b_blended * light * brightness_boost).clamp(0.0, 1.0),
                                    ];

                                    let iteration_fade =
                                        if i < 16 { (i as f32 - 3.0) / 13.0 } else { 1.0 };

                                    (
                                        rgb,
                                        profile * 0.95 * iteration_fade,
                                        shadow_profile * iteration_fade,
                                    )
                                } else {
                                    ([0.0, 0.0, 0.0], 0.0, 0.0) // 100% transparent gap between branches
                                }
                            } else {
                                ([0.0, 0.0, 0.0], 0.0, 0.0)
                            };

                            let idx = x * 3;
                            let dx_vignette = (x_f * inv_half_w - 1.0) as f32;

                            blend_and_vignette_pixel(
                                row_data,
                                idx,
                                fractal_rgb,
                                alpha,
                                s_alpha,
                                dx_vignette,
                                dy_vignette_sq,
                            );
                        }
                    }
                });
            }
        });
    }

    /// Helper to process, render, and write output files directly to system storage.
    pub fn apply_effect<P: AsRef<Path>>(
        &self,
        input_path: P,
        output_path: P,
    ) -> WallSwitchResult<()> {
        let img = image::open(&input_path)
            .map_err(|e| WallSwitchError::UnableToFind(format!("Failed to open image: {e}")))?;

        let mut rgb_img = img.to_rgb8();
        self.apply_effect_in_memory(&mut rgb_img);

        rgb_img
            .save(&output_path)
            .map_err(|e| WallSwitchError::Io(Error::other(e)))?;

        Ok(())
    }
}