use gpui::ElementId;
use ui::{
    ContextMenu, GradientFade, IconButton, IconName, IconSize, PopoverMenu, Tooltip, prelude::*,
};

use crate::{
    CsvPreviewView,
    settings::FilterSortOrder,
    table_data_engine::{
        filtering_by_column::{FilterEntry, FilterEntryState},
        sorting_by_column::{AppliedSorting, SortDirection},
    },
    types::AnyColumn,
};

impl CsvPreviewView {
    /// Create header for data, which is orderable with text on the left and sort button on the right
    pub(crate) fn create_header_element_with_sort_button(
        &self,
        header_text: SharedString,
        cx: &mut Context<'_, CsvPreviewView>,
        col_idx: AnyColumn,
    ) -> AnyElement {
        let has_active_filter = self.engine.has_active_filters(col_idx);
        let has_active_sort = self
            .engine
            .applied_sorting
            .is_some_and(|o| o.col_idx == col_idx);
        let always_show_buttons = has_active_filter || has_active_sort;
        let group_name = SharedString::from(format!("csv-col-header-{}", col_idx.get()));

        let colors = cx.theme().colors();
        let base_bg = colors.editor_background;
        let grad_width_hovered = px(100.);
        let grad_width = if always_show_buttons {
            grad_width_hovered
        } else {
            px(20.)
        };
        h_flex()
            .group(group_name.clone())
            .relative()
            .overflow_hidden()
            .w_full()
            .items_center()
            .font_buffer(cx)
            .text_buffer(cx)
            .child(
                div()
                    .flex_1()
                    .min_w_0()
                    .overflow_hidden()
                    .whitespace_nowrap()
                    .child(header_text),
            )
            .child(
                GradientFade::new(base_bg, base_bg, base_bg)
                    .width(grad_width)
                    .width_hovered(grad_width_hovered)
                    .right(px(0.))
                    .gradient_stop(0.8)
                    .group_name(group_name.clone()),
            )
            .child(
                h_flex()
                    .absolute()
                    .right_0()
                    .top_0()
                    .h_full()
                    .items_center()
                    .gap_1()
                    .when(!always_show_buttons, |this| {
                        this.visible_on_hover(group_name)
                    })
                    .child(self.create_filter_button(cx, col_idx))
                    .child(self.create_sort_button(cx, col_idx)),
            )
            .into_any_element()
    }

    fn create_sort_button(
        &self,
        cx: &mut Context<'_, CsvPreviewView>,
        col_idx: AnyColumn,
    ) -> Button {
        let sort_btn = Button::new(
            ElementId::NamedInteger("sort-button".into(), col_idx.get() as u64),
            match self.engine.applied_sorting {
                Some(ordering) if ordering.col_idx == col_idx => match ordering.direction {
                    SortDirection::Asc => "↓",
                    SortDirection::Desc => "↑",
                },
                _ => "↕", // Unsorted/available for sorting
            },
        )
        .size(ButtonSize::Compact)
        .style(
            if self
                .engine
                .applied_sorting
                .is_some_and(|o| o.col_idx == col_idx)
            {
                ButtonStyle::Filled
            } else {
                ButtonStyle::Subtle
            },
        )
        .tooltip(Tooltip::text(match self.engine.applied_sorting {
            Some(ordering) if ordering.col_idx == col_idx => match ordering.direction {
                SortDirection::Asc => "Sorted A-Z. Click to sort Z-A",
                SortDirection::Desc => "Sorted Z-A. Click to disable sorting",
            },
            _ => "Not sorted. Click to sort A-Z",
        }))
        .on_click(cx.listener(move |this, _event, _window, cx| {
            let new_sorting = match this.engine.applied_sorting {
                Some(ordering) if ordering.col_idx == col_idx => {
                    // Same column clicked - cycle through states
                    match ordering.direction {
                        SortDirection::Asc => Some(AppliedSorting {
                            col_idx,
                            direction: SortDirection::Desc,
                        }),
                        SortDirection::Desc => None, // Clear sorting
                    }
                }
                _ => {
                    // Different column or no sorting - start with ascending
                    Some(AppliedSorting {
                        col_idx,
                        direction: SortDirection::Asc,
                    })
                }
            };

            this.engine.applied_sorting = new_sorting;
            this.apply_sort(cx);
            cx.notify();
        }));
        sort_btn
    }

