use std::time::Duration;

use anyhow::Result;
use gpui::{
    actions, div, list, prelude::FluentBuilder as _, px, rems, uniform_list, AppContext,
    ClickEvent, DismissEvent, Div, EventEmitter, FocusHandle, FocusableView, InteractiveElement,
    IntoElement, KeyBinding, Length, ListSizingBehavior, ListState, MouseButton, MouseUpEvent,
    ParentElement as _, Render, SharedString, StatefulInteractiveElement as _, Styled as _, Task,
    UniformListScrollHandle, View, ViewContext, VisualContext as _, WindowContext,
};

actions!(
    picker,
    [
        UseSelectedQuery,
        Cancel,
        Confirm,
        SecondaryConfirm,
        SelectPrev,
        SelectNext,
        SelectFirst,
        SelectLast,
    ]
);

pub fn init(cx: &mut AppContext) {
    let context = Some("Picker");
    cx.bind_keys([
        KeyBinding::new("enter", Confirm, context),
        KeyBinding::new("escape", Cancel, context),
        KeyBinding::new("up", SelectPrev, context),
        KeyBinding::new("down", SelectNext, context),
    ]);
}

use crate::{
    divider::Divider,
    empty::Empty,
    input::{TextEvent, TextInput},
    stock::*,
    theme::ActiveTheme,
    StyledExt as _,
};

enum ElementContainer {
    List(ListState),
    UniformList(UniformListScrollHandle),
}

#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
enum ContainerKind {
    List,
    UniformList,
}

pub trait PickerDelegate: Sized + 'static {
    type ListItem: IntoElement;

    fn match_count(&self) -> usize;
    fn selected_index(&self) -> usize;
    fn set_selected_index(&mut self, index: usize, cx: &mut ViewContext<Picker<Self>>);
    fn selected_index_changed(
        &self,
        _ix: usize,
        _cx: &mut ViewContext<Picker<Self>>,
    ) -> Option<Box<dyn Fn(&mut WindowContext) + 'static>> {
        None
    }

    fn confirm(&mut self, secondary: bool, cx: &mut ViewContext<Picker<Self>>) {}
    fn dismissed(&mut self, cx: &mut ViewContext<Picker<Self>>) {}
    fn should_dismiss(&self) -> bool {
        true
    }
    fn render_query(&self, input: &View<TextInput>, _cx: &mut ViewContext<Picker<Self>>) -> Div {
        v_flex()
            .child(
                h_flex()
                    .overflow_hidden()
                    .flex_none()
                    .h_9()
                    .px_4()
                    .child(input.clone()),
            )
            .child(Divider::horizontal())
    }
    fn render_match(
        &self,
        ix: usize,
        selected: bool,
        cx: &mut ViewContext<Picker<Self>>,
    ) -> Option<Self::ListItem>;

    fn separators_after_indices(&self) -> Vec<usize> {
        Vec::new()
    }
    fn update_matches(&mut self, query: &str, cx: &mut ViewContext<Picker<Self>>) -> Task<()> {
        Task::ready(())
    }
    fn confirm_update_query(&mut self, _cx: &mut ViewContext<Picker<Self>>) -> Option<String> {
        None
    }
    fn finalize_update_matches(
        &mut self,
        _query: SharedString,
        _duration: Duration,
        _cx: &mut ViewContext<Picker<Self>>,
    ) -> bool {
        false
    }
    fn selected_as_query(&self) -> Option<String> {
        None
    }
}

impl<D: PickerDelegate> FocusableView for Picker<D> {
    fn focus_handle(&self, cx: &AppContext) -> FocusHandle {
        if let Some(input) = &self.query_input {
            input.focus_handle(cx)
        } else {
            self.head.focus_handle(cx)
        }
    }
}

impl<D: PickerDelegate> EventEmitter<DismissEvent> for Picker<D> {}

struct PendingUpdateMatches {
    delegate_update_matches: Option<Task<()>>,
    _task: Task<Result<()>>,
}

pub struct Picker<D: PickerDelegate> {
    delegate: D,
    element_container: ElementContainer,
    query_input: Option<View<TextInput>>,
    width: Option<Length>,
    max_height: Option<Length>,
    is_modal: bool,
    head: View<Empty>,
    pending_update_matches: Option<PendingUpdateMatches>,
    confirm_on_update: Option<bool>,
}

