use std::{any::TypeId, sync::Arc};

use gpui::{
    div, AnyView, AppContext, Component, DispatchPhase, Div, ParentElement, Render,
    StatelessInteractive, View, ViewContext,
};

use crate::Workspace;

pub struct ModalRegistry {
    registered_modals: Vec<(TypeId, Box<dyn Fn(Div<Workspace>) -> Div<Workspace>>)>,
}

pub trait Modal {}

#[derive(Clone)]
pub struct ModalLayer {
    open_modal: Option<AnyView>,
}

pub fn init_modal_registry(cx: &mut AppContext) {
    cx.set_global(ModalRegistry {
        registered_modals: Vec::new(),
    });
}

struct ToggleModal {
    name: String,
}

// complete change of plan?
// on_action(ToggleModal{ name})
// register_modal(name, |workspace, cx| { ... })

impl ModalRegistry {
    pub fn register_modal<A: 'static, V, B>(&mut self, action: A, build_view: B)
    where
        V: Render,
        B: Fn(&Workspace, &mut ViewContext<Workspace>) -> View<V> + 'static,
    {
        let build_view = Arc::new(build_view);

        dbg!("yonder");
        self.registered_modals.push((
            TypeId::of::<A>(),
            Box::new(move |mut div| {
                let build_view = build_view.clone();
                dbg!("this point");

                div.on_action(
                    move |workspace: &mut Workspace,
                          event: &A,
                          phase: DispatchPhase,
                          cx: &mut ViewContext<Workspace>| {
                        dbg!("GOT HERE");
                        if phase == DispatchPhase::Capture {
                            return;
                        }

                        let new_modal = (build_view)(workspace, cx);
                        workspace.modal_layer.update(cx, |modal_layer, _| {
                            modal_layer.open_modal = Some(new_modal.into());
                        });

                        cx.notify();
                    },
                )
            }),
        ));
    }
}

impl ModalLayer {
    pub fn new() -> Self {
        Self { open_modal: None }
    }

    pub fn render(&self, cx: &ViewContext<Workspace>) -> impl Component<Workspace> {
        dbg!("rendering ModalLayer");

        let mut div = div();

        // div, c workspace.toggle_modal()div.on_action()) {
        //
        // }

        // for (type_id, action) in cx.global::<ModalRegistry>().registered_modals.iter() {
        //     div = div.useful_on_action(*type_id, action)
        // }

        for (_, action) in cx.global::<ModalRegistry>().registered_modals.iter() {
            div = (action)(div);
        }

        div.children(self.open_modal.clone())
    }
}

// impl Render for ModalLayer {
//     type Element = Div<Self>;

//     fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
//         let mut div = div();
//         for (type_id, build_view) in cx.global::<ModalRegistry>().registered_modals {
//             div = div.useful_on_action(
//                 type_id,
//                 Box::new(|this, _: dyn Any, phase, cx: &mut ViewContext<Self>| {
//                     if phase == DispatchPhase::Capture {
//                         return;
//                     }
//                     self.workspace.update(cx, |workspace, cx| {
//                         self.open_modal = Some(build_view(workspace, cx));
//                     });
//                     cx.notify();
//                 }),
//             )
//         }

//         div
//     }
// }