// Copyright 2023 Google LLC
//
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

use crate::ffi;
use {
    peniko::{kurbo::Affine, Brush, Color, Mix},
    std::pin::Pin,
    vello_encoding::{Encoding as VelloEncoding, RenderConfig, Transform},
};

pub(crate) struct Encoding {
    encoding: VelloEncoding,
}

pub(crate) fn new_encoding() -> Box<Encoding> {
    Box::new(Encoding::new())
}

impl Encoding {
    fn new() -> Encoding {
        // An encoding blob that doesn't represent a scene fragment (i.e. a reused blob that is
        // appended to a root encoding), then we need to initialize the transform and linewidth
        // streams with first entries (an identity transform and -1 linewidth value). Resetting
        // the encoding as non-fragment achieves this.
        let mut encoding = VelloEncoding::new();
        encoding.reset(/*is_fragment=*/ false);
        Encoding { encoding }
    }

    pub fn is_empty(self: &Encoding) -> bool {
        self.encoding.is_empty()
    }

    pub fn fill(
        self: &mut Encoding,
        style: ffi::Fill,
        transform: ffi::Affine,
        brush: &ffi::Brush,
        path_iter: Pin<&mut ffi::PathIterator>,
    ) {
        self.encoding.encode_transform(Transform::from_kurbo(&transform.into()));
        self.encoding.encode_linewidth(match style {
            ffi::Fill::NonZero => -1.0,
            ffi::Fill::EvenOdd => -2.0,
            _ => panic!("invalid fill type"),
        });
        if self.encode_path(path_iter, /*is_fill=*/ true) {
            self.encoding.encode_brush(&Brush::from(brush), 1.0)
        }
    }

    pub fn stroke(
        self: &mut Encoding,
        style: &ffi::Stroke,
        transform: ffi::Affine,
        brush: &ffi::Brush,
        path_iter: Pin<&mut ffi::PathIterator>,
    ) {
        self.encoding.encode_transform(Transform::from_kurbo(&transform.into()));
        self.encoding.encode_linewidth(style.width);
        if self.encode_path(path_iter, /*is_fill=*/ false) {
            self.encoding.encode_brush(&Brush::from(brush), 1.0)
        }
    }

    pub fn begin_clip(
        self: &mut Encoding,
        transform: ffi::Affine,
        path_iter: Pin<&mut ffi::PathIterator>,
    ) {
        self.encoding.encode_transform(Transform::from_kurbo(&transform.into()));
        self.encoding.encode_linewidth(-1.0);
        self.encode_path(path_iter, /*is_fill=*/ true);
        self.encoding.encode_begin_clip(Mix::Clip.into(), /*alpha=*/ 1.0);
    }

    pub fn end_clip(self: &mut Encoding) {
        self.encoding.encode_end_clip();
    }

    pub fn prepare_render(
        self: &Encoding,
        width: u32,
        height: u32,
        background: &ffi::Color,
    ) -> Box<RenderConfiguration> {
        let mut packed_scene = Vec::new();
        let layout = vello_encoding::resolve_solid_paths_only(&self.encoding, &mut packed_scene);
        let config = RenderConfig::new(&layout, width, height, &background.into());
        Box::new(RenderConfiguration {
            packed_scene,
            config,
        })
    }

    fn encode_path(&mut self, mut path_iter: Pin<&mut ffi::PathIterator>, is_fill: bool) -> bool {
        let segments = {
            let mut path_encoder = self.encoding.encode_path(is_fill);
            let mut path_el = ffi::PathElement::default();
            while unsafe { path_iter.as_mut().next_element(&mut path_el) } {
                match path_el.verb {
                    ffi::PathVerb::MoveTo => {
                        let p = &path_el.points[0];
                        path_encoder.move_to(p.x, p.y);
                    }
                    ffi::PathVerb::LineTo => {
                        let p = &path_el.points[1];
                        path_encoder.line_to(p.x, p.y);
                    }
                    ffi::PathVerb::QuadTo => {
                        let p0 = &path_el.points[1];
                        let p1 = &path_el.points[2];
                        path_encoder.quad_to(p0.x, p0.y, p1.x, p1.y);
                    }
                    ffi::PathVerb::CurveTo => {
                        let p0 = &path_el.points[1];
                        let p1 = &path_el.points[2];
                        let p2 = &path_el.points[3];
                        path_encoder.cubic_to(p0.x, p0.y, p1.x, p1.y, p2.x, p2.y);
                    }
                    ffi::PathVerb::Close => path_encoder.close(),
                    _ => panic!("invalid path verb"),
                }
            }
            path_encoder.finish(/*insert_path_marker=*/ true)
        };
        segments != 0
    }
}

pub(crate) struct RenderConfiguration {
    packed_scene: Vec<u8>,
    config: RenderConfig,
}

