use super::*;

impl Editor {
    pub fn style(&mut self, cx: &App) -> &EditorStyle {
        match self.style {
            Some(ref style) => style,
            None => {
                let style = self.create_style(cx);
                self.style.insert(style)
            }
        }
    }

    pub fn set_soft_wrap_mode(
        &mut self,
        mode: language_settings::SoftWrap,
        cx: &mut Context<Self>,
    ) {
        self.soft_wrap_mode_override = Some(mode);
        cx.notify();
    }

    pub fn set_hard_wrap(&mut self, hard_wrap: Option<usize>, cx: &mut Context<Self>) {
        self.hard_wrap = hard_wrap;
        cx.notify();
    }

    pub fn set_text_style_refinement(&mut self, style: TextStyleRefinement) {
        self.text_style_refinement = Some(style);
    }

    /// called by the Element so we know what style we were most recently rendered with.
    pub fn set_style(&mut self, style: EditorStyle, window: &mut Window, cx: &mut Context<Self>) {
        // We intentionally do not inform the display map about the minimap style
        // so that wrapping is not recalculated and stays consistent for the editor
        // and its linked minimap.
        if !self.mode.is_minimap() {
            let font = style.text.font();
            let font_size = style.text.font_size.to_pixels(window.rem_size());
            let display_map = self
                .placeholder_display_map
                .as_ref()
                .filter(|_| self.is_empty(cx))
                .unwrap_or(&self.display_map);

            display_map.update(cx, |map, cx| map.set_font(font, font_size, cx));
        }
        self.style = Some(style);
    }

    pub fn set_soft_wrap(&mut self) {
        self.soft_wrap_mode_override = Some(language_settings::SoftWrap::EditorWidth)
    }

    pub fn set_show_wrap_guides(&mut self, show_wrap_guides: bool, cx: &mut Context<Self>) {
        self.show_wrap_guides = Some(show_wrap_guides);
        cx.notify();
    }

    pub fn set_show_indent_guides(&mut self, show_indent_guides: bool, cx: &mut Context<Self>) {
        self.show_indent_guides = Some(show_indent_guides);
        cx.notify();
    }

    pub fn disable_indent_guides_for_buffer(
        &mut self,
        buffer_id: BufferId,
        cx: &mut Context<Self>,
    ) {
        self.buffers_with_disabled_indent_guides.insert(buffer_id);
        cx.notify();
    }

    pub fn toggle_line_numbers(
        &mut self,
        _: &ToggleLineNumbers,
        _: &mut Window,
        cx: &mut Context<Self>,
    ) {
        let mut editor_settings = EditorSettings::get_global(cx).clone();
        editor_settings.gutter.line_numbers = !editor_settings.gutter.line_numbers;
        EditorSettings::override_global(editor_settings, cx);
    }

    pub fn line_numbers_enabled(&self, cx: &App) -> bool {
        if let Some(show_line_numbers) = self.show_line_numbers {
            return show_line_numbers;
        }
        EditorSettings::get_global(cx).gutter.line_numbers
    }

    pub fn relative_line_numbers(&self, cx: &App) -> RelativeLineNumbers {
        match (
            self.use_relative_line_numbers,
            EditorSettings::get_global(cx).relative_line_numbers,
        ) {
            (None, setting) => setting,
            (Some(false), _) => RelativeLineNumbers::Disabled,
            (Some(true), RelativeLineNumbers::Wrapped) => RelativeLineNumbers::Wrapped,
            (Some(true), _) => RelativeLineNumbers::Enabled,
        }
    }

    pub fn set_relative_line_number(&mut self, is_relative: Option<bool>, cx: &mut Context<Self>) {
        self.use_relative_line_numbers = is_relative;
        cx.notify();
    }

    pub fn set_show_gutter(&mut self, show_gutter: bool, cx: &mut Context<Self>) {
        self.show_gutter = show_gutter;
        cx.notify();
    }

    pub fn set_show_vertical_scrollbar(&mut self, show: bool, cx: &mut Context<Self>) {
        self.show_scrollbars.vertical = show;
        cx.notify();
    }

    pub fn set_show_horizontal_scrollbar(&mut self, show: bool, cx: &mut Context<Self>) {
        self.show_scrollbars.horizontal = show;
        cx.notify();
    }

    pub fn set_minimap_visibility(
        &mut self,
        minimap_visibility: MinimapVisibility,
        window: &mut Window,
        cx: &mut Context<Self>,
    ) {
        if self.minimap_visibility != minimap_visibility {
            if minimap_visibility.visible() && self.minimap.is_none() {
                let minimap_settings = EditorSettings::get_global(cx).minimap;
                self.minimap =
                    self.create_minimap(minimap_settings.with_show_override(), window, cx);
            }
            self.minimap_visibility = minimap_visibility;
            cx.notify();
        }
    }

