use std::cell::{Cell, RefCell};
use std::ops::Deref as _;
use std::rc::Rc;
use std::sync::Arc;

use gpui::prelude::FluentBuilder as _;
use gpui::{
    AnyElement, AnyView, App, AppContext as _, Bounds, Context, Div, Empty, Entity,
    GlobalElementId, ImageSource, InspectorElementId, InteractiveElement as _, IntoElement,
    LayoutId, MouseButton, MouseMoveEvent, MouseUpEvent, ParentElement as _, Pixels, Render,
    ScrollHandle, SharedString, Stateful, StatefulInteractiveElement as _, Style, StyleRefinement,
    Styled as _, WeakEntity, Window, actions, div, px,
};
pub use gpui_base::dock::{DockArea, DockLayout, DockPlacement};
use gpui_base::dock::{
    DockAreaRenderer, DockContext, DragPanel, DropIndicator, InsertTarget, NodeId, PaneNode,
    PaneRef, PanelId, TabGroupContext, TabGroupRenderer,
};
use gpui_base::{HandleEdge, Placement, ResizeHandleContext};
use theme::{ActiveTheme, TABBAR_HEIGHT, TextStyle, Typeset as _, button_radius, panel_radius};

use crate::button::{Button, ButtonVariants as _};
use crate::resizable::{resize_handle, resize_handle_appearance};
use crate::tab::Tab;
use crate::tab::tab_bar::TabBar;
use crate::title_bar::{TRAFFIC_LIGHT_PADDING, title_bar_drag_handlers, window_controls};
use crate::{IconName, Selectable, Sizable, StyledExt, background, h_flex, v_flex};

mod panel;
pub use panel::*;

actions!(dock, [ToggleZoom, ClosePanel]);

pub fn dock_area(
    id: impl Into<SharedString>,
    window: &mut Window,
    cx: &mut App,
) -> Entity<DockArea> {
    let shared = Rc::new(SkinShared {
        area: RefCell::new(None),
        resizing: Cell::new(None),
    });
    let area = cx.new(|cx| {
        DockArea::new(id, None, window, cx).with_renderer(Rc::new(DockSkin {
            shared: shared.clone(),
        }))
    });

    *shared.area.borrow_mut() = Some(area.downgrade());
    area
}

pub fn add_panel(
    area: &mut DockArea,
    panel: PanelHandle,
    placement: DockPlacement,
    window: &mut Window,
    cx: &mut Context<DockArea>,
) {
    let key = panel.panel().panel_id(cx);
    if let Some((id, node, ix)) = find_panel(area, &key, cx) {
        area.move_panel(
            id,
            InsertTarget::Tabs {
                node,
                ix: Some(ix),
                activate: true,
            },
            window,
            cx,
        );
        return;
    }

    area.add_panel_view(Arc::new(panel), placement, None, window, cx);
}

/// Add a panel to a dock reached through a weak handle.
pub fn add_panel_to(
    dock: &WeakEntity<DockArea>,
    panel: PanelHandle,
    placement: DockPlacement,
    window: &mut Window,
    cx: &mut App,
) {
    if let Err(error) = dock.update(cx, |area, cx| {
        add_panel(area, panel, placement, window, cx);
    }) {
        log::warn!("Failed to add panel to dock: {error}");
    }
}

/// The panel in any region of `area` whose logical id is `key`.
fn find_panel(area: &DockArea, key: &SharedString, cx: &App) -> Option<(PanelId, NodeId, usize)> {
    let placements = [
        DockPlacement::Center,
        DockPlacement::Left,
        DockPlacement::Right,
        DockPlacement::Bottom,
    ];

    for placement in placements {
        let Some(tree) = area.layout(placement) else {
            continue;
        };

        for id in tree.panels() {
            let matches = area
                .panel(id)
                .and_then(PanelHandle::of)
                .is_some_and(|handle| handle.panel().panel_id(cx) == *key);
            if !matches {
                continue;
            }

            let Some(node) = tree.find_panel_node(id) else {
                continue;
            };
            let Some(PaneRef::Tabs { panels, .. }) = tree.find_node(node).map(PaneNode::kind)
            else {
                continue;
            };
            let Some(ix) = panels.iter().position(|candidate| *candidate == id) else {
                continue;
            };

            return Some((id, node, ix));
        }
    }

    None
}

