monolith

use crate::Error;

use crate::image::{VulkanTarget, VulkanTexture};

use crate::pipeline::{Kind, Push};

use crate::renderer::VulkanRenderer;

use crate::transform::{rect_to_framebuffer, texture_uvs, to_framebuffer};

use ash::vk;

use smithay::backend::renderer::sync::SyncPoint;

use smithay::backend::renderer::{Color32F, ContextId, Frame, Texture};

use smithay::utils::{Buffer, Physical, Rectangle, Size, Transform};

use std::sync::Arc;

pub(crate) enum Op {

    Clear {

        color: [f32; 4],

        rects: Vec<vk::Rect2D>,

    },

    Draw {

        kind: Kind,

        texture: Option<VulkanTexture>,

        push: Push,

        scissors: Vec<vk::Rect2D>,

    },

}

/// A frame in progress. Draws are recorded and submitted together by [`Frame::finish`].

pub struct VulkanFrame<'frame, 'buffer> {

    renderer: &'frame mut VulkanRenderer,

    target: &'frame mut VulkanTarget<'buffer>,

    output: Size<i32, Physical>,

    /// The output rotated into the space draws are given in, which differs

    /// from `output` for 90 and 270 degree transforms.

    area: Size<i32, Physical>,

    transform: Transform,

    ops: Vec<Op>,

    clip: Option<Clip>,

}

/// A rounded rect in output space that later draws are cut to, until

/// [`VulkanFrame::set_clip`] changes it. A nonzero `ring` keeps only a band

/// that wide inside the edge.

#[derive(Clone, Copy, Debug, PartialEq)]

pub struct Clip {

    pub rect: Rectangle<i32, Physical>,

    /// Top left, top right, bottom right and bottom left, in pixels.

    pub radii: [f32; 4],

    pub ring: f32,

}

impl std::fmt::Debug for VulkanFrame<'_, '_> {

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

        f.debug_struct("VulkanFrame")

            .field("output", &self.output)

            .field("ops", &self.ops.len())

            .finish()

    }

}

impl<'frame, 'buffer> VulkanFrame<'frame, 'buffer> {

    pub(crate) fn new(

        renderer: &'frame mut VulkanRenderer,

        target: &'frame mut VulkanTarget<'buffer>,

        output: Size<i32, Physical>,

        transform: Transform,

    ) -> Self {

        Self {

            renderer,

            target,

            output,

            area: transform.transform_size(output),

            transform,

            ops: Vec::new(),

            clip: None,

        }

    }

    pub fn set_clip(&mut self, clip: Option<Clip>) {

        self.clip = clip;

    }

    /// The clip's push constants in framebuffer space, where an output

    /// transform moves each radius to another corner.

    fn clip_push(&self) -> ([f32; 4], [f32; 4], [f32; 4]) {

        let Some(c) = self.clip else {

            return ([0.0; 4], [0.0; 4], [0.0; 4]);

        };

        let [tl, tr, br, bl] = c.radii;

        let corners = [[tl, 0.0], [tr, 0.0], [bl, 0.0], [br, 0.0]];

        let (fb, r) = to_framebuffer(c.rect, corners, self.area, self.transform);

        let rect = [

            fb.loc.x as f32,

            fb.loc.y as f32,

            fb.size.w as f32,

            fb.size.h as f32,

        ];

        let most = fb.size.w.min(fb.size.h) as f32 / 2.0;

        let radii = [r[0][0], r[1][0], r[3][0], r[2][0]].map(|r| r.min(most));

        (rect, radii, [c.ring, 0.0, 0.0, 0.0])

    }

    fn fb_size(&self) -> Size<i32, Physical> {

        (self.target.width() as i32, self.target.height() as i32).into()

    }

    fn fb_rect(&self, r: Rectangle<i32, Physical>) -> Option<vk::Rect2D> {

        let r = rect_to_framebuffer(r, self.area, self.transform)

            .intersection(Rectangle::from_size(self.fb_size()))?;

        Some(vk::Rect2D {

            offset: vk::Offset2D {

                x: r.loc.x,

                y: r.loc.y,

            },

            extent: vk::Extent2D {

                width: r.size.w as u32,

                height: r.size.h as u32,

            },

        })

    }

    fn scissors(

        &self,

        dst: Rectangle<i32, Physical>,

        damage: &[Rectangle<i32, Physical>],

    ) -> Vec<vk::Rect2D> {

        damage

            .iter()

            .filter_map(|d| d.intersection(Rectangle::from_size(dst.size)))

            .filter_map(|mut d| {

                d.loc += dst.loc;

                self.fb_rect(d)

            })

            .collect()

    }

    /// Draws a texture through the transition hook in `shaders/effect.frag`.

    #[expect(clippy::too_many_arguments)]