impl RenderConfiguration {
    pub fn config_uniform_buffer_size(self: &RenderConfiguration) -> usize {
        std::mem::size_of::<vello_encoding::ConfigUniform>()
    }

    pub fn scene_buffer_size(self: &RenderConfiguration) -> usize {
        self.packed_scene.len()
    }

    pub fn write_config_uniform_buffer(self: &RenderConfiguration, out_buffer: &mut [u8]) -> bool {
        let bytes = bytemuck::bytes_of(&self.config.gpu);
        if out_buffer.len() < bytes.len() {
            return false;
        }
        out_buffer.copy_from_slice(bytes);
        true
    }

    pub fn write_scene_buffer(self: &RenderConfiguration, out_buffer: &mut [u8]) -> bool {
        if out_buffer.len() < self.packed_scene.len() {
            return false;
        }
        out_buffer.copy_from_slice(&self.packed_scene);
        true
    }

    pub fn workgroup_counts(self: &RenderConfiguration) -> ffi::DispatchInfo {
        (&self.config.workgroup_counts).into()
    }

    pub fn buffer_sizes(self: &RenderConfiguration) -> ffi::BufferSizes {
        (&self.config.buffer_sizes).into()
    }
}

impl Default for ffi::PathVerb {
    fn default() -> Self {
        Self::MoveTo
    }
}

impl From<ffi::Affine> for Affine {
    fn from(src: ffi::Affine) -> Self {
        Self::new([
            src.matrix[0] as f64,
            src.matrix[1] as f64,
            src.matrix[2] as f64,
            src.matrix[3] as f64,
            src.matrix[4] as f64,
            src.matrix[5] as f64,
        ])
    }
}

impl From<&ffi::Color> for Color {
    fn from(src: &ffi::Color) -> Self {
        Self {
            r: src.r,
            g: src.g,
            b: src.b,
            a: src.a,
        }
    }
}

impl From<&ffi::Brush> for Brush {
    fn from(src: &ffi::Brush) -> Self {
        match src.kind {
            ffi::BrushKind::Solid => Brush::Solid(Color::from(&src.data.solid)),
            _ => panic!("invalid brush kind"),
        }
    }
}

impl From<&vello_encoding::WorkgroupSize> for ffi::WorkgroupSize {
    fn from(src: &vello_encoding::WorkgroupSize) -> Self {
        Self {
            x: src.0,
            y: src.1,
            z: src.2,
        }
    }
}

impl From<&vello_encoding::WorkgroupCounts> for ffi::DispatchInfo {
    fn from(src: &vello_encoding::WorkgroupCounts) -> Self {
        Self {
            use_large_path_scan: src.use_large_path_scan,
            path_reduce: (&src.path_reduce).into(),
            path_reduce2: (&src.path_reduce2).into(),
            path_scan1: (&src.path_scan1).into(),
            path_scan: (&src.path_scan).into(),
            bbox_clear: (&src.bbox_clear).into(),
            path_seg: (&src.path_seg).into(),
            draw_reduce: (&src.draw_reduce).into(),
            draw_leaf: (&src.draw_leaf).into(),
            clip_reduce: (&src.clip_reduce).into(),
            clip_leaf: (&src.clip_leaf).into(),
            binning: (&src.binning).into(),
            tile_alloc: (&src.tile_alloc).into(),
            path_coarse: (&src.path_coarse).into(),
            backdrop: (&src.backdrop).into(),
            coarse: (&src.coarse).into(),
            fine: (&src.fine).into(),
        }
    }
}

impl From<&vello_encoding::BufferSizes> for ffi::BufferSizes {
    fn from(src: &vello_encoding::BufferSizes) -> Self {
        Self {
            path_reduced: src.path_reduced.size_in_bytes(),
            path_reduced2: src.path_reduced2.size_in_bytes(),
            path_reduced_scan: src.path_reduced_scan.size_in_bytes(),
            path_monoids: src.path_monoids.size_in_bytes(),
            path_bboxes: src.path_bboxes.size_in_bytes(),
            cubics: src.cubics.size_in_bytes(),
            draw_reduced: src.draw_reduced.size_in_bytes(),
            draw_monoids: src.draw_monoids.size_in_bytes(),
            info: src.info.size_in_bytes(),
            clip_inps: src.clip_inps.size_in_bytes(),
            clip_els: src.clip_els.size_in_bytes(),
            clip_bics: src.clip_bics.size_in_bytes(),
            clip_bboxes: src.clip_bboxes.size_in_bytes(),
            draw_bboxes: src.draw_bboxes.size_in_bytes(),
            bump_alloc: src.bump_alloc.size_in_bytes(),
            bin_headers: src.bin_headers.size_in_bytes(),
            paths: src.paths.size_in_bytes(),
            bin_data: src.bin_data.size_in_bytes(),
            tiles: src.tiles.size_in_bytes(),
            segments: src.segments.size_in_bytes(),
            ptcl: src.ptcl.size_in_bytes(),
        }
    }
}