fn left_top_group(node: &PaneNode) -> Option<NodeId> {
    match node.kind() {
        PaneRef::Tabs { .. } => Some(node.id()),
        PaneRef::Split { children, .. } => children.first().and_then(left_top_group),
    }
}

fn right_top_group(node: &PaneNode) -> Option<NodeId> {
    match node.kind() {
        PaneRef::Tabs { .. } => Some(node.id()),
        PaneRef::Split { axis, children, .. } => {
            let child = if axis == gpui::Axis::Vertical {
                children.first()
            } else {
                children.last()
            };
            child.and_then(right_top_group)
        }
    }
}

#[derive(Default)]
struct SkinShared {
    area: RefCell<Option<WeakEntity<DockArea>>>,
    resizing: Cell<Option<DockPlacement>>,
}

impl SkinShared {
    fn area(&self) -> Option<Entity<DockArea>> {
        self.area.borrow().as_ref().and_then(|area| area.upgrade())
    }
}

struct DockSkin {
    shared: Rc<SkinShared>,
}

impl DockSkin {
    fn resize_handle(&self, dock: &DockContext) -> impl IntoElement {
        let placement = dock.placement();
        let shared = self.shared.clone();

        let id = match placement {
            DockPlacement::Left => "dock-resize-handle-left",
            DockPlacement::Right => "dock-resize-handle-right",
            DockPlacement::Bottom => "dock-resize-handle-bottom",
            DockPlacement::Center => "dock-resize-handle-center",
        };

        let edge = match placement {
            DockPlacement::Left => Some(HandleEdge::Trailing),
            DockPlacement::Right | DockPlacement::Bottom => Some(HandleEdge::Leading),
            DockPlacement::Center => None,
        };

        resize_handle(id, placement.axis())
            .when_some(edge, |this, edge| this.inside(edge))
            .with_appearance(resize_handle_appearance())
            .on_drag(DockResizeHandle, move |info, _, _, cx| {
                cx.stop_propagation();
                shared.resizing.set(Some(placement));
                cx.new(|_| info.deref().clone())
            })
    }
}

impl DockAreaRenderer for DockSkin {
    fn render_split_handle(
        &self,
        handle: &ResizeHandleContext,
        window: &mut Window,
        cx: &mut App,
    ) -> Option<AnyElement> {
        resize_handle_appearance()(handle, window, cx)
    }

    fn render_dock(
        &self,
        dock: &DockContext,
        content: AnyElement,
        _: &mut Window,
        _: &mut App,
    ) -> AnyElement {
        div()
            .flex()
            .size_full()
            .relative()
            .child(content)
            .child(self.resize_handle(dock))
            .child(DockResizeTracker {
                dock: dock.clone(),
                shared: self.shared.clone(),
            })
            .into_any_element()
    }

    fn tab_group_renderer(&self) -> Rc<dyn TabGroupRenderer> {
        Rc::new(TabGroupSkin::new(self.shared.clone()))
    }
}

/// The payload a dock's resize handle drags; the handle is the affordance.
#[derive(Clone)]
struct DockResizeHandle;

impl Render for DockResizeHandle {
    fn render(&mut self, _: &mut Window, _: &mut Context<Self>) -> impl IntoElement {
        Empty
    }
}

/// Turns the window's mouse stream into dock resizing.
struct DockResizeTracker {
    dock: DockContext,
    shared: Rc<SkinShared>,
}

impl IntoElement for DockResizeTracker {
    type Element = Self;

    fn into_element(self) -> Self::Element {
        self
    }
}

impl gpui::Element for DockResizeTracker {
    type PrepaintState = ();
    type RequestLayoutState = ();

