use femtovg::ImageFlags;
use femtovg::PixelFormat::Rgba8;
use femtovg::{renderer::OpenGl, Canvas, Paint};
use num_traits::{Num, NumOps};
use std::path::Path;
use std::sync::Arc;
use std::sync::Mutex;

use crate::pipeline::offscreen_renderer::CanvasWrapper;
use crate::render::cms::CMS;
use crate::render::{LayerImpl, Target};
use crate::render::{LayerImplSync, TargetType};
use crate::{
    data::{AsyncDataLoader, DataLoader, Radar2d},
    render::{Layer, Render},
};

use super::{
    color_mapper::ColorMapper,
    grid_field_renderer::{GridFieldRenderer, GridLayerImpl},
};

impl Layer {
    pub fn grid_render_layer<T, CMAP>(data: Radar2d<T>, layer_name: String, color_map: CMAP) -> Self
    where
        T: std::fmt::Debug + Num + NumOps + PartialOrd + Copy + Clone + 'static + Send + Sync,
        CMAP: ColorMapper<T> + 'static,
    {
        Self::new(
            true,
            |s, render, _| {
                let mut c = render.get_canvas();
                let c = c.as_mut().unwrap();

                let render_target = s.render_target();
                let mut unlock_target = render_target.lock().unwrap();

                let image_id = if let Some(target) = unlock_target.as_mut() {
                    let result_id = match target.target {
                        TargetType::ImageId(id) => id,
                        TargetType::Mem(ref mem) => {
                            let converted = c
                                .load_image_mem(&mem, femtovg::ImageFlags::empty())
                                .unwrap();
                            target.set_target(TargetType::ImageId(converted));
                            converted
                        }
                    };
                    let (x, y) = target.size(&render);
                    let (ox, oy) = target.origin(&render);
                    Some((result_id, (x, y), (ox, oy)))
                } else {
                    None
                };

                if let Some((id, (x, y), (ox, oy))) = image_id {
                    if let Ok(_) = c.image_size(id) {
                        let painter = Paint::image(id, ox, oy, x, y, 0.0, 1.0);
                        let mut path = femtovg::Path::new();
                        path.rect(ox, oy, x, y);
                        c.fill_path(&path, &painter);
                    }
                }
            },
            layer_name,
            Some(
                |renderer: LayerImplSync, c: Arc<Mutex<CanvasWrapper>>, cms: CMS| async move {
                    let mut canvas = c.lock().unwrap();
                    let renderer = renderer.lock().unwrap();
                    let img = renderer.draw(&mut canvas, cms).unwrap();
                    img
                },
            ),
            Some(GridLayerImpl::new(GridFieldRenderer::new(color_map), data)),
        )
    }

    pub fn grid_render_layer_with_path<T, CMAP, LOADER>(
        path: impl AsRef<Path>,
        layer_name: String,
        loader: LOADER,
        color_map: CMAP,
    ) -> Self
    where
        T: Num + NumOps + PartialOrd + Copy + Clone + 'static + std::fmt::Debug + Sync + Send,
        CMAP: ColorMapper<T> + 'static,
        LOADER: DataLoader<T, Radar2d<T>>,
    {
        let data = loader.load(path).unwrap();
        self::Layer::grid_render_layer(data, layer_name, color_map)
    }

    pub async fn grid_render_layer_with_path_async<T, CMAP, LOADER>(
        path: impl AsRef<Path> + Send,
        layer_name: String,
        loader: LOADER,
        color_map: CMAP,
    ) -> Self
    where
        T: Num + NumOps + PartialOrd + Copy + Clone + 'static + std::fmt::Debug + Send + Sync,
        CMAP: ColorMapper<T> + 'static,
        LOADER: AsyncDataLoader<T, Radar2d<T>>,
    {
        let data = loader.load(path).await.unwrap();
        self::Layer::grid_render_layer(data, layer_name, color_map)
    }
}