use std::cell::OnceCell;

use std::collections::HashMap;

use std::rc::Rc;

use crate::bbox::BoundingBox;

use crate::coord_units::CoordUnits;

use crate::document::AcquiredNodes;

use crate::drawing_ctx::DrawingCtx;

use crate::filter::UserSpaceFilter;

use crate::paint_server::UserSpacePaintSource;

use crate::parsers::CustomIdent;

use crate::properties::ColorInterpolationFilters;

use crate::rect::{IRect, Rect};

use crate::surface_utils::shared_surface::{SharedImageSurface, SurfaceType};

use crate::transform::Transform;

use super::error::FilterError;

use super::Input;

/// A filter primitive output.

pub struct FilterOutput {

    /// The surface after the filter primitive was applied.

    /// The filter primitive subregion.

}

/// A filter primitive result.

pub struct FilterResult {

    /// The name of this result: the value of the `result` attribute.

    /// The output.

}

/// An input to a filter primitive.

pub enum FilterInput {

    /// One of the standard inputs.

    /// Output of another filter primitive.

}

/// The filter rendering context.

pub struct FilterContext {

    /// Paint source for primitives which have an input value equal to `StrokePaint`.

    stroke_paint: Rc<UserSpacePaintSource>,

    /// Paint source for primitives which have an input value equal to `FillPaint`.

    fill_paint: Rc<UserSpacePaintSource>,

    /// The source graphic surface.

    source_surface: SharedImageSurface,

    /// Output of the last filter primitive.

    last_result: Option<FilterOutput>,

    /// Surfaces of the previous filter primitives by name.

    previous_results: HashMap<CustomIdent, FilterOutput>,

    /// Input surface for primitives that require an input of `BackgroundImage` or `BackgroundAlpha`. Computed lazily.

    background_surface: OnceCell<Result<SharedImageSurface, FilterError>>,

    // Input surface for primitives that require an input of `StrokePaint`, Computed lazily.

    stroke_paint_surface: OnceCell<Result<SharedImageSurface, FilterError>>,

    // Input surface for primitives that require an input of `FillPaint`, Computed lazily.

    fill_paint_surface: OnceCell<Result<SharedImageSurface, FilterError>>,

    /// Primtive units

    primitive_units: CoordUnits,

    /// The filter effects region.

    effects_region: Rect,

    /// The filter element affine matrix.

    ///

    /// If `filterUnits == userSpaceOnUse`, equal to the drawing context matrix, so, for example,

    /// if the target node is in a group with `transform="translate(30, 20)"`, this will be equal

    /// to a matrix that translates to 30, 20 (and does not scale). Note that the target node

    /// bounding box isn't included in the computations in this case.

    ///

    /// If `filterUnits == objectBoundingBox`, equal to the target node bounding box matrix

    /// multiplied by the drawing context matrix, so, for example, if the target node is in a group

    /// with `transform="translate(30, 20)"` and also has `x="1", y="1", width="50", height="50"`,

    /// this will be equal to a matrix that translates to 31, 21 and scales to 50, 50.

    ///

    /// This is to be used in conjunction with setting the viewbox size to account for the scaling.

    /// For `filterUnits == userSpaceOnUse`, the viewbox will have the actual resolution size, and

    /// for `filterUnits == objectBoundingBox`, the viewbox will have the size of 1, 1.

    _affine: Transform,

    /// The filter primitive affine matrix.

    ///

    /// See the comments for `_affine`, they largely apply here.

    paffine: Transform,

}

impl FilterContext {

    /// Creates a new `FilterContext`.

        filter: &UserSpaceFilter,

        stroke_paint: Rc<UserSpacePaintSource>,

        fill_paint: Rc<UserSpacePaintSource>,

        source_surface: &SharedImageSurface,

        draw_transform: Transform,