    fn id(&self) -> Option<gpui::ElementId> {
        None
    }

    fn source_location(&self) -> Option<&'static std::panic::Location<'static>> {
        None
    }

    fn request_layout(
        &mut self,
        _: Option<&GlobalElementId>,
        _: Option<&InspectorElementId>,
        window: &mut Window,
        cx: &mut App,
    ) -> (LayoutId, Self::RequestLayoutState) {
        (window.request_layout(Style::default(), None, cx), ())
    }

    fn prepaint(
        &mut self,
        _: Option<&GlobalElementId>,
        _: Option<&InspectorElementId>,
        _: Bounds<Pixels>,
        _: &mut Self::RequestLayoutState,
        _: &mut Window,
        _: &mut App,
    ) {
    }

    fn paint(
        &mut self,
        _: Option<&GlobalElementId>,
        _: Option<&InspectorElementId>,
        _: Bounds<Pixels>,
        _: &mut Self::RequestLayoutState,
        _: &mut Self::PrepaintState,
        window: &mut Window,
        _: &mut App,
    ) {
        let placement = self.dock.placement();

        window.on_mouse_event({
            let dock = self.dock.clone();
            let shared = self.shared.clone();
            move |event: &MouseMoveEvent, phase, window, cx| {
                if !phase.bubble() || shared.resizing.get() != Some(placement) {
                    return;
                }

                let open = shared
                    .area()
                    .is_some_and(|area| area.read(cx).is_dock_open(placement));

                if !open {
                    dock.toggle(window, cx);
                }

                dock.resize_to(event.position, window, cx);
            }
        });

        window.on_mouse_event({
            let shared = self.shared.clone();
            move |_: &MouseUpEvent, phase, _, _| {
                if !phase.bubble() || shared.resizing.get() != Some(placement) {
                    return;
                }

                shared.resizing.set(None);
            }
        });
    }
}

struct DragPreview {
    panel: Arc<dyn gpui_base::dock::PanelView>,
}

impl Render for DragPreview {
    fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
        h_flex()
            .id("drag-panel")
            .cursor_grab()
            .p_2()
            .min_w_24()
            .justify_center()
            .overflow_hidden()
            .whitespace_nowrap()
            .rounded(px(button_radius()))
            .text_style(TextStyle::Callout)
            .text_color(cx.theme().text)
            .text_ellipsis()
            .when(cx.theme().shadow, |this| this.shadow_xs())
            .bg(cx.theme().bg)
            .child(panel_title(&self.panel, cx))
    }
}

struct TabGroupSkin {
    shared: Rc<SkinShared>,
    scroll_handle: ScrollHandle,
    last_active_ix: Cell<Option<usize>>,
}

impl TabGroupSkin {
    fn new(shared: Rc<SkinShared>) -> Self {
        Self {
            shared,
            scroll_handle: ScrollHandle::new(),
            last_active_ix: Cell::new(None),
        }
    }

    fn is_title_bar_group(&self, group: &TabGroupContext, cx: &App) -> bool {
        let Some(area) = self.shared.area() else {
            return false;
        };

        area.read(cx)
            .layout(DockPlacement::Center)
            .and_then(|tree| left_top_group(tree.root()))
            == Some(group.node())
    }

    /// Whether this group is the left dock's root with a single panel.
    fn is_plain_left_group(&self, group: &TabGroupContext, cx: &App) -> bool {
        let Some(area) = self.shared.area() else {
            return false;
        };
        let area = area.read(cx);

        area.layout(DockPlacement::Left)
            .map(|tree| tree.root().id())
            == Some(group.node())
            && group.panels().len() == 1
    }

    fn is_leftmost_top_group(&self, group: &TabGroupContext, cx: &App) -> bool {
        let Some(area) = self.shared.area() else {
            return false;
        };
        let area = area.read(cx);

        let left_open =
            area.is_dock_open(DockPlacement::Left) && !area.is_empty(DockPlacement::Left, cx);
        let tree = if left_open {
            area.layout(DockPlacement::Left)
        } else {
            area.layout(DockPlacement::Center)
        };

        tree.and_then(|tree| left_top_group(tree.root())) == Some(group.node())
    }