    pub fn breadcrumbs_visible(&self) -> bool {
        self.breadcrumbs_visibility.visible()
    }

    fn set_breadcrumbs_visibility(
        &mut self,
        breadcrumbs_visibility: BreadcrumbsVisibility,
        cx: &mut Context<Self>,
    ) {
        if self.breadcrumbs_visibility != breadcrumbs_visibility {
            self.breadcrumbs_visibility = breadcrumbs_visibility;
            cx.emit(EditorEvent::BreadcrumbsChanged);
            cx.notify();
        }
    }

    pub fn toggle_breadcrumb(
        &mut self,
        _: &ToggleBreadcrumb,
        _: &mut Window,
        cx: &mut Context<Self>,
    ) {
        self.set_breadcrumbs_visibility(self.breadcrumbs_visibility.toggle_visibility(), cx);
    }

    pub fn disable_scrollbars_and_minimap(&mut self, window: &mut Window, cx: &mut Context<Self>) {
        self.set_show_scrollbars(false, cx);
        self.set_minimap_visibility(MinimapVisibility::Disabled, window, cx);
    }

    pub fn hide_minimap_by_default(&mut self, window: &mut Window, cx: &mut Context<Self>) {
        self.set_minimap_visibility(self.minimap_visibility.hidden(), window, cx);
    }

    /// Normally the text in full mode and auto height editors is padded on the
    /// left side by roughly half a character width for improved hit testing.
    ///
    /// Use this method to disable this for cases where this is not wanted (e.g.
    /// if you want to align the editor text with some other text above or below)
    /// or if you want to add this padding to single-line editors.
    pub fn set_offset_content(&mut self, offset_content: bool, cx: &mut Context<Self>) {
        self.offset_content = offset_content;
        cx.notify();
    }

    pub fn set_show_line_numbers(&mut self, show_line_numbers: bool, cx: &mut Context<Self>) {
        self.show_line_numbers = Some(show_line_numbers);
        cx.notify();
    }

    pub fn disable_expand_excerpt_buttons(&mut self, cx: &mut Context<Self>) {
        self.disable_expand_excerpt_buttons = true;
        cx.notify();
    }

    pub fn set_show_git_diff_gutter(&mut self, show_git_diff_gutter: bool, cx: &mut Context<Self>) {
        self.show_git_diff_gutter = Some(show_git_diff_gutter);
        cx.notify();
    }

    pub fn set_allow_git_diff_scrollbar_markers(&mut self, allow: bool, cx: &mut Context<Self>) {
        if self.allow_git_diff_scrollbar_markers != allow {
            self.allow_git_diff_scrollbar_markers = allow;
            self.scrollbar_marker_state.dirty = true;
            self.scrollbar_marker_state.markers = Default::default();
            self.scrollbar_marker_state.pending_refresh = None;
            cx.notify();
        }
    }

    pub fn set_show_code_actions(&mut self, show_code_actions: bool, cx: &mut Context<Self>) {
        self.show_code_actions = Some(show_code_actions);
        cx.notify();
    }

    pub fn set_show_runnables(&mut self, show_runnables: bool, cx: &mut Context<Self>) {
        self.show_runnables = Some(show_runnables);
        cx.notify();
    }

    pub fn set_show_breakpoints(&mut self, show_breakpoints: bool, cx: &mut Context<Self>) {
        self.show_breakpoints = Some(show_breakpoints);
        cx.notify();
    }

    pub fn set_show_diff_review_button(&mut self, show: bool, cx: &mut Context<Self>) {
        self.show_diff_review_button = show;
        cx.notify();
    }

    fn set_show_scrollbars(&mut self, show: bool, cx: &mut Context<Self>) {
        self.show_scrollbars = ScrollbarAxes {
            horizontal: show,
            vertical: show,
        };
        cx.notify();
    }

    pub(super) fn wrap_guides(&self, cx: &App) -> SmallVec<[(usize, bool); 2]> {
        let mut wrap_guides = smallvec![];

        if self.show_wrap_guides == Some(false) {
            return wrap_guides;
        }

        let settings = self.buffer.read(cx).language_settings(cx);
        if settings.show_wrap_guides {
            match self.soft_wrap_mode(cx) {
                SoftWrap::Bounded(soft_wrap) => {
                    wrap_guides.push((soft_wrap as usize, true));
                }
                SoftWrap::GitDiff | SoftWrap::None | SoftWrap::EditorWidth => {}
            }
            wrap_guides.extend(settings.wrap_guides.iter().map(|guide| (*guide, false)))
        }

        wrap_guides
    }