impl<D: PickerDelegate> Picker<D> {
    fn new(
        delegate: D,
        kind: ContainerKind,
        query_input: Option<View<TextInput>>,
        cx: &mut ViewContext<Self>,
    ) -> Self {
        let element_container = match kind {
            ContainerKind::List => {
                let view = cx.view().downgrade();
                ElementContainer::List(ListState::new(
                    0,
                    gpui::ListAlignment::Top,
                    px(1000.),
                    move |ix, cx| {
                        view.upgrade()
                            .map(|view| {
                                view.update(cx, |this, cx| {
                                    this.render_element(cx, ix).into_any_element()
                                })
                            })
                            .unwrap_or_else(|| div().into_any_element())
                    },
                ))
            }
            ContainerKind::UniformList => {
                ElementContainer::UniformList(UniformListScrollHandle::new())
            }
        };

        Self {
            delegate,
            query_input,
            head: cx.new_view(Empty::new),
            width: None,
            is_modal: false,
            max_height: Some(rems(20.).into()),
            element_container,
            pending_update_matches: None,
            confirm_on_update: None,
        }
    }

    fn new_query_input(
        placehoder: impl Into<SharedString>,
        cx: &mut ViewContext<Self>,
    ) -> View<TextInput> {
        let input = cx.new_view(|cx| {
            let mut input = TextInput::new(cx).appearance(false);
            input.set_placeholder(placehoder, cx);
            input
        });
        cx.subscribe(&input, Self::on_query_input_event).detach();
        input
    }

    pub fn list(delegate: D, cx: &mut ViewContext<Self>) -> Self {
        let query_input = Self::new_query_input("Search...", cx);
        Self::new(delegate, ContainerKind::List, Some(query_input), cx)
    }

    pub fn uniform_list(delegate: D, cx: &mut ViewContext<Self>) -> Self {
        let query_input = Self::new_query_input("Search...", cx);
        Self::new(delegate, ContainerKind::UniformList, Some(query_input), cx)
    }

    pub fn width(mut self, width: impl Into<gpui::Length>) -> Self {
        self.width = Some(width.into());
        self
    }

    pub fn max_height(mut self, max_height: Option<gpui::Length>) -> Self {
        self.max_height = max_height;
        self
    }

    pub fn modal(mut self, modal: bool) -> Self {
        self.is_modal = modal;
        self
    }

    pub fn focus(&self, cx: &mut WindowContext) {
        self.focus_handle(cx).focus(cx);
    }

    pub fn set_query(&mut self, query: &str, cx: &mut ViewContext<Self>) {
        if let Some(input) = &self.query_input {
            input.update(cx, |this, cx| this.set_text(query.to_string(), cx));
        }
    }

    /// Return the query input string.
    pub fn query(&self, cx: &AppContext) -> SharedString {
        if let Some(input) = &self.query_input {
            input.read(cx).text()
        } else {
            "".into()
        }
    }

    fn render_element_container(&self, cx: &mut ViewContext<Self>) -> impl IntoElement {
        let sizing_behavior = if self.max_height.is_some() {
            ListSizingBehavior::Infer
        } else {
            ListSizingBehavior::Auto
        };

        match &self.element_container {
            ElementContainer::UniformList(scroll_handle) => uniform_list(
                cx.view().clone(),
                "candidates",
                self.delegate.match_count(),
                move |picker, visible_range, cx| {
                    visible_range
                        .map(|ix| picker.render_element(cx, ix))
                        .collect()
                },
            )
            .with_sizing_behavior(sizing_behavior)
            .flex_grow()
            .track_scroll(scroll_handle.clone())
            .into_any_element(),
            ElementContainer::List(state) => list(state.clone())
                .with_sizing_behavior(sizing_behavior)
                .flex_grow()
                .into_any_element(),
        }
    }