    pub fn render_effect(

        &mut self,

        texture: &VulkanTexture,

        src: Rectangle<f64, Buffer>,

        dst: Rectangle<i32, Physical>,

        damage: &[Rectangle<i32, Physical>],

        src_transform: Transform,

        alpha: f32,

        effect: Effect,

    ) -> Result<(), Error> {

        let params = [effect.progress, effect.kind as u32 as f32, 0.0, 0.0];

        self.draw_texture(

            texture,

            src,

            dst,

            damage,

            src_transform,

            alpha,

            Kind::Effect,

            params,

        )

    }

    #[expect(clippy::too_many_arguments)]

    fn draw_texture(

        &mut self,

        texture: &VulkanTexture,

        src: Rectangle<f64, Buffer>,

        dst: Rectangle<i32, Physical>,

        damage: &[Rectangle<i32, Physical>],

        src_transform: Transform,

        alpha: f32,

        kind: Kind,

        effect: [f32; 4],

    ) -> Result<(), Error> {

        if !Arc::ptr_eq(&texture.0.shared, self.renderer.shared()) {

            return Err(Error::ForeignTexture);

        }

        if dst.size.w <= 0 || dst.size.h <= 0 || Arc::ptr_eq(&texture.0, &self.target.0) {

            return Ok(());

        }

        let scissors = self.scissors(dst, damage);

        if scissors.is_empty() {

            return Ok(());

        }

        let uvs = texture_uvs(src, dst.size, texture.size(), src_transform);

        let (fb, uv) = to_framebuffer(dst, uvs, self.area, self.transform);

        let (clip, radii, ring) = self.clip_push();

        let push = Push {

            dst: self.ndc(fb),

            uv,

            color: [1.0, 1.0, 1.0, alpha],

            effect,

            clip,

            radii,

            ring,

        };

        self.ops.push(Op::Draw {

            kind,

            texture: Some(texture.clone()),

            push,

            scissors,

        });

        Ok(())

    }

    fn ndc(&self, r: Rectangle<i32, Physical>) -> [f32; 4] {

        let fb = self.fb_size();

        let (w, h) = (fb.w as f32, fb.h as f32);

        [

            r.loc.x as f32 / w * 2.0 - 1.0,

            r.loc.y as f32 / h * 2.0 - 1.0,

            r.size.w as f32 / w * 2.0,

            r.size.h as f32 / h * 2.0,

        ]

    }

}

impl Frame for VulkanFrame<'_, '_> {

    type Error = Error;

    type TextureId = VulkanTexture;

    fn context_id(&self) -> ContextId<VulkanTexture> {

        self.renderer.context_id_ref().clone()

    }

    fn clear(&mut self, color: Color32F, at: &[Rectangle<i32, Physical>]) -> Result<(), Error> {

        let rects: Vec<_> = at.iter().filter_map(|r| self.fb_rect(*r)).collect();

        if !rects.is_empty() {

            self.ops.push(Op::Clear {

                color: color.components(),

                rects,

            });

        }

        Ok(())

    }

    fn draw_solid(

        &mut self,

        dst: Rectangle<i32, Physical>,

        damage: &[Rectangle<i32, Physical>],

        color: Color32F,

    ) -> Result<(), Error> {

        let scissors = self.scissors(dst, damage);

        if scissors.is_empty() {

            return Ok(());

        }

        let (fb, _) = to_framebuffer(dst, [[0.0; 2]; 4], self.area, self.transform);

        let (clip, radii, ring) = self.clip_push();

        let push = Push {

            dst: self.ndc(fb),

            uv: [[0.0; 2]; 4],

            color: color.components(),

            effect: [0.0; 4],

            clip,

            radii,

            ring,

        };

        self.ops.push(Op::Draw {

            kind: Kind::Solid,

            texture: None,

            push,

            scissors,

        });

        Ok(())

    }

    fn render_texture_from_to(

        &mut self,

        texture: &VulkanTexture,

        src: Rectangle<f64, Buffer>,

        dst: Rectangle<i32, Physical>,

        damage: &[Rectangle<i32, Physical>],

        _opaque_regions: &[Rectangle<i32, Physical>],

        src_transform: Transform,

        alpha: f32,

    ) -> Result<(), Error> {

        self.draw_texture(

            texture,

            src,

            dst,

            damage,

            src_transform,

            alpha,

            Kind::Texture,

            [0.0; 4],

        )

    }

    fn transformation(&self) -> Transform {

        self.transform

    }

    fn output_size(&self) -> Size<i32, Physical> {

        self.output

    }

    fn wait(&mut self, sync: &SyncPoint) -> Result<(), Error> {

        sync.wait().map_err(|_| Error::Interrupted)

    }

    fn finish(mut self) -> Result<SyncPoint, Error> {

        let ops = std::mem::take(&mut self.ops);

        self.renderer.submit(self.target, ops)

    }

}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]

pub enum Transition {

    Move = 0,

    Spawn = 1,

    Close = 2,

}

/// A window transition for the effect shader, with `progress` in [0, 1].

#[derive(Clone, Copy, Debug, PartialEq)]

pub struct Effect {

    pub kind: Transition,

    pub progress: f32,

}