use std::{cell::Cell, rc::Rc};

use crate::{
    h_flex,
    scroll::{ScrollableAxis, ScrollableMask, Scrollbar, ScrollbarState},
    theme::{ActiveTheme, Colorize},
    v_flex,
};
use gpui::{
    actions, div, prelude::FluentBuilder as _, px, uniform_list, AppContext, Div, FocusHandle,
    FocusableView, InteractiveElement as _, IntoElement, KeyBinding, MouseButton,
    ParentElement as _, Render, ScrollHandle, SharedString, StatefulInteractiveElement as _,
    Styled, UniformListScrollHandle, ViewContext, WindowContext,
};

actions!(
    table,
    [
        Cancel,
        SelectPrev,
        SelectNext,
        SelectPrevColumn,
        SelectNextColumn
    ]
);

pub fn init(cx: &mut AppContext) {
    let context = Some("Table");
    cx.bind_keys([
        KeyBinding::new("escape", Cancel, context),
        KeyBinding::new("up", SelectPrev, context),
        KeyBinding::new("down", SelectNext, context),
        KeyBinding::new("left", SelectPrevColumn, context),
        KeyBinding::new("right", SelectNextColumn, context),
    ]);
}

struct ColGroup {
    width: Option<f32>,
}

#[derive(Copy, Clone, Debug, PartialEq, Eq)]
enum SelectionState {
    Column,
    Row,
}

pub struct Table<D: TableDelegate> {
    focus_handle: FocusHandle,
    delegate: D,
    horizontal_scroll_handle: ScrollHandle,
    vertical_scroll_handle: UniformListScrollHandle,
    col_groups: Vec<ColGroup>,

    scrollbar_state: Rc<Cell<ScrollbarState>>,

    selection_state: SelectionState,
    selected_row: Option<usize>,
    selected_col: Option<usize>,
}

#[allow(unused)]
pub trait TableDelegate: Sized + 'static {
    /// Return the number of columns in the table.
    fn cols_count(&self) -> usize;
    /// Return the number of rows in the table.
    fn rows_count(&self) -> usize;

    /// Returns the name of the column at the given index.
    fn column_name(&self, col_ix: usize) -> SharedString;

    /// Returns whether the column at the given index can be resized. Default: true
    fn can_resize_col(&self, col_ix: usize) -> bool {
        true
    }

    /// Returns the width of the column at the given index.
    /// Return None, use auto width.
    fn col_width(&self, col_ix: usize) -> Option<f32>;

    /// Set the width of the column at the given index.
    fn on_col_width_changed(&mut self, col_ix: usize, width: Option<f32>) {}

    /// Render the header cell at the given column index, default to the column name.
    fn render_th(&self, col_ix: usize) -> impl IntoElement {
        div().size_full().child(self.column_name(col_ix))
    }

    /// Render cell at the given row and column.
    fn render_td(&self, row_ix: usize, col_ix: usize) -> impl IntoElement;

    /// Return true to enable loop selection on the table.
    ///
    /// When the prev/next selection is out of the table bounds, the selection will loop to the other side.
    ///
    /// Default: true
    fn can_loop_select(&self) -> bool {
        true
    }
}