    pub fn soft_wrap_mode(&self, cx: &App) -> SoftWrap {
        let settings = self.buffer.read(cx).language_settings(cx);
        let mode = self.soft_wrap_mode_override.unwrap_or(settings.soft_wrap);
        match mode {
            language_settings::SoftWrap::PreferLine | language_settings::SoftWrap::None => {
                SoftWrap::None
            }
            language_settings::SoftWrap::EditorWidth => SoftWrap::EditorWidth,
            language_settings::SoftWrap::Bounded => {
                SoftWrap::Bounded(settings.preferred_line_length)
            }
        }
    }

    // Called by the element. This method is not designed to be called outside of the editor
    // element's layout code because it does not notify when rewrapping is computed synchronously.
    pub(super) fn set_wrap_width(&self, width: Option<Pixels>, cx: &mut App) -> bool {
        if self.is_empty(cx) {
            self.placeholder_display_map
                .as_ref()
                .map_or(false, |display_map| {
                    display_map.update(cx, |map, cx| map.set_wrap_width(width, cx))
                })
        } else {
            self.display_map
                .update(cx, |map, cx| map.set_wrap_width(width, cx))
        }
    }

    pub fn toggle_soft_wrap(&mut self, _: &ToggleSoftWrap, _: &mut Window, cx: &mut Context<Self>) {
        if self.soft_wrap_mode_override.is_some() {
            self.soft_wrap_mode_override.take();
        } else {
            let soft_wrap = match self.soft_wrap_mode(cx) {
                SoftWrap::GitDiff => return,
                SoftWrap::None => language_settings::SoftWrap::EditorWidth,
                SoftWrap::EditorWidth | SoftWrap::Bounded(_) => language_settings::SoftWrap::None,
            };
            self.soft_wrap_mode_override = Some(soft_wrap);
        }
        cx.notify();
    }

    pub(super) fn toggle_tab_bar(
        &mut self,
        _: &ToggleTabBar,
        _: &mut Window,
        cx: &mut Context<Self>,
    ) {
        let Some(workspace) = self.workspace() else {
            return;
        };
        let fs = workspace.read(cx).app_state().fs.clone();
        let current_show = TabBarSettings::get_global(cx).show;
        update_settings_file(fs, cx, move |setting, _| {
            setting.tab_bar.get_or_insert_default().show = Some(!current_show);
        });
    }

    pub(super) fn toggle_indent_guides(
        &mut self,
        _: &ToggleIndentGuides,
        _: &mut Window,
        cx: &mut Context<Self>,
    ) {
        let currently_enabled = self.should_show_indent_guides().unwrap_or_else(|| {
            self.buffer
                .read(cx)
                .language_settings(cx)
                .indent_guides
                .enabled
        });
        self.show_indent_guides = Some(!currently_enabled);
        cx.notify();
    }

    pub(super) fn should_show_indent_guides(&self) -> Option<bool> {
        self.show_indent_guides
    }

    pub(super) fn has_indent_guides_disabled_for_buffer(&self, buffer_id: BufferId) -> bool {
        self.buffers_with_disabled_indent_guides
            .contains(&buffer_id)
    }

    pub(super) fn toggle_relative_line_numbers(
        &mut self,
        _: &ToggleRelativeLineNumbers,
        _: &mut Window,
        cx: &mut Context<Self>,
    ) {
        let is_relative = self.relative_line_numbers(cx);
        self.set_relative_line_number(Some(!is_relative.enabled()), cx)
    }

    pub(super) fn set_number_deleted_lines(&mut self, number: bool, cx: &mut Context<Self>) {
        self.number_deleted_lines = number;
        cx.notify();
    }

    pub fn set_delegate_open_excerpts(&mut self, delegate: bool) {
        self.delegate_open_excerpts = delegate;
    }

    pub(super) fn set_delegate_expand_excerpts(&mut self, delegate: bool) {
        self.delegate_expand_excerpts = delegate;
    }

    pub(super) fn set_on_local_selections_changed(
        &mut self,
        callback: Option<Box<dyn Fn(Point, &mut Window, &mut Context<Self>) + 'static>>,
    ) {
        self.on_local_selections_changed = callback;
    }

    pub(super) fn set_suppress_selection_callback(&mut self, suppress: bool) {
        self.suppress_selection_callback = suppress;
    }
}