    fn render_element(&self, cx: &mut ViewContext<Self>, ix: usize) -> impl IntoElement {
        div()
            .id(("item", ix))
            .cursor_pointer()
            .on_click(cx.listener(move |this, event: &ClickEvent, cx| {
                this.on_click(ix, event.down.modifiers.secondary(), cx)
            }))
            // As of this writing, GPUI intercepts `ctrl-[mouse-event]`s on macOS
            // and produces right mouse button events. This matches platforms norms
            // but means that UIs which depend on holding ctrl down (such as the tab
            // switcher) can't be clicked on. Hence, this handler.
            .on_mouse_up(
                MouseButton::Right,
                cx.listener(move |this, event: &MouseUpEvent, cx| {
                    // We specficially want to use the platform key here, as
                    // ctrl will already be held down for the tab switcher.
                    this.on_click(ix, event.modifiers.platform, cx)
                }),
            )
            .children(
                self.delegate
                    .render_match(ix, ix == self.delegate.selected_index(), cx),
            )
            .when(
                self.delegate.separators_after_indices().contains(&ix),
                |picker| {
                    picker
                        .border_color(cx.theme().border)
                        .border_b_1()
                        .pb(px(-1.0))
                },
            )
    }

    fn on_click(&mut self, ix: usize, secondary: bool, cx: &mut ViewContext<Self>) {
        cx.stop_propagation();
        cx.prevent_default();
        self.set_selected_index(ix, false, cx);
        self.do_confirm(secondary, cx)
    }

    fn do_confirm(&mut self, secondary: bool, cx: &mut ViewContext<Self>) {
        // if let Some(update_query) = self.delegate.confirm_update_query(cx) {
        //     self.set_query(update_query, cx);
        //     self.delegate.set_selected_index(0, cx);
        // } else {
        self.delegate.confirm(secondary, cx)
        // }
    }

    pub fn set_selected_index(
        &mut self,
        ix: usize,
        scroll_to_index: bool,
        cx: &mut ViewContext<Self>,
    ) {
        let previous_index = self.delegate.selected_index();
        self.delegate.set_selected_index(ix, cx);
        let current_index = self.delegate.selected_index();

        if previous_index != current_index {
            if let Some(action) = self.delegate.selected_index_changed(ix, cx) {
                action(cx);
            }
            if scroll_to_index {
                self.scroll_to_item_index(ix);
            }
        }
    }

    fn scroll_to_item_index(&mut self, ix: usize) {
        match &mut self.element_container {
            ElementContainer::List(state) => state.scroll_to_reveal_item(ix),
            ElementContainer::UniformList(scroll_handle) => scroll_handle.scroll_to_item(ix),
        }
    }

    fn confirm(&mut self, _: &Confirm, cx: &mut ViewContext<Self>) {
        if self.pending_update_matches.is_some()
            && !self
                .delegate
                .finalize_update_matches(self.query(cx), Duration::from_millis(16), cx)
        {
            self.confirm_on_update = Some(false)
        } else {
            self.pending_update_matches.take();
            self.do_confirm(false, cx);
        }
    }

    pub fn select_next(&mut self, _: &SelectNext, cx: &mut ViewContext<Self>) {
        let count = self.delegate.match_count();
        if count > 0 {
            let index = self.delegate.selected_index();
            let ix = if index == count - 1 { 0 } else { index + 1 };
            self.set_selected_index(ix, true, cx);
            cx.notify();
        }
    }

    fn select_prev(&mut self, _: &SelectPrev, cx: &mut ViewContext<Self>) {
        let count = self.delegate.match_count();
        if count > 0 {
            let index = self.delegate.selected_index();
            let ix = if index == 0 { count - 1 } else { index - 1 };
            self.set_selected_index(ix, true, cx);
            cx.notify();
        }
    }

    fn select_first(&mut self, _: &SelectFirst, cx: &mut ViewContext<Self>) {
        let count = self.delegate.match_count();
        if count > 0 {
            self.set_selected_index(0, true, cx);
            cx.notify();
        }
    }

    fn select_last(&mut self, _: &SelectLast, cx: &mut ViewContext<Self>) {
        let count = self.delegate.match_count();
        if count > 0 {
            self.delegate.set_selected_index(count - 1, cx);
            self.set_selected_index(count - 1, true, cx);
            cx.notify();
        }
    }

    pub fn cancel(&mut self, _: &Cancel, cx: &mut ViewContext<Self>) {
        if self.delegate.should_dismiss() {
            self.delegate.dismissed(cx);
            cx.emit(DismissEvent);
        }
    }