impl<D> Table<D>
where
    D: TableDelegate,
{
    pub fn new(delegate: D, cx: &mut ViewContext<Self>) -> Self {
        let mut this = Self {
            focus_handle: cx.focus_handle(),
            delegate,
            col_groups: Vec::new(),
            horizontal_scroll_handle: ScrollHandle::new(),
            vertical_scroll_handle: UniformListScrollHandle::new(),
            scrollbar_state: Rc::new(Cell::new(ScrollbarState::new())),
            selection_state: SelectionState::Row,
            selected_row: None,
            selected_col: None,
        };

        this.update_col_groups(cx);
        this
    }

    pub fn delegate(&self) -> &D {
        &self.delegate
    }

    pub fn delegate_mut(&mut self) -> &mut D {
        &mut self.delegate
    }

    fn update_col_groups(&mut self, cx: &mut ViewContext<Self>) {
        self.col_groups = (0..self.delegate.cols_count())
            .map(|col_ix| ColGroup {
                width: self.delegate.col_width(col_ix),
            })
            .collect();
        cx.notify();
    }

    fn scroll_to_selected_row(&mut self, _cx: &mut ViewContext<Self>) {
        if let Some(row_ix) = self.selected_row {
            self.vertical_scroll_handle.scroll_to_item(row_ix);
        }
    }

    fn scroll_to_selected_column(&mut self, cx: &mut ViewContext<Self>) {
        if let Some(col_ix) = self.selected_col {
            self.horizontal_scroll_handle.scroll_to_item(col_ix);
            cx.notify();
        }
    }

    fn on_row_click(&mut self, row_ix: usize, cx: &mut ViewContext<Self>) {
        self.selection_state = SelectionState::Row;
        self.selected_row = Some(row_ix);
        self.scroll_to_selected_row(cx);
    }

    fn on_col_head_click(&mut self, col_ix: usize, cx: &mut ViewContext<Self>) {
        self.selection_state = SelectionState::Column;
        self.selected_col = Some(col_ix);
        self.scroll_to_selected_column(cx);
    }

    fn action_cancel(&mut self, _: &Cancel, cx: &mut ViewContext<Self>) {
        self.selection_state = SelectionState::Row;
        self.selected_row = None;
        self.selected_col = None;
        cx.notify();
    }

    fn action_select_prev(&mut self, _: &SelectPrev, cx: &mut ViewContext<Self>) {
        let selected_row = self.selected_row.unwrap_or(0);
        let rows_count = self.delegate.rows_count();
        if selected_row > 0 {
            self.selected_row = Some(selected_row - 1);
        } else {
            if self.delegate.can_loop_select() {
                self.selected_row = Some(rows_count - 1);
            }
        }

        self.selection_state = SelectionState::Row;
        self.scroll_to_selected_row(cx);
        cx.notify();
    }

    fn action_select_next(&mut self, _: &SelectNext, cx: &mut ViewContext<Self>) {
        let selected_row = self.selected_row.unwrap_or(0);
        if selected_row < self.delegate.rows_count() - 1 {
            self.selected_row = Some(selected_row + 1);
        } else {
            if self.delegate.can_loop_select() {
                self.selected_row = Some(0);
            }
        }

        self.selection_state = SelectionState::Row;
        self.scroll_to_selected_row(cx);
        cx.notify();
    }

    fn action_select_prev_column(&mut self, _: &SelectPrevColumn, cx: &mut ViewContext<Self>) {
        let selected_col = self.selected_col.unwrap_or(0);
        let cols_count = self.delegate.cols_count();
        if selected_col > 0 {
            self.selected_col = Some(selected_col - 1);
        } else {
            if self.delegate.can_loop_select() {
                self.selected_col = Some(cols_count - 1);
            }
        }

        self.selection_state = SelectionState::Column;
        self.scroll_to_selected_column(cx);
        cx.notify();
    }

    fn action_select_next_column(&mut self, _: &SelectNextColumn, cx: &mut ViewContext<Self>) {
        let selected_col = self.selected_col.unwrap_or(0);
        if selected_col < self.delegate.cols_count() - 1 {
            self.selected_col = Some(selected_col + 1);
        } else {
            if self.delegate.can_loop_select() {
                self.selected_col = Some(0);
            }
        }

        self.selection_state = SelectionState::Column;
        self.scroll_to_selected_column(cx);
        cx.notify();
    }

    fn render_cell(&self, col_ix: usize, _cx: &mut ViewContext<Self>) -> Div {
        let col_width = self.col_groups[col_ix].width;

        div()
            .when_some(col_width, |this, width| this.w(px(width)))
            .overflow_hidden()
            .whitespace_nowrap()
            .py_1()
            .px_2()
    }

    /// Show Column selection style, when the column is selected and the selection state is Column.
    fn col_wrap(&self, col_ix: usize, cx: &mut ViewContext<Self>) -> Div {
        if self.selected_col == Some(col_ix) && self.selection_state == SelectionState::Column {
            div().bg(cx.theme().accent.opacity(0.5))
        } else {
            div()
        }
    }

    fn render_scrollbar(&self, cx: &mut ViewContext<Self>) -> Option<impl IntoElement> {
        let view = cx.view().clone();
        let state = self.scrollbar_state.clone();

        Some(
            div()
                .absolute()
                .top_0()
                .left_0()
                .right_0()
                .bottom_0()
                .child(Scrollbar::uniform_scroll(
                    view,
                    state,
                    self.vertical_scroll_handle.clone(),
                    self.delegate.rows_count(),
                )),
        )
    }
}

impl<D> FocusableView for Table<D>
where
    D: TableDelegate,
{
    fn focus_handle(&self, _cx: &gpui::AppContext) -> FocusHandle {
        self.focus_handle.clone()
    }
}

