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>,

    transform: Transform,

    ops: Vec<Op>,

}

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,

            transform,

            ops: Vec::new(),

        }

    }

    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.output, 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()

    }

    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.output, self.transform);

        let push = Push {

            dst: self.ndc(fb),

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

            color: color.components(),

        };

        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> {

        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.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.output, self.transform);

        let push = Push {

            dst: self.ndc(fb),

            uv,

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

        };

        self.ops.push(Op::Draw {

            kind: Kind::Texture,

            texture: Some(texture.clone()),

            push,

            scissors,

        });

        Ok(())

    }

    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)

    }

}