    fn create_filter_button(
        &self,
        cx: &mut Context<'_, CsvPreviewView>,
        col: AnyColumn,
    ) -> PopoverMenu<ContextMenu> {
        let has_active_filters = self.engine.has_active_filters(col);

        PopoverMenu::new(ElementId::NamedInteger(
            "filter-menu".into(),
            col.get() as u64,
        ))
        .trigger_with_tooltip(
            IconButton::new(
                ElementId::NamedInteger("filter-button".into(), col.get() as u64),
                IconName::Filter,
            )
            .icon_size(IconSize::Small)
            .style(if has_active_filters {
                ButtonStyle::Filled
            } else {
                ButtonStyle::Subtle
            })
            .toggle_state(has_active_filters),
            Tooltip::text(if has_active_filters {
                "Column has active filters. Click to manage"
            } else {
                "No filters applied. Click to add filters"
            }),
        )
        .menu({
            let view_entity = cx.entity();
            move |window, cx| {
                let view = view_entity.read(cx);
                let column_filters = match view.engine.get_filters_for_column(col) {
                    Ok(filters) => filters,
                    Err(err) => {
                        log::error!("Failed to get filters for column: {err}");
                        return None;
                    }
                };
                let filter_sort_order = view.settings.filter_sort_order;
                let filter_menu = Self::create_filter_menu(
                    window,
                    cx,
                    view_entity.clone(),
                    col,
                    &column_filters,
                    has_active_filters,
                    filter_sort_order,
                );
                Some(filter_menu)
            }
        })
    }

    fn create_filter_menu(
        window: &mut ui::Window,
        cx: &mut ui::App,
        view_entity: gpui::Entity<CsvPreviewView>,
        col: AnyColumn,
        column_filters: &[(FilterEntry, FilterEntryState)],
        has_active_filters: bool,
        sort_order: FilterSortOrder,
    ) -> gpui::Entity<ContextMenu> {
        let mut available: Vec<&FilterEntry> = column_filters
            .iter()
            .filter_map(|(entry, state)| {
                matches!(state, FilterEntryState::Available { .. }).then_some(entry)
            })
            .collect();

        match sort_order {
            FilterSortOrder::AlphaThenCount => available.sort_by(|a, b| {
                a.content
                    .cmp(&b.content)
                    .then_with(|| b.occurred_times().cmp(&a.occurred_times()))
            }),
            FilterSortOrder::CountThenAlpha => available.sort_by(|a, b| {
                b.occurred_times()
                    .cmp(&a.occurred_times())
                    .then_with(|| a.content.cmp(&b.content))
            }),
        }

        let unavailable: Vec<(&FilterEntry, AnyColumn)> = column_filters
            .iter()
            .filter_map(|(entry, state)| {
                if let FilterEntryState::Unavailable { blocked_by } = state {
                    Some((entry, *blocked_by))
                } else {
                    None
                }
            })
            .collect();

        // Pre-build applied-state lookup before moving into the closure
        let applied_states: Vec<(FilterEntry, bool)> = column_filters
            .iter()
            .filter_map(|(entry, state)| {
                if let FilterEntryState::Available { is_applied } = state {
                    Some((entry.clone(), *is_applied))
                } else {
                    None
                }
            })
            .collect();

        let available_cloned: Vec<FilterEntry> = available.iter().map(|e| (*e).clone()).collect();
        let unavailable_cloned: Vec<(FilterEntry, AnyColumn)> = unavailable
            .into_iter()
            .map(|(e, col)| (e.clone(), col))
            .collect();

        ContextMenu::build(window, cx, move |menu, _, _| {
            let mut menu = menu;

            if has_active_filters {
                menu = menu
                    .toggleable_entry("Clear all", false, ui::IconPosition::Start, None, {
                        let view_entity = view_entity.clone();
                        move |_window, cx| {
                            view_entity.update(cx, |view, cx| {
                                view.clear_filters(col, cx);
                                cx.notify();
                            });
                        }
                    })
                    .separator();
            }

            for entry in &available_cloned {
                let is_applied = applied_states
                    .iter()
                    .find(|(e, _)| e.content == entry.content)
                    .map_or(false, |(_, applied)| *applied);

                let label: SharedString =
                    format_filter_label(entry.content.as_ref(), entry.occurred_times()).into();
                let entry_value = entry.content.clone();

                menu = menu.toggleable_entry(&label, is_applied, ui::IconPosition::Start, None, {
                    let view_entity = view_entity.clone();
                    move |_window, cx| {
                        view_entity.update(cx, |view, cx| {
                            view.toggle_filter(col, entry_value.clone(), cx);
                            cx.notify();
                        });
                    }
                });
            }

            if !unavailable_cloned.is_empty() {
                menu = menu.separator().header("Hidden by other filters");
                for (entry, _blocked_by) in &unavailable_cloned {
                    let label: SharedString =
                        format_filter_label(entry.content.as_ref(), entry.occurred_times()).into();
                    menu = menu.custom_entry(
                        {
                            let label = label.clone();
                            move |_window, cx| {
                                div()
                                    .px_2()
                                    .text_color(cx.theme().colors().text_muted)
                                    .child(label.clone())
                                    .into_any_element()
                            }
                        },
                        |_, _| {},
                    );
                }
            }

            menu
        })
    }
}

fn format_filter_label(content: Option<&SharedString>, count: usize) -> String {
    match content {
        Some(s) => format!("{s} ({count})"),
        None => format!("<null> ({count})"),
    }
}