use crate::{
    widgets::renderer,
    windows_manager::{AllBuffers, WindowsManager},
    GIAPP, RUNTIME,
};
use element_bridge::TextureBridge;
use futures::future::BoxFuture;
use log::info;
use makepad_widgets::{Cx, Texture, ToUISender};
use mp_elements::{
    app::{DrawList, RenderWindow},
    App,
};
use std::sync::{Arc, Mutex};

#[derive(Default)]
pub struct RenderTasks {
    pub(crate) tasks: Vec<RenderTask>,
}

impl RenderTasks {
    pub fn new() -> Self {
        Self { tasks: Vec::new() }
    }

    fn push_task(&mut self, task: RenderTask) {
        self.tasks.push(task);
    }

    pub fn register_task(
        &mut self,
        sender: ToUISender<Vec<u8>>,
        bridge_id: usize,
        bridge: Arc<RenderWindow>,
        draw_list: DrawList,
    ) {
        let task = RenderTask::new(bridge_id, sender, bridge, draw_list);
        self.push_task(task);
    }

    pub fn clear(&mut self) {
        self.tasks.clear();
    }

    pub async fn render(&self) {
        // Draw all tasks
        let futures: Vec<_> = self
            .tasks
            .iter()
            .map(|task| async {
                info!("Drawing task");
                task.draw().await;
            })
            .collect();
        futures::future::join_all(futures).await;
    }
}

pub struct RenderTask {
    bridge_id: usize,
    sender: ToUISender<Vec<u8>>,
    buffer: Arc<Mutex<Vec<u8>>>,
    render_window: Arc<RenderWindow>,
    draw_list: DrawList,
}

impl RenderTask {
    pub fn new(
        bridge_id: usize,
        sender: ToUISender<Vec<u8>>,
        bridge_render_window: Arc<RenderWindow>,
        draw_list: DrawList,
    ) -> Self {
        Self {
            bridge_id,
            sender,
            buffer: Arc::new(Mutex::new(vec![0u8; 256 * 256 * 4])),
            render_window: bridge_render_window,
            draw_list,
        }
    }

    pub async fn draw(&self) {
        GIAPP
            .draw(&self.render_window, self.draw_list.clone())
            .await;

        let ctx = GIAPP.ctx();
        let mut bf = Vec::with_capacity(256 * 256 * 4);
        TextureBridge::load_data(&mut bf, ctx, &self.render_window).await;
        self.sender.send(bf).unwrap();
    }
}