    fn render_tabs(
        &self,
        group: &TabGroupContext,
        visible: &[usize],
        window: &mut Window,
        cx: &mut App,
    ) -> AnyElement {
        let left_button = self.dock_toggle_button(DockPlacement::Left, group, cx);
        let bottom_button = self.dock_toggle_button(DockPlacement::Bottom, group, cx);
        let right_button = self.dock_toggle_button(DockPlacement::Right, group, cx);
        let has_leading = left_button.is_some() || bottom_button.is_some();

        let collapsed = group.is_collapsed();
        let droppable = group.is_droppable();
        let tabs_count = group.panels().len();
        let is_title_bar = self.is_title_bar_group(group, cx);

        let wallpaper = group
            .active_panel()
            .and_then(|panel| panel_background(panel, cx))
            .is_some();

        let displayed = group.active_panel().map(|panel| panel.panel_id(cx));
        let displayed_ix = displayed.and_then(|displayed| {
            group
                .panels()
                .iter()
                .position(|panel| panel.panel_id(cx) == displayed)
        });

        let needs_traffic_light_padding =
            cfg!(target_os = "macos") && self.is_leftmost_top_group(group, cx);

        let empty_space = div()
            .id("tab-bar-empty-space")
            .h_full()
            .flex_grow_1()
            .min_w_16()
            .when(droppable, |this| {
                this.drag_over::<DragPanel>(|this, _, _, cx| this.bg(cx.theme().drop_target))
                    .on_drop({
                        let group = TabGroupContext::clone(group);
                        move |drag: &DragPanel, window, cx| {
                            let ix = (drag.source() == group.node()).then(|| tabs_count - 1);
                            group.drop_panel(drag.clone(), ix, false, window, cx);
                        }
                    })
            });

        let empty_space = if is_title_bar {
            title_bar_drag_handlers(empty_space, window, cx).into_any_element()
        } else {
            empty_space.into_any_element()
        };

        let bar = TabBar::new("tab-bar")
            .track_scroll(&self.scroll_handle)
            .h(TABBAR_HEIGHT)
            .when(!wallpaper, |this| this.bg(cx.theme().bg))
            .when(needs_traffic_light_padding, |this| {
                this.pl(px(TRAFFIC_LIGHT_PADDING))
            })
            .when(is_title_bar || has_leading, |this| {
                this.prefix(
                    h_flex()
                        .size(TABBAR_HEIGHT)
                        .flex_shrink_0()
                        .justify_center()
                        .top_0()
                        .right(-px(1.))
                        .pl_0p5()
                        .pr_1()
                        .children(left_button)
                        .children(bottom_button),
                )
            })
            .children(visible.iter().map(|ix| {
                let ix = *ix;
                let panel = group.panels()[ix].clone();
                let drag = tab_drag(group, ix, cx);

                Tab::new()
                    .ix(ix)
                    .tab_bar_prefix(has_leading)
                    .child(panel_title(&panel, cx))
                    .selected(!collapsed && displayed_ix == Some(ix))
                    .disabled(collapsed)
                    .suffix(
                        Button::new("close")
                            .icon(IconName::Close)
                            .tooltip("Close panel")
                            .ghost()
                            .xsmall()
                            .on_click({
                                let group = TabGroupContext::clone(group);
                                let panel = panel.clone();
                                move |_, window, cx| {
                                    group.close(panel.panel_id(cx), window, cx);
                                }
                            }),
                    )
                    .on_click({
                        let group = TabGroupContext::clone(group);
                        move |_, window, cx| group.select_tab(ix, window, cx)
                    })
                    .when(!collapsed, |this| {
                        this.on_mouse_down(MouseButton::Middle, {
                            let group = TabGroupContext::clone(group);
                            let panel = panel.clone();
                            move |_, window, cx| {
                                group.close(panel.panel_id(cx), window, cx);
                            }
                        })
                        .when_some(drag, |this, drag| {
                            this.on_drag(drag, {
                                let panel = panel.clone();
                                move |drag, offset, _, cx| {
                                    cx.stop_propagation();
                                    drag.set_drag_offset(offset);
                                    cx.new(|_| DragPreview {
                                        panel: panel.clone(),
                                    })
                                }
                            })
                        })
                        .when(droppable, |this| {
                            this.drag_over::<DragPanel>(|this, _, _, cx| {
                                this.rounded_l_none()
                                    .border_l_2()
                                    .border_r_0()
                                    .border_color(cx.theme().drop_line)
                            })
                            .on_drop({
                                let group = TabGroupContext::clone(group);
                                move |drag: &DragPanel, window, cx| {
                                    group.drop_panel(drag.clone(), Some(ix), true, window, cx);
                                }
                            })
                        })
                    })
            }))
            .last_empty_space(empty_space)
            .when(!collapsed, |this| {
                this.suffix(
                    h_flex()
                        .flex_shrink_0()
                        .items_center()
                        .top_0()
                        .right_0()
                        .h_full()
                        .px_0p5()
                        .gap_1()
                        .children(right_button),
                )
            });

        if is_title_bar {
            h_flex()
                .h(TABBAR_HEIGHT)
                .w_full()
                .when(!wallpaper, |this| this.bg(cx.theme().bg))
                .child(bar.flex_1())
                .child(window_controls())
                .into_any_element()
        } else {
            bar.into_any_element()
        }
    }