impl<D> Render for Table<D>
where
    D: TableDelegate,
{
    fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
        let view = cx.view().clone();
        let vertical_scroll_handle = self.vertical_scroll_handle.clone();
        let horizontal_scroll_handle = self.horizontal_scroll_handle.clone();
        let cols_count: usize = self.delegate.cols_count();
        let rows_count = self.delegate.rows_count();
        let selected_bg = cx.theme().accent.opacity(0.8);
        let hover_bg = cx.theme().accent.opacity(0.5);

        fn tr(cx: &mut WindowContext) -> Div {
            h_flex().gap_1().border_color(cx.theme().border)
        }

        let inner_table = v_flex()
            .key_context("Table")
            .id("table")
            .track_focus(&self.focus_handle)
            .on_action(cx.listener(Self::action_cancel))
            .on_action(cx.listener(Self::action_select_next))
            .on_action(cx.listener(Self::action_select_prev))
            .on_action(cx.listener(Self::action_select_next_column))
            .on_action(cx.listener(Self::action_select_prev_column))
            .size_full()
            .overflow_hidden()
            .child(
                v_flex()
                    .flex_grow()
                    .h_10()
                    .w_full()
                    .shadow_sm()
                    .border_b_1()
                    .border_color(cx.theme().border)
                    .child(
                        uniform_list(view.clone(), "table-uniform-list-head", 1, {
                            let horizontal_scroll_handle = horizontal_scroll_handle.clone();
                            move |table, _, cx| {
                                // Columns
                                vec![tr(cx)
                                    .id("table-head")
                                    .w_full()
                                    .overflow_scroll()
                                    .track_scroll(&horizontal_scroll_handle)
                                    // The children must be one by one items.
                                    // Becuase the horizontal scroll handle will use the child_item_bounds to
                                    // calculate the item position for itself's `scroll_to_item` method.
                                    .children(table.col_groups.iter().enumerate().map(
                                        |(col_ix, _)| {
                                            table.col_wrap(col_ix, cx).child(
                                                table
                                                    .render_cell(col_ix, cx)
                                                    .on_mouse_down(
                                                        MouseButton::Left,
                                                        cx.listener(move |this, _, cx| {
                                                            this.on_col_head_click(col_ix, cx);
                                                        }),
                                                    )
                                                    .child(table.delegate.render_th(col_ix)),
                                            )
                                        },
                                    ))
                                    .flex_1()]
                            }
                        })
                        .size_full(),
                    ),
            )
            .child(
                h_flex().id("table-body").flex_grow().size_full().child(
                    uniform_list(view, "table-uniform-list", rows_count, {
                        let horizontal_scroll_handle = horizontal_scroll_handle.clone();
                        move |table, visible_range, cx| {
                            visible_range
                                .map(|row_ix| {
                                    tr(cx)
                                        .id(("table-row", row_ix))
                                        .w_full()
                                        .children((0..cols_count).map(|col_ix| {
                                            table
                                                .col_wrap(col_ix, cx) // Make the row scroll sync with the horizontal_scroll_handle to support horizontal scrolling.
                                                .left(horizontal_scroll_handle.offset().x)
                                                .child(
                                                    table
                                                        .render_cell(col_ix, cx)
                                                        .flex_shrink_0()
                                                        .child(
                                                            table
                                                                .delegate
                                                                .render_td(row_ix, col_ix),
                                                        ),
                                                )
                                        }))
                                        .when(row_ix > 0, |this| this.border_t_1())
                                        .hover(|this| {
                                            if table.selected_row.is_some() {
                                                this
                                            } else {
                                                this.bg(hover_bg)
                                            }
                                        })
                                        // Row selected style
                                        .when_some(table.selected_row, |this, selected_row| {
                                            this.when(
                                                row_ix == selected_row
                                                    && table.selection_state == SelectionState::Row,
                                                |this| this.bg(selected_bg),
                                            )
                                        })
                                        .on_mouse_down(
                                            MouseButton::Left,
                                            cx.listener(move |this, _, cx| {
                                                this.on_row_click(row_ix, cx);
                                            }),
                                        )
                                })
                                .collect::<Vec<_>>()
                        }
                    })
                    .flex_grow()
                    .size_full()
                    .with_sizing_behavior(gpui::ListSizingBehavior::Auto)
                    .track_scroll(vertical_scroll_handle)
                    .into_any_element(),
                ),
            );

        div()
            .size_full()
            .rounded_md()
            .border_1()
            .border_color(cx.theme().border)
            .bg(cx.theme().card)
            .child(inner_table)
            .children(self.render_scrollbar(cx))
            .child(ScrollableMask::new(
                cx.view().clone(),
                ScrollableAxis::Horizontal,
                &horizontal_scroll_handle,
            ))
    }
}