    fn use_selected_query(&mut self, _: &UseSelectedQuery, cx: &mut ViewContext<Self>) {
        if let Some(new_query) = self.delegate.selected_as_query() {
            self.set_query(&new_query, cx);
            cx.stop_propagation();
        }
    }

    pub fn refresh(&mut self, cx: &mut ViewContext<Self>) {
        let query = self.query(cx);
        self.update_matches(&query, cx);
    }

    pub fn update_matches(&mut self, query: &str, cx: &mut ViewContext<Self>) {
        let delegate_pending_update_matches = self.delegate.update_matches(query, cx);

        self.matches_updated(cx);
        // This struct ensures that we can synchronously drop the task returned by the
        // delegate's `update_matches` method and the task that the picker is spawning.
        // If we simply capture the delegate's task into the picker's task, when the picker's
        // task gets synchronously dropped, the delegate's task would keep running until
        // the picker's task has a chance of being scheduled, because dropping a task happens
        // asynchronously.
        self.pending_update_matches = Some(PendingUpdateMatches {
            delegate_update_matches: Some(delegate_pending_update_matches),
            _task: cx.spawn(|this, mut cx| async move {
                let delegate_pending_update_matches = this.update(&mut cx, |this, _| {
                    this.pending_update_matches
                        .as_mut()
                        .unwrap()
                        .delegate_update_matches
                        .take()
                        .unwrap()
                })?;
                delegate_pending_update_matches.await;
                this.update(&mut cx, |this, cx| {
                    this.matches_updated(cx);
                })
            }),
        });
    }

    fn matches_updated(&mut self, cx: &mut ViewContext<Self>) {
        if let ElementContainer::List(state) = &mut self.element_container {
            state.reset(self.delegate.match_count());
        }

        let index = self.delegate.selected_index();
        self.scroll_to_item_index(index);
        // self.pending_update_matches = None;
        // if let Some(secondary) = self.confirm_on_update.take() {
        //     self.confirm(secondary, cx);
        // }
        cx.notify();
    }

    fn on_query_input_event(
        &mut self,
        _: View<TextInput>,
        event: &TextEvent,
        cx: &mut ViewContext<Self>,
    ) {
        #[allow(clippy::single_match)]
        match event {
            TextEvent::Input { text } => {
                self.set_query(text, cx);
                self.refresh(cx);
            }
            _ => {}
        }
    }
}

impl<D: PickerDelegate> Render for Picker<D> {
    fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
        v_flex()
            .key_context("Picker")
            .size_full()
            .when_some(self.width, |el, width| el.w(width))
            .overflow_hidden()
            .when(self.is_modal, |this| this.elevation_3(cx))
            .on_action(cx.listener(Self::select_next))
            .on_action(cx.listener(Self::select_prev))
            .on_action(cx.listener(Self::select_first))
            .on_action(cx.listener(Self::select_last))
            .on_action(cx.listener(Self::cancel))
            .on_action(cx.listener(Self::confirm))
            // .on_action(cx.listener(Self::secondary_confirm))
            .on_action(cx.listener(Self::use_selected_query))
            // .on_action(cx.listener(Self::confirm_input))
            // Render Query Input header
            .child(match self.query_input {
                Some(ref input) => self.delegate.render_query(input, cx),
                None => div().child(self.head.clone()),
            })
            .when(self.delegate.match_count() > 0, |el| {
                el.child(
                    v_flex()
                        .flex_grow()
                        .when_some(self.max_height, |div, max_h| div.max_h(max_h))
                        .overflow_hidden()
                        // .children(self.delegate.render_header(cx))
                        .child(self.render_element_container(cx)),
                )
            })
            .when(self.delegate.match_count() == 0, |el| {
                el.child(
                    v_flex()
                        .h_full()
                        .size_full()
                        .h_16()
                        .items_center()
                        .content_center()
                        .justify_center()
                        .text_color(cx.theme().muted_foreground)
                        .child("No matched."),
                )
            })
            .on_mouse_down_out(cx.listener(|_, _, cx| {
                cx.dispatch_action(Box::new(Cancel));
            }))
    }
}