    fn dock_toggle_button(
        &self,
        placement: DockPlacement,
        group: &TabGroupContext,
        cx: &mut App,
    ) -> Option<Button> {
        if group.is_zoomed() {
            return None;
        }

        let area = self.shared.area()?;
        let is_open = {
            let area = area.read(cx);

            if !area.is_dock_collapsible(placement) {
                return None;
            }

            let designated = match placement {
                DockPlacement::Left => area
                    .layout(DockPlacement::Center)
                    .and_then(|tree| left_top_group(tree.root())),
                DockPlacement::Right => area
                    .layout(DockPlacement::Center)
                    .and_then(|tree| right_top_group(tree.root())),
                DockPlacement::Bottom => area
                    .layout(DockPlacement::Bottom)
                    .and_then(|tree| left_top_group(tree.root())),
                DockPlacement::Center => None,
            };

            if designated != Some(group.node()) {
                return None;
            }

            area.is_dock_open(placement)
        };

        let icon = match (placement, is_open) {
            (DockPlacement::Left, true) => IconName::PanelLeft,
            (DockPlacement::Left, false) => IconName::PanelLeftOpen,
            (DockPlacement::Right, true) => IconName::PanelRight,
            (DockPlacement::Right, false) => IconName::PanelRightOpen,
            (DockPlacement::Bottom, true) => IconName::PanelBottom,
            (DockPlacement::Bottom, false) => IconName::PanelBottomOpen,
            (DockPlacement::Center, _) => return None,
        };

        Some(
            Button::new(SharedString::from(format!("toggle-dock:{:?}", placement)))
                .icon(icon)
                .small()
                .ghost()
                .tab_stop(false)
                .map(|this| {
                    if is_open {
                        this.tooltip("Collapse")
                    } else {
                        this.tooltip("Expand")
                    }
                })
                .on_click(move |_, window, cx| {
                    area.update(cx, |area, cx| area.toggle_dock(placement, window, cx));
                }),
        )
    }
}

impl TabGroupRenderer for TabGroupSkin {
    fn frame(&self, group: &TabGroupContext, _: &mut Window, cx: &mut App) -> Stateful<Div> {
        let wallpaper = group
            .active_panel()
            .and_then(|panel| panel_background(panel, cx));

        div()
            .id("tab-panel")
            .relative()
            .when_some(wallpaper, |this, source| this.child(background(source, cx)))
            .when(!group.is_collapsed(), |this| {
                this.on_action({
                    let group = TabGroupContext::clone(group);
                    move |_: &ToggleZoom, window, cx| group.toggle_zoom(window, cx)
                })
                .on_action({
                    let group = TabGroupContext::clone(group);
                    move |_: &ClosePanel, window, cx| {
                        let Some(panel) = group.active_panel() else {
                            return;
                        };
                        let panel = panel.panel_id(cx);
                        group.close(panel, window, cx);
                    }
                })
            })
    }

