use std::sync::Arc;

use image::EncodableLayout;
use log::info;
use rand::Rng;
use wgpu::{Extent3d, Texture, TextureUsages};

use crate::{
    app::App,
    diff::Differ,
    export::Exporter,
    helper::write_texture,
    paint::{PaintUniforms, Painter},
};

#[allow(unused)]
pub struct Approximator {
    app: Arc<App>,
    size: Extent3d,
    differ: Differ,
    painter: Painter,
    exporter: Exporter,

    tex_approx: Texture,
    tex_savestate: Texture,
    tex_target: Texture,
}

impl Approximator {
    pub fn new(app: &Arc<App>, tex_target: Texture, size: Extent3d) -> Self {
        let App { device, queue, .. } = app.as_ref();
        let tex_approx = device.create_texture(&wgpu::TextureDescriptor {
            size,
            mip_level_count: 1,
            sample_count: 1,
            dimension: wgpu::TextureDimension::D2,
            format: wgpu::TextureFormat::Rgba8Unorm,
            usage: TextureUsages::COPY_DST
                | TextureUsages::TEXTURE_BINDING
                | TextureUsages::STORAGE_BINDING
                | TextureUsages::COPY_SRC,
            label: None,
        });
        let tex_savestate = device.create_texture(&wgpu::TextureDescriptor {
            size,
            mip_level_count: 1,
            sample_count: 1,
            dimension: wgpu::TextureDimension::D2,
            format: wgpu::TextureFormat::Rgba8Unorm,
            usage: TextureUsages::COPY_DST | TextureUsages::COPY_SRC,
            label: None,
        });

        let img_initial = image::open("a/initial.png").unwrap().into_rgba8();
        write_texture(queue, &tex_approx, img_initial.as_bytes(), size);

        let differ = Differ::new(&app, size, &tex_approx, &tex_target);
        let painter = Painter::new(&app, size, &tex_approx);
        let exporter = Exporter::new(&app, size);

        Approximator {
            app: app.clone(),
            size,
            differ,
            tex_savestate,
            tex_approx,
            tex_target,
            painter,
            exporter,
        }
    }

    pub fn save(&self) {
        self.app
            .copy_texture(&self.tex_approx, &self.tex_savestate, self.size);
    }
    pub fn restore(&self) {
        self.app
            .copy_texture(&self.tex_savestate, &self.tex_approx, self.size);
    }

    pub async fn run(&mut self) {
        for _ in 0..10 {
            let mut p = PaintUniforms {
                x: rand::thread_rng().gen_range(0.0..256.0),
                y: rand::thread_rng().gen_range(0.0..256.0),
                r: rand::thread_rng().gen_range(0.0..1.0),
                g: rand::thread_rng().gen_range(0.0..1.0),
                b: rand::thread_rng().gen_range(0.0..1.0),
                radius: rand::thread_rng().gen_range(5.0..10.0),
            };

            // Find initial diff
            self.save();
            self.painter.run(p);
            let mut cd = pollster::block_on(self.differ.run());
            info!("initial diff={cd}");
            self.restore();

            self.save();
            loop {
                let mut q = 0;
                q += self.optimize_param(&mut cd, &mut p, "more red", |p| p.r += 0.1);
                q += self.optimize_param(&mut cd, &mut p, "less red", |p| p.r -= 0.1);
                q += self.optimize_param(&mut cd, &mut p, "more green", |p| p.g += 0.1);
                q += self.optimize_param(&mut cd, &mut p, "less green", |p| p.g -= 0.1);
                q += self.optimize_param(&mut cd, &mut p, "more blue", |p| p.b += 0.1);
                q += self.optimize_param(&mut cd, &mut p, "less blue", |p| p.b -= 0.1);
                q += self.optimize_param(&mut cd, &mut p, "increase radius", |p| p.radius *= 1.5);
                q += self.optimize_param(&mut cd, &mut p, "decrease radius", |p| p.radius *= 1.5);
                q += self.optimize_param(&mut cd, &mut p, "move right", |p| p.x += 5.0);
                q += self.optimize_param(&mut cd, &mut p, "move left", |p| p.x -= 5.0);
                q += self.optimize_param(&mut cd, &mut p, "move down", |p| p.y += 5.0);
                q += self.optimize_param(&mut cd, &mut p, "move up", |p| p.y -= 5.0);
                if q == 0 {
                    break;
                }
            }
            self.painter.run(p);
        }

        self.exporter.run(&self.tex_approx, "a/approx.png").await;
    }

    pub fn optimize_param<F>(
        &self,
        current_diff: &mut u32,
        params: &mut PaintUniforms,
        label: &'static str,
        f: F,
    ) -> usize
    where
        F: Fn(&mut PaintUniforms) -> (),
    {
        let mut p = params.clone();
        let mut i = 0;
        loop {
            f(&mut p);
            self.painter.run(p);
            let diff = pollster::block_on(self.differ.run());
            // pollster::block_on(self.exporter.run(&self.tex_approx, &format!("a/snap.png")));
            self.restore();
            if diff >= *current_diff {
                break i;
            }
            info!("applied {label:?} (before={current_diff} after={diff})");
            i += 1;
            *current_diff = diff;
        }
    }
}