        node_bbox: BoundingBox,

    ) -> Result<Self, FilterError> {

        // The rect can be empty (for example, if the filter is applied to an empty group).

        // However, with userSpaceOnUse it's still possible to create images with a filter.

                0.0,

                0.0,

            )

            .post_transform(&draw_transform),

        };

                0.0,

                0.0,

            )

            .post_transform(&draw_transform),

        };

            ));

        }

        let effects_region = {

            // At this point all of the previous viewbox and matrix business gets converted to pixel

            // coordinates in the final surface, because bbox is created with an identity transform.

            // Finally, clip to the width and height of our surface.

        };

            effects_region,

    /// Returns the surface corresponding to the source graphic.

    #[inline]

        &self.source_surface

    /// Returns the surface corresponding to the background image snapshot.

                .map_err(FilterError::Rendering)

    /// Returns a surface filled with the current stroke's paint, for `StrokePaint` inputs in primitives.

    ///

    /// Filter Effects 1: <https://www.w3.org/TR/filter-effects/#attr-valuedef-in-strokepaint>

        &self,

        acquired_nodes: &mut AcquiredNodes<'_>,

        draw_ctx: &mut DrawingCtx,

    ) -> Result<SharedImageSurface, FilterError> {

    /// Returns a surface filled with the current fill's paint, for `FillPaint` inputs in primitives.

    ///

    /// Filter Effects 1: <https://www.w3.org/TR/filter-effects/#attr-valuedef-in-fillpaint>

        &self,

        acquired_nodes: &mut AcquiredNodes<'_>,

        draw_ctx: &mut DrawingCtx,

    ) -> Result<SharedImageSurface, FilterError> {

    /// Converts this `FilterContext` into the surface corresponding to the output of the filter

    /// chain.

    ///

    /// The returned surface is in the sRGB color space.

    // TODO: sRGB conversion should probably be done by the caller.

    #[inline]

            ),

        }

    /// Stores a filter primitive result into the context.

    #[inline]

        }

    /// Returns the paffine matrix.

    #[inline]

    /// Returns the primitive units.

    #[inline]

    /// Returns the filter effects region.

    #[inline]

    /// Get a filter primitive's default input as if its `in=\"...\"` were not specified.

    ///

    /// Per <https://drafts.fxtf.org/filter-effects/#element-attrdef-filter-primitive-in>,

    /// "References to non-existent results will be treated as if no result was

    /// specified".  That is, fall back to the last result in the filter chain, or if this

    /// is the first in the chain, just use SourceGraphic.

        } else {

        }

    /// Retrieves the filter input surface according to the SVG rules.

        &self,

        acquired_nodes: &mut AcquiredNodes<'_>,

        draw_ctx: &mut DrawingCtx,

        in_: &Input,

    ) -> Result<FilterInput, FilterError> {

                .source_graphic()

                .map_err(FilterError::CairoError)

                .map(FilterInput::StandardInput),

                .background_image(draw_ctx)

                .map(FilterInput::StandardInput),

                .background_image(draw_ctx)

                        .map_err(FilterError::CairoError)

                .map(FilterInput::StandardInput),

                .fill_paint_image(acquired_nodes, draw_ctx)

                .map(FilterInput::StandardInput),

                .stroke_paint_image(acquired_nodes, draw_ctx)

                .map(FilterInput::StandardInput),

                        // Happy path: we found a previous primitive's named output, so pass it on.

                    None => {

                        // Fallback path: we didn't find a primitive's output by the

                        // specified name, so fall back to using an unspecified output.

                        // Per the spec, "References to non-existent results will be

                        // treated as if no result was specified." -

                        // https://drafts.fxtf.org/filter-effects/#element-attrdef-filter-primitive-in

                    }

                };

        }

    /// Retrieves the filter input surface according to the SVG rules.

    ///

    /// The surface will be converted to the color space specified by `color_interpolation_filters`.

        &self,

        acquired_nodes: &mut AcquiredNodes<'_>,

        draw_ctx: &mut DrawingCtx,

        in_: &Input,

        color_interpolation_filters: ColorInterpolationFilters,

    ) -> Result<FilterInput, FilterError> {

        // Convert the input surface to the desired format.

            FilterInput::PrimitiveOutput(FilterOutput {

        };

        };

            .map_err(FilterError::CairoError)

}

impl FilterInput {

    /// Retrieves the surface from `FilterInput`.

    #[inline]

        }

}