    fn render_tab_bar(
        &self,
        group: &TabGroupContext,
        window: &mut Window,
        cx: &mut App,
    ) -> AnyElement {
        // The plain left group draws bare so its content can own the window's top-left corner.
        if self.is_plain_left_group(group, cx) {
            return Empty.into_any_element();
        }

        let visible: Vec<usize> = group
            .panels()
            .iter()
            .enumerate()
            .filter(|(_, panel)| panel.visible(cx))
            .map(|(ix, _)| ix)
            .collect();

        let active_ix = group.active_ix();
        if self.last_active_ix.replace(Some(active_ix)) != Some(active_ix)
            && let Some(visible_ix) = visible.iter().position(|ix| *ix == active_ix)
        {
            self.scroll_handle.scroll_to_item(visible_ix);
        }

        if visible.is_empty() {
            return Empty.into_any_element();
        }

        self.render_tabs(group, visible.as_slice(), window, cx)
    }

    fn render_active_panel(
        &self,
        panel: AnyView,
        group: &TabGroupContext,
        _: &mut Window,
        cx: &mut App,
    ) -> AnyElement {
        if group.is_collapsed() {
            return Empty.into_any_element();
        }

        let wallpaper = group
            .active_panel()
            .and_then(|active| panel_background(active, cx))
            .is_some();

        v_flex()
            .id("tab-content")
            .group("")
            .overflow_hidden()
            .flex_1()
            .child(
                div()
                    .size_full()
                    .when(!wallpaper, |this| this.bg(cx.theme().bg))
                    .overflow_hidden()
                    .child(panel.cached(StyleRefinement::default().v_flex().size_full())),
            )
            .into_any_element()
    }

    fn render_drop_indicator(
        &self,
        indicator: DropIndicator,
        _: &mut Window,
        cx: &mut App,
    ) -> Option<AnyElement> {
        let size = indicator.bounds().size;
        let fraction = 0.35;

        let (left, top, width, height) = match indicator.placement() {
            Some(Placement::Left) => (px(0.), px(0.), size.width * fraction, size.height),
            Some(Placement::Right) => (
                size.width * (1. - fraction),
                px(0.),
                size.width * fraction,
                size.height,
            ),
            Some(Placement::Top) => (px(0.), px(0.), size.width, size.height * fraction),
            Some(Placement::Bottom) => (
                px(0.),
                size.height * (1. - fraction),
                size.width,
                size.height * fraction,
            ),
            None => (px(0.), px(0.), size.width, size.height),
        };

        Some(
            div()
                .absolute()
                .left(left)
                .top(top)
                .w(width)
                .h(height)
                .rounded(px(panel_radius()))
                .border_1()
                .border_color(cx.theme().drop_line)
                .bg(cx.theme().drop_target)
                .into_any_element(),
        )
    }
}

fn tab_drag(group: &TabGroupContext, ix: usize, cx: &App) -> Option<DragPanel> {
    group
        .is_draggable()
        .then(|| group.drag_panel(ix, cx))
        .flatten()
}

fn panel_title(panel: &Arc<dyn gpui_base::dock::PanelView>, cx: &App) -> AnyElement {
    match PanelHandle::of(panel) {
        Some(handle) => handle.panel().title(cx),
        None => SharedString::from(panel.panel_name(cx)).into_any_element(),
    }
}

fn panel_background(panel: &Arc<dyn gpui_base::dock::PanelView>, cx: &App) -> Option<ImageSource> {
    PanelHandle::of(panel).and_then(|handle| handle.panel().background(cx))
}