use super::{
    buffer, movement, Anchor, Bias, Buffer, BufferElement, DisplayMap, DisplayPoint, Point,
    ToOffset, ToPoint,
};
use crate::{settings::Settings, watch, workspace};
use anyhow::Result;
use futures_core::future::LocalBoxFuture;
use gpui::{
    fonts::Properties as FontProperties, keymap::Binding, text_layout, App, AppContext, Element,
    ElementBox, Entity, FontCache, ModelHandle, View, ViewContext, WeakViewHandle,
};
use gpui::{geometry::vector::Vector2F, TextLayoutCache};
use parking_lot::Mutex;
use smallvec::SmallVec;
use smol::Timer;
use std::{
    cmp::{self, Ordering},
    fmt::Write,
    mem,
    ops::Range,
    sync::Arc,
    time::Duration,
};

const CURSOR_BLINK_INTERVAL: Duration = Duration::from_millis(500);

pub fn init(app: &mut App) {
    app.add_bindings(vec![
        Binding::new("backspace", "buffer:backspace", Some("BufferView")),
        Binding::new("enter", "buffer:newline", Some("BufferView")),
        Binding::new("cmd-z", "buffer:undo", Some("BufferView")),
        Binding::new("cmd-shift-Z", "buffer:redo", Some("BufferView")),
        Binding::new("up", "buffer:move_up", Some("BufferView")),
        Binding::new("down", "buffer:move_down", Some("BufferView")),
        Binding::new("left", "buffer:move_left", Some("BufferView")),
        Binding::new("right", "buffer:move_right", Some("BufferView")),
        Binding::new("shift-up", "buffer:select_up", Some("BufferView")),
        Binding::new("shift-down", "buffer:select_down", Some("BufferView")),
        Binding::new("shift-left", "buffer:select_left", Some("BufferView")),
        Binding::new("shift-right", "buffer:select_right", Some("BufferView")),
        Binding::new("pageup", "buffer:page_up", Some("BufferView")),
        Binding::new("pagedown", "buffer:page_down", Some("BufferView")),
        Binding::new("alt-cmd-[", "buffer:fold", Some("BufferView")),
        Binding::new("alt-cmd-]", "buffer:unfold", Some("BufferView")),
        Binding::new(
            "alt-cmd-f",
            "buffer:fold_selected_ranges",
            Some("BufferView"),
        ),
    ]);

    app.add_action("buffer:scroll", BufferView::scroll);
    app.add_action("buffer:select", BufferView::select);
    app.add_action("buffer:insert", BufferView::insert);
    app.add_action("buffer:newline", BufferView::newline);
    app.add_action("buffer:backspace", BufferView::backspace);
    app.add_action("buffer:undo", BufferView::undo);
    app.add_action("buffer:redo", BufferView::redo);
    app.add_action("buffer:move_up", BufferView::move_up);
    app.add_action("buffer:move_down", BufferView::move_down);
    app.add_action("buffer:move_left", BufferView::move_left);
    app.add_action("buffer:move_right", BufferView::move_right);
    app.add_action("buffer:select_up", BufferView::select_up);
    app.add_action("buffer:select_down", BufferView::select_down);
    app.add_action("buffer:select_left", BufferView::select_left);
    app.add_action("buffer:select_right", BufferView::select_right);
    app.add_action("buffer:page_up", BufferView::page_up);
    app.add_action("buffer:page_down", BufferView::page_down);
    app.add_action("buffer:fold", BufferView::fold);
    app.add_action("buffer:unfold", BufferView::unfold);
    app.add_action(
        "buffer:fold_selected_ranges",
        BufferView::fold_selected_ranges,
    );
}

pub enum SelectAction {
    Begin {
        position: DisplayPoint,
        add: bool,
    },
    Update {
        position: DisplayPoint,
        scroll_position: Vector2F,
    },
    End,
}

pub struct BufferView {
    handle: WeakViewHandle<Self>,
    buffer: ModelHandle<Buffer>,
    display_map: ModelHandle<DisplayMap>,
    selections: Vec<Selection>,
    pending_selection: Option<Selection>,
    scroll_position: Mutex<Vector2F>,
    autoscroll_requested: Mutex<bool>,
    settings: watch::Receiver<Settings>,
    focused: bool,
    cursors_visible: bool,
    blink_epoch: usize,
    blinking_paused: bool,
    single_line: bool,
}

impl BufferView {
    pub fn single_line(settings: watch::Receiver<Settings>, ctx: &mut ViewContext<Self>) -> Self {
        let buffer = ctx.add_model(|_| Buffer::new(0, String::new()));
        let mut view = Self::for_buffer(buffer, settings, ctx);
        view.single_line = true;
        view
    }

    pub fn for_buffer(
        buffer: ModelHandle<Buffer>,
        settings: watch::Receiver<Settings>,
        ctx: &mut ViewContext<Self>,
    ) -> Self {
        settings.notify_view_on_change(ctx);

        ctx.observe(&buffer, Self::on_buffer_changed);
        ctx.subscribe_to_model(&buffer, Self::on_buffer_event);
        let display_map = ctx.add_model(|ctx| {
            DisplayMap::new(
                buffer.clone(),
                smol::block_on(settings.read()).tab_size,
                ctx,
            )
        });
        ctx.observe(&display_map, Self::on_display_map_changed);

        let buffer_ref = buffer.as_ref(ctx);
        Self {
            handle: ctx.handle().downgrade(),
            buffer,
            display_map,
            selections: vec![Selection {
                start: buffer_ref.anchor_before(0).unwrap(),
                end: buffer_ref.anchor_before(0).unwrap(),
                reversed: false,
                goal_column: None,
            }],
            pending_selection: None,
            scroll_position: Mutex::new(Vector2F::zero()),
            autoscroll_requested: Mutex::new(false),
            settings,
            focused: false,
            cursors_visible: false,
            blink_epoch: 0,
            blinking_paused: false,
            single_line: false,
        }
    }

    pub fn buffer(&self) -> &ModelHandle<Buffer> {
        &self.buffer
    }

    pub fn is_gutter_visible(&self) -> bool {
        !self.single_line
    }

    fn scroll(&mut self, scroll_position: &Vector2F, ctx: &mut ViewContext<Self>) {
        *self.scroll_position.lock() = *scroll_position;
        ctx.notify();
    }

    pub fn scroll_position(&self) -> Vector2F {
        *self.scroll_position.lock()
    }

    pub fn clamp_scroll_left(&self, max: f32) {
        let mut scroll_position = self.scroll_position.lock();
        let scroll_left = scroll_position.x();
        scroll_position.set_x(scroll_left.min(max));
    }

    pub fn autoscroll_vertically(
        &self,
        viewport_height: f32,
        line_height: f32,
        app: &AppContext,
    ) -> bool {
        let mut scroll_position = self.scroll_position.lock();
        let scroll_top = scroll_position.y();
        scroll_position.set_y(scroll_top.min(self.max_point(app).row().saturating_sub(1) as f32));

        let mut autoscroll_requested = self.autoscroll_requested.lock();
        if *autoscroll_requested {
            *autoscroll_requested = false;
        } else {
            return false;
        }

        let map = self.display_map.as_ref(app);
        let visible_lines = viewport_height / line_height;
        let first_cursor_top = self
            .selections
            .first()
            .unwrap()
            .head()
            .to_display_point(map, app)
            .unwrap()
            .row() as f32;
        let last_cursor_bottom = self
            .selections
            .last()
            .unwrap()
            .head()
            .to_display_point(map, app)
            .unwrap()
            .row() as f32
            + 1.0;

        let margin = ((visible_lines - (last_cursor_bottom - first_cursor_top)) / 2.0)
            .floor()
            .min(3.0);
        if margin < 0.0 {
            return false;
        }

        let target_top = (first_cursor_top - margin).max(0.0);
        let target_bottom = last_cursor_bottom + margin;
        let start_row = scroll_position.y();
        let end_row = start_row + visible_lines;

        if target_top < start_row {
            scroll_position.set_y(target_top);
        } else if target_bottom >= end_row {
            scroll_position.set_y(target_bottom - visible_lines);
        }

        true
    }

    pub fn autoscroll_horizontally(
        &self,
        start_row: u32,
        viewport_width: f32,
        scroll_width: f32,
        max_glyph_width: f32,
        layouts: &[Arc<text_layout::Line>],
        app: &AppContext,
    ) {
        let map = self.display_map.as_ref(app);

        let mut target_left = std::f32::INFINITY;
        let mut target_right = 0.0_f32;
        for selection in &self.selections {
            let head = selection.head().to_display_point(map, app).unwrap();
            let start_column = head.column().saturating_sub(3);
            let end_column = cmp::min(map.line_len(head.row(), app).unwrap(), head.column() + 3);
            target_left = target_left
                .min(layouts[(head.row() - start_row) as usize].x_for_index(start_column as usize));
            target_right = target_right.max(
                layouts[(head.row() - start_row) as usize].x_for_index(end_column as usize)
                    + max_glyph_width,
            );
        }
        target_right = target_right.min(scroll_width);

        if target_right - target_left > viewport_width {
            return;
        }

        let mut scroll_position = self.scroll_position.lock();
        let scroll_left = scroll_position.x() * max_glyph_width;
        let scroll_right = scroll_left + viewport_width;

        if target_left < scroll_left {
            scroll_position.set_x(target_left / max_glyph_width);
        } else if target_right > scroll_right {
            scroll_position.set_x((target_right - viewport_width) / max_glyph_width);
        }
    }

    fn select(&mut self, arg: &SelectAction, ctx: &mut ViewContext<Self>) {
        match arg {
            SelectAction::Begin { position, add } => self.begin_selection(*position, *add, ctx),
            SelectAction::Update {
                position,
                scroll_position,
            } => self.update_selection(*position, *scroll_position, ctx),
            SelectAction::End => self.end_selection(ctx),
        }
    }

    fn begin_selection(&mut self, position: DisplayPoint, add: bool, ctx: &mut ViewContext<Self>) {
        if !self.focused {
            ctx.focus_self();
            ctx.emit(Event::Activate);
        }

        let display_map = self.display_map.as_ref(ctx);
        let cursor = display_map
            .anchor_before(position, Bias::Left, ctx.app())
            .unwrap();
        let selection = Selection {
            start: cursor.clone(),
            end: cursor,
            reversed: false,
            goal_column: None,
        };

        if !add {
            self.selections.clear();
        }
        self.pending_selection = Some(selection);

        ctx.notify();
    }

    fn update_selection(
        &mut self,
        position: DisplayPoint,
        scroll_position: Vector2F,
        ctx: &mut ViewContext<Self>,
    ) {
        let buffer = self.buffer.as_ref(ctx);
        let map = self.display_map.as_ref(ctx);
        let cursor = map.anchor_before(position, Bias::Left, ctx.app()).unwrap();
        if let Some(selection) = self.pending_selection.as_mut() {
            selection.set_head(buffer, cursor);
        } else {
            log::error!("update_selection dispatched with no pending selection");
            return;
        }

        *self.scroll_position.lock() = scroll_position;

        ctx.notify();
    }

    fn end_selection(&mut self, ctx: &mut ViewContext<Self>) {
        if let Some(selection) = self.pending_selection.take() {
            let ix = self.selection_insertion_index(&selection.start, ctx.app());
            self.selections.insert(ix, selection);
            self.merge_selections(ctx.app());
            ctx.notify();
        } else {
            log::error!("end_selection dispatched with no pending selection");
        }
    }

    pub fn is_selecting(&self) -> bool {
        self.pending_selection.is_some()
    }

    #[cfg(test)]
    fn select_ranges<'a, T>(&mut self, ranges: T, ctx: &mut ViewContext<Self>) -> Result<()>
    where
        T: IntoIterator<Item = &'a Range<DisplayPoint>>,
    {
        let buffer = self.buffer.as_ref(ctx);
        let map = self.display_map.as_ref(ctx);
        let mut selections = Vec::new();
        for range in ranges {
            selections.push(Selection {
                start: map.anchor_after(range.start, Bias::Left, ctx.app())?,
                end: map.anchor_before(range.end, Bias::Left, ctx.app())?,
                reversed: false,
                goal_column: None,
            });
        }
        selections.sort_unstable_by(|a, b| a.start.cmp(&b.start, buffer).unwrap());
        self.selections = selections;
        self.merge_selections(ctx.app());
        ctx.notify();
        Ok(())
    }

    fn insert(&mut self, text: &String, ctx: &mut ViewContext<Self>) {
        let buffer = self.buffer.as_ref(ctx);
        let mut offset_ranges = SmallVec::<[Range<usize>; 32]>::new();
        for selection in &self.selections {
            let start = selection.start.to_offset(buffer).unwrap();
            let end = selection.end.to_offset(buffer).unwrap();
            offset_ranges.push(start..end);
        }

        self.buffer.update(ctx, |buffer, ctx| {
            if let Err(error) = buffer.edit(offset_ranges.iter().cloned(), text.as_str(), Some(ctx))
            {
                log::error!("error inserting text: {}", error);
            };
        });

        let buffer = self.buffer.as_ref(ctx);
        let char_count = text.chars().count() as isize;
        let mut delta = 0_isize;
        self.selections = offset_ranges
            .into_iter()
            .map(|range| {
                let start = range.start as isize;
                let end = range.end as isize;
                let anchor = buffer
                    .anchor_before((start + delta + char_count) as usize)
                    .unwrap();
                let deleted_count = end - start;
                delta += char_count - deleted_count;
                Selection {
                    start: anchor.clone(),
                    end: anchor,
                    reversed: false,
                    goal_column: None,
                }
            })
            .collect();

        self.pause_cursor_blinking(ctx);
        *self.autoscroll_requested.lock() = true;
    }

    fn newline(&mut self, _: &(), ctx: &mut ViewContext<Self>) {
        if self.single_line {
            ctx.propagate_action();
        } else {
            self.insert(&"\n".into(), ctx);
        }
    }

    pub fn backspace(&mut self, _: &(), ctx: &mut ViewContext<Self>) {
        let buffer = self.buffer.as_ref(ctx);
        let map = self.display_map.as_ref(ctx);
        for selection in &mut self.selections {
            if selection.range(buffer).is_empty() {
                let head = selection.head().to_display_point(map, ctx.app()).unwrap();
                let cursor = map
                    .anchor_before(
                        movement::left(map, head, ctx.app()).unwrap(),
                        Bias::Left,
                        ctx.app(),
                    )
                    .unwrap();
                selection.set_head(&buffer, cursor);
                selection.goal_column = None;
            }
        }
        self.changed_selections(ctx);
        self.insert(&String::new(), ctx);
    }

    pub fn undo(&mut self, _: &(), ctx: &mut ViewContext<Self>) {
        self.buffer
            .update(ctx, |buffer, ctx| buffer.undo(Some(ctx)));
    }

    pub fn redo(&mut self, _: &(), ctx: &mut ViewContext<Self>) {
        self.buffer
            .update(ctx, |buffer, ctx| buffer.redo(Some(ctx)));
    }

    pub fn move_left(&mut self, _: &(), ctx: &mut ViewContext<Self>) {
        {
            let app = ctx.app();
            let map = self.display_map.as_ref(ctx);
            for selection in &mut self.selections {
                let start = selection.start.to_display_point(map, app).unwrap();
                let end = selection.end.to_display_point(map, app).unwrap();

                if start != end {
                    selection.end = selection.start.clone();
                } else {
                    let cursor = map
                        .anchor_before(movement::left(map, start, app).unwrap(), Bias::Left, app)
                        .unwrap();
                    selection.start = cursor.clone();
                    selection.end = cursor;
                }
                selection.reversed = false;
                selection.goal_column = None;
            }
        }
        self.changed_selections(ctx);
    }

    pub fn select_left(&mut self, _: &(), ctx: &mut ViewContext<Self>) {
        {
            let buffer = self.buffer.as_ref(ctx);
            let map = self.display_map.as_ref(ctx);
            for selection in &mut self.selections {
                let head = selection.head().to_display_point(map, ctx.app()).unwrap();
                let cursor = map
                    .anchor_before(
                        movement::left(map, head, ctx.app()).unwrap(),
                        Bias::Left,
                        ctx.app(),
                    )
                    .unwrap();
                selection.set_head(&buffer, cursor);
                selection.goal_column = None;
            }
        }
        self.changed_selections(ctx);
    }

    pub fn move_right(&mut self, _: &(), ctx: &mut ViewContext<Self>) {
        {
            let app = ctx.app();
            let map = self.display_map.as_ref(app);
            for selection in &mut self.selections {
                let start = selection.start.to_display_point(map, app).unwrap();
                let end = selection.end.to_display_point(map, app).unwrap();

                if start != end {
                    selection.start = selection.end.clone();
                } else {
                    let cursor = map
                        .anchor_before(movement::right(map, end, app).unwrap(), Bias::Right, app)
                        .unwrap();
                    selection.start = cursor.clone();
                    selection.end = cursor;
                }
                selection.reversed = false;
                selection.goal_column = None;
            }
        }
        self.changed_selections(ctx);
    }

    pub fn select_right(&mut self, _: &(), ctx: &mut ViewContext<Self>) {
        {
            let buffer = self.buffer.as_ref(ctx);
            let app = ctx.app();
            let map = self.display_map.as_ref(app);
            for selection in &mut self.selections {
                let head = selection.head().to_display_point(map, ctx.app()).unwrap();
                let cursor = map
                    .anchor_before(movement::right(map, head, app).unwrap(), Bias::Right, app)
                    .unwrap();
                selection.set_head(&buffer, cursor);
                selection.goal_column = None;
            }
        }
        self.changed_selections(ctx);
    }

    pub fn move_up(&mut self, _: &(), ctx: &mut ViewContext<Self>) {
        if self.single_line {
            ctx.propagate_action();
        } else {
            let app = ctx.app();
            let map = self.display_map.as_ref(app);
            for selection in &mut self.selections {
                let start = selection.start.to_display_point(map, app).unwrap();
                let end = selection.end.to_display_point(map, app).unwrap();
                if start != end {
                    selection.goal_column = None;
                }

                let (start, goal_column) =
                    movement::up(map, start, selection.goal_column, app).unwrap();
                let cursor = map.anchor_before(start, Bias::Left, app).unwrap();
                selection.start = cursor.clone();
                selection.end = cursor;
                selection.goal_column = goal_column;
                selection.reversed = false;
            }
            self.changed_selections(ctx);
        }
    }

    pub fn select_up(&mut self, _: &(), ctx: &mut ViewContext<Self>) {
        if self.single_line {
            ctx.propagate_action();
        } else {
            let app = ctx.app();
            let buffer = self.buffer.as_ref(app);
            let map = self.display_map.as_ref(app);
            for selection in &mut self.selections {
                let head = selection.head().to_display_point(map, app).unwrap();
                let (head, goal_column) =
                    movement::up(map, head, selection.goal_column, app).unwrap();
                selection.set_head(&buffer, map.anchor_before(head, Bias::Left, app).unwrap());
                selection.goal_column = goal_column;
            }
            self.changed_selections(ctx);
        }
    }

    pub fn move_down(&mut self, _: &(), ctx: &mut ViewContext<Self>) {
        if self.single_line {
            ctx.propagate_action();
        } else {
            let app = ctx.app();
            let map = self.display_map.as_ref(app);
            for selection in &mut self.selections {
                let start = selection.start.to_display_point(map, app).unwrap();
                let end = selection.end.to_display_point(map, app).unwrap();
                if start != end {
                    selection.goal_column = None;
                }

                let (start, goal_column) =
                    movement::down(map, end, selection.goal_column, app).unwrap();
                let cursor = map.anchor_before(start, Bias::Right, app).unwrap();
                selection.start = cursor.clone();
                selection.end = cursor;
                selection.goal_column = goal_column;
                selection.reversed = false;
            }
            self.changed_selections(ctx);
        }
    }

    pub fn select_down(&mut self, _: &(), ctx: &mut ViewContext<Self>) {
        if self.single_line {
            ctx.propagate_action();
        } else {
            let app = ctx.app();
            let buffer = self.buffer.as_ref(ctx);
            let map = self.display_map.as_ref(ctx);
            for selection in &mut self.selections {
                let head = selection.head().to_display_point(map, app).unwrap();
                let (head, goal_column) =
                    movement::down(map, head, selection.goal_column, app).unwrap();
                selection.set_head(&buffer, map.anchor_before(head, Bias::Right, app).unwrap());
                selection.goal_column = goal_column;
            }
            self.changed_selections(ctx);
        }
    }

    pub fn changed_selections(&mut self, ctx: &mut ViewContext<Self>) {
        self.merge_selections(ctx.app());
        self.pause_cursor_blinking(ctx);
        *self.autoscroll_requested.lock() = true;
        ctx.notify();
    }

    fn merge_selections(&mut self, ctx: &AppContext) {
        let buffer = self.buffer.as_ref(ctx);
        let mut i = 1;
        while i < self.selections.len() {
            if self.selections[i - 1]
                .end
                .cmp(&self.selections[i].start, buffer)
                .unwrap()
                >= Ordering::Equal
            {
                let removed = self.selections.remove(i);
                if removed
                    .start
                    .cmp(&self.selections[i - 1].start, buffer)
                    .unwrap()
                    < Ordering::Equal
                {
                    self.selections[i - 1].start = removed.start;
                }
                if removed
                    .end
                    .cmp(&self.selections[i - 1].end, buffer)
                    .unwrap()
                    > Ordering::Equal
                {
                    self.selections[i - 1].end = removed.end;
                }
            } else {
                i += 1;
            }
        }
    }

    pub fn first_selection(&self, app: &AppContext) -> Range<DisplayPoint> {
        self.selections
            .first()
            .unwrap()
            .display_range(self.display_map.as_ref(app), app)
    }

    pub fn last_selection(&self, app: &AppContext) -> Range<DisplayPoint> {
        self.selections
            .last()
            .unwrap()
            .display_range(self.display_map.as_ref(app), app)
    }

    pub fn selections_in_range<'a>(
        &'a self,
        range: Range<DisplayPoint>,
        app: &'a AppContext,
    ) -> impl 'a + Iterator<Item = Range<DisplayPoint>> {
        let map = self.display_map.as_ref(app);

        let start = map.anchor_before(range.start, Bias::Left, app).unwrap();
        let start_index = self.selection_insertion_index(&start, app);
        let pending_selection = self.pending_selection.as_ref().and_then(|s| {
            let selection_range = s.display_range(map, app);
            if selection_range.start <= range.end || selection_range.end <= range.end {
                Some(selection_range)
            } else {
                None
            }
        });
        self.selections[start_index..]
            .iter()
            .map(move |s| s.display_range(map, app))
            .take_while(move |r| r.start <= range.end || r.end <= range.end)
            .chain(pending_selection)
    }

    fn selection_insertion_index(&self, start: &Anchor, app: &AppContext) -> usize {
        let buffer = self.buffer.as_ref(app);

        match self
            .selections
            .binary_search_by(|probe| probe.start.cmp(&start, buffer).unwrap())
        {
            Ok(index) => index,
            Err(index) => {
                if index > 0
                    && self.selections[index - 1].end.cmp(&start, buffer).unwrap()
                        == Ordering::Greater
                {
                    index - 1
                } else {
                    index
                }
            }
        }
    }

    pub fn page_up(&mut self, _: &(), _: &mut ViewContext<Self>) {
        log::info!("BufferView::page_up");
    }

    pub fn page_down(&mut self, _: &(), _: &mut ViewContext<Self>) {
        log::info!("BufferView::page_down");
    }

    pub fn fold(&mut self, _: &(), ctx: &mut ViewContext<Self>) {
        use super::RangeExt;

        let mut fold_ranges = Vec::new();

        let app = ctx.app();
        let map = self.display_map.as_ref(app);
        for selection in &self.selections {
            let (start, end) = selection.display_range(map, app).sorted();
            let buffer_start_row = start.to_buffer_point(map, Bias::Left, app).unwrap().row;

            for row in (0..=end.row()).rev() {
                if self.is_line_foldable(row, app) && !map.is_line_folded(row) {
                    let fold_range = self.foldable_range_for_line(row, app).unwrap();
                    if fold_range.end.row >= buffer_start_row {
                        fold_ranges.push(fold_range);
                        if row <= start.row() {
                            break;
                        }
                    }
                }
            }
        }

        if !fold_ranges.is_empty() {
            self.display_map.update(ctx, |map, ctx| {
                map.fold(fold_ranges, ctx).unwrap();
            });
            *self.autoscroll_requested.lock() = true;
        }
    }

    pub fn unfold(&mut self, _: &(), ctx: &mut ViewContext<Self>) {
        use super::RangeExt;

        let app = ctx.app();
        let map = self.display_map.as_ref(app);
        let buffer = self.buffer.as_ref(app);
        let ranges = self
            .selections
            .iter()
            .map(|s| {
                let (start, end) = s.display_range(map, app).sorted();
                let mut start = start.to_buffer_point(map, Bias::Left, app).unwrap();
                let mut end = end.to_buffer_point(map, Bias::Left, app).unwrap();
                start.column = 0;
                end.column = buffer.line_len(end.row).unwrap();
                start..end
            })
            .collect::<Vec<_>>();

        self.display_map.update(ctx, |map, ctx| {
            map.unfold(ranges, ctx).unwrap();
        });
        *self.autoscroll_requested.lock() = true;
    }

    fn is_line_foldable(&self, display_row: u32, app: &AppContext) -> bool {
        let max_point = self.max_point(app);
        if display_row >= max_point.row() {
            false
        } else {
            let (start_indent, is_blank) = self.line_indent(display_row, app).unwrap();
            if is_blank {
                false
            } else {
                for display_row in display_row + 1..=max_point.row() {
                    let (indent, is_blank) = self.line_indent(display_row, app).unwrap();
                    if !is_blank {
                        return indent > start_indent;
                    }
                }
                false
            }
        }
    }

    fn line_indent(&self, display_row: u32, app: &AppContext) -> Result<(usize, bool)> {
        let mut indent = 0;
        let mut is_blank = true;
        for c in self
            .display_map
            .as_ref(app)
            .chars_at(DisplayPoint::new(display_row, 0), app)?
        {
            if c == ' ' {
                indent += 1;
            } else {
                is_blank = c == '\n';
                break;
            }
        }
        Ok((indent, is_blank))
    }

    fn foldable_range_for_line(&self, start_row: u32, app: &AppContext) -> Result<Range<Point>> {
        let map = self.display_map.as_ref(app);
        let max_point = self.max_point(app);

        let (start_indent, _) = self.line_indent(start_row, app)?;
        let start = DisplayPoint::new(start_row, self.line_len(start_row, app)?);
        let mut end = None;
        for row in start_row + 1..=max_point.row() {
            let (indent, is_blank) = self.line_indent(row, app)?;
            if !is_blank && indent <= start_indent {
                end = Some(DisplayPoint::new(row - 1, self.line_len(row - 1, app)?));
                break;
            }
        }

        let end = end.unwrap_or(max_point);
        return Ok(start.to_buffer_point(map, Bias::Left, app)?
            ..end.to_buffer_point(map, Bias::Left, app)?);
    }

    pub fn fold_selected_ranges(&mut self, _: &(), ctx: &mut ViewContext<Self>) {
        self.display_map.update(ctx, |map, ctx| {
            let buffer = self.buffer.as_ref(ctx);
            let ranges = self
                .selections
                .iter()
                .map(|s| s.range(buffer))
                .collect::<Vec<_>>();
            map.fold(ranges, ctx).unwrap();
        });
    }

    pub fn line(&self, display_row: u32, app: &AppContext) -> Result<String> {
        self.display_map.as_ref(app).line(display_row, app)
    }

    pub fn line_len(&self, display_row: u32, app: &AppContext) -> Result<u32> {
        self.display_map.as_ref(app).line_len(display_row, app)
    }

    pub fn rightmost_point(&self, app: &AppContext) -> DisplayPoint {
        self.display_map.as_ref(app).rightmost_point()
    }

    pub fn max_point(&self, app: &AppContext) -> DisplayPoint {
        self.display_map.as_ref(app).max_point(app)
    }

    pub fn text(&self, app: &AppContext) -> String {
        self.display_map.as_ref(app).text(app)
    }

    pub fn font_size(&self) -> f32 {
        smol::block_on(self.settings.read()).buffer_font_size
    }

    pub fn font_ascent(&self, font_cache: &FontCache) -> f32 {
        let settings = smol::block_on(self.settings.read());
        let font_id = font_cache.default_font(settings.buffer_font_family);
        let ascent = font_cache.metric(font_id, |m| m.ascent);
        font_cache.scale_metric(ascent, font_id, settings.buffer_font_size)
    }

    pub fn font_descent(&self, font_cache: &FontCache) -> f32 {
        let settings = smol::block_on(self.settings.read());
        let font_id = font_cache.default_font(settings.buffer_font_family);
        let ascent = font_cache.metric(font_id, |m| m.descent);
        font_cache.scale_metric(ascent, font_id, settings.buffer_font_size)
    }

    pub fn line_height(&self, font_cache: &FontCache) -> f32 {
        let settings = smol::block_on(self.settings.read());
        let font_id = font_cache.default_font(settings.buffer_font_family);
        font_cache.line_height(font_id, settings.buffer_font_size)
    }

    pub fn em_width(&self, font_cache: &FontCache) -> f32 {
        let settings = smol::block_on(self.settings.read());
        let font_id = font_cache.default_font(settings.buffer_font_family);
        font_cache.em_width(font_id, settings.buffer_font_size)
    }

    // TODO: Can we make this not return a result?
    pub fn max_line_number_width(
        &self,
        font_cache: &FontCache,
        layout_cache: &TextLayoutCache,
        app: &AppContext,
    ) -> Result<f32> {
        let settings = smol::block_on(self.settings.read());
        let font_size = settings.buffer_font_size;
        let font_id =
            font_cache.select_font(settings.buffer_font_family, &FontProperties::new())?;
        let digit_count = ((self.buffer.as_ref(app).max_point().row + 1) as f32)
            .log10()
            .floor() as usize
            + 1;

        Ok(layout_cache
            .layout_str(
                "1".repeat(digit_count).as_str(),
                font_size,
                &[(0..digit_count, font_id)],
            )
            .width)
    }

    pub fn layout_line_numbers(
        &self,
        viewport_height: f32,
        font_cache: &FontCache,
        layout_cache: &TextLayoutCache,
        app: &AppContext,
    ) -> Result<Vec<Arc<text_layout::Line>>> {
        let display_map = self.display_map.as_ref(app);

        let settings = smol::block_on(self.settings.read());
        let font_size = settings.buffer_font_size;
        let font_id =
            font_cache.select_font(settings.buffer_font_family, &FontProperties::new())?;

        let start_row = self.scroll_position().y() as usize;
        let end_row = cmp::min(
            self.max_point(app).row() as usize,
            start_row + (viewport_height / self.line_height(font_cache)).ceil() as usize,
        );
        let line_count = end_row - start_row + 1;

        let mut layouts = Vec::with_capacity(line_count);
        let mut line_number = String::new();
        for buffer_row in display_map.buffer_rows(start_row as u32)?.take(line_count) {
            line_number.clear();
            write!(&mut line_number, "{}", buffer_row + 1).unwrap();
            layouts.push(layout_cache.layout_str(
                &line_number,
                font_size,
                &[(0..line_number.len(), font_id)],
            ));
        }

        Ok(layouts)
    }

    pub fn layout_lines(
        &self,
        mut rows: Range<u32>,
        font_cache: &FontCache,
        layout_cache: &TextLayoutCache,
        app: &AppContext,
    ) -> Result<Vec<Arc<text_layout::Line>>> {
        let display_map = self.display_map.as_ref(app);

        rows.end = cmp::min(rows.end, display_map.max_point(app).row() + 1);
        if rows.start >= rows.end {
            return Ok(Vec::new());
        }

        let settings = smol::block_on(self.settings.read());
        let font_id =
            font_cache.select_font(settings.buffer_font_family, &FontProperties::new())?;
        let font_size = settings.buffer_font_size;

        let mut layouts = Vec::with_capacity(rows.len());
        let mut line = String::new();
        let mut line_len = 0;
        let mut row = rows.start;
        let chars = display_map
            .chars_at(DisplayPoint::new(rows.start, 0), app)
            .unwrap();
        for char in chars.chain(Some('\n')) {
            if char == '\n' {
                layouts.push(layout_cache.layout_str(&line, font_size, &[(0..line_len, font_id)]));
                line.clear();
                line_len = 0;
                row += 1;
                if row == rows.end {
                    break;
                }
            } else {
                line_len += 1;
                line.push(char);
            }
        }

        Ok(layouts)
    }

    pub fn layout_line(
        &self,
        row: u32,
        font_cache: &FontCache,
        layout_cache: &TextLayoutCache,
        app: &AppContext,
    ) -> Result<Arc<text_layout::Line>> {
        let settings = smol::block_on(self.settings.read());
        let font_id =
            font_cache.select_font(settings.buffer_font_family, &FontProperties::new())?;

        let line = self.line(row, app)?;

        Ok(layout_cache.layout_str(
            &line,
            settings.buffer_font_size,
            &[(0..self.line_len(row, app)? as usize, font_id)],
        ))
    }

    fn next_blink_epoch(&mut self) -> usize {
        self.blink_epoch += 1;
        self.blink_epoch
    }

    fn pause_cursor_blinking(&mut self, ctx: &mut ViewContext<Self>) {
        self.cursors_visible = true;
        ctx.notify();

        let epoch = self.next_blink_epoch();
        ctx.spawn(
            async move {
                Timer::after(CURSOR_BLINK_INTERVAL).await;
                epoch
            },
            Self::resume_cursor_blinking,
        )
        .detach();
    }

    fn resume_cursor_blinking(&mut self, epoch: usize, ctx: &mut ViewContext<Self>) {
        if epoch == self.blink_epoch {
            self.blinking_paused = false;
            self.blink_cursors(epoch, ctx);
        }
    }

    fn blink_cursors(&mut self, epoch: usize, ctx: &mut ViewContext<Self>) {
        if epoch == self.blink_epoch && self.focused && !self.blinking_paused {
            self.cursors_visible = !self.cursors_visible;
            ctx.notify();

            let epoch = self.next_blink_epoch();
            ctx.spawn(
                async move {
                    Timer::after(CURSOR_BLINK_INTERVAL).await;
                    epoch
                },
                Self::blink_cursors,
            )
            .detach();
        }
    }

    pub fn cursors_visible(&self) -> bool {
        self.cursors_visible
    }

    fn on_buffer_changed(&mut self, _: ModelHandle<Buffer>, ctx: &mut ViewContext<Self>) {
        ctx.notify();
    }

    fn on_display_map_changed(&mut self, _: ModelHandle<DisplayMap>, ctx: &mut ViewContext<Self>) {
        ctx.notify();
    }

    fn on_buffer_event(
        &mut self,
        _: ModelHandle<Buffer>,
        event: &buffer::Event,
        ctx: &mut ViewContext<Self>,
    ) {
        match event {
            buffer::Event::Edited(_) => ctx.emit(Event::Edited),
            buffer::Event::Dirtied => ctx.emit(Event::Dirtied),
            buffer::Event::Saved => ctx.emit(Event::Saved),
        }
    }
}

struct Selection {
    start: Anchor,
    end: Anchor,
    reversed: bool,
    goal_column: Option<u32>,
}

pub enum Event {
    Activate,
    Edited,
    Blurred,
    Dirtied,
    Saved,
}

impl Entity for BufferView {
    type Event = Event;
}

impl View for BufferView {
    fn render<'a>(&self, app: &AppContext) -> ElementBox {
        BufferElement::new(self.handle.upgrade(app).unwrap()).boxed()
    }

    fn ui_name() -> &'static str {
        "BufferView"
    }

    fn on_focus(&mut self, ctx: &mut ViewContext<Self>) {
        self.focused = true;
        self.blink_cursors(self.blink_epoch, ctx);
    }

    fn on_blur(&mut self, ctx: &mut ViewContext<Self>) {
        self.focused = false;
        self.cursors_visible = false;
        ctx.emit(Event::Blurred);
        ctx.notify();
    }
}

impl workspace::Item for Buffer {
    type View = BufferView;

    fn build_view(
        buffer: ModelHandle<Self>,
        settings: watch::Receiver<Settings>,
        ctx: &mut ViewContext<Self::View>,
    ) -> Self::View {
        BufferView::for_buffer(buffer, settings, ctx)
    }
}

impl workspace::ItemView for BufferView {
    fn should_activate_item_on_event(event: &Self::Event) -> bool {
        matches!(event, Event::Activate)
    }

    fn should_update_tab_on_event(event: &Self::Event) -> bool {
        matches!(event, Event::Saved | Event::Dirtied)
    }

    fn title(&self, app: &AppContext) -> std::string::String {
        if let Some(path) = self.buffer.as_ref(app).path(app) {
            path.file_name()
                .expect("buffer's path is always to a file")
                .to_string_lossy()
                .into()
        } else {
            "untitled".into()
        }
    }

    fn entry_id(&self, app: &AppContext) -> Option<(usize, usize)> {
        self.buffer.as_ref(app).entry_id()
    }

    fn clone_on_split(&self, ctx: &mut ViewContext<Self>) -> Option<Self>
    where
        Self: Sized,
    {
        let clone = BufferView::for_buffer(self.buffer.clone(), self.settings.clone(), ctx);
        *clone.scroll_position.lock() = *self.scroll_position.lock();
        Some(clone)
    }

    fn save(&self, ctx: &mut ViewContext<Self>) -> LocalBoxFuture<'static, Result<()>> {
        self.buffer.update(ctx, |buffer, ctx| buffer.save(ctx))
    }

    fn is_dirty(&self, ctx: &AppContext) -> bool {
        self.buffer.as_ref(ctx).is_dirty()
    }
}

impl Selection {
    fn head(&self) -> &Anchor {
        if self.reversed {
            &self.start
        } else {
            &self.end
        }
    }

    fn set_head(&mut self, buffer: &Buffer, cursor: Anchor) {
        if cursor.cmp(self.tail(), buffer).unwrap() < Ordering::Equal {
            if !self.reversed {
                mem::swap(&mut self.start, &mut self.end);
                self.reversed = true;
            }
            self.start = cursor;
        } else {
            if self.reversed {
                mem::swap(&mut self.start, &mut self.end);
                self.reversed = false;
            }
            self.end = cursor;
        }
    }

    fn tail(&self) -> &Anchor {
        if self.reversed {
            &self.end
        } else {
            &self.start
        }
    }

    fn range(&self, buffer: &Buffer) -> Range<Point> {
        let start = self.start.to_point(buffer).unwrap();
        let end = self.end.to_point(buffer).unwrap();
        if self.reversed {
            end..start
        } else {
            start..end
        }
    }

    fn display_range(&self, map: &DisplayMap, app: &AppContext) -> Range<DisplayPoint> {
        let start = self.start.to_display_point(map, app).unwrap();
        let end = self.end.to_display_point(map, app).unwrap();
        if self.reversed {
            end..start
        } else {
            start..end
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{editor::Point, settings, test::sample_text};
    use anyhow::Error;
    use unindent::Unindent;

    #[test]
    fn test_selection_with_mouse() {
        App::test((), |mut app| async move {
            let buffer = app.add_model(|_| Buffer::new(0, "aaaaaa\nbbbbbb\ncccccc\ndddddd\n"));
            let settings = settings::channel(&app.font_cache()).unwrap().1;
            let (_, buffer_view) =
                app.add_window(|ctx| BufferView::for_buffer(buffer, settings, ctx));

            buffer_view.update(&mut app, |view, ctx| {
                view.begin_selection(DisplayPoint::new(2, 2), false, ctx);
            });

            buffer_view.read(&app, |view, app| {
                let selections = view
                    .selections_in_range(DisplayPoint::zero()..view.max_point(app), app)
                    .collect::<Vec<_>>();
                assert_eq!(
                    selections,
                    [DisplayPoint::new(2, 2)..DisplayPoint::new(2, 2)]
                );
            });

            buffer_view.update(&mut app, |view, ctx| {
                view.update_selection(DisplayPoint::new(3, 3), Vector2F::zero(), ctx);
            });

            buffer_view.read(&app, |view, app| {
                let selections = view
                    .selections_in_range(DisplayPoint::zero()..view.max_point(app), app)
                    .collect::<Vec<_>>();
                assert_eq!(
                    selections,
                    [DisplayPoint::new(2, 2)..DisplayPoint::new(3, 3)]
                );
            });

            buffer_view.update(&mut app, |view, ctx| {
                view.update_selection(DisplayPoint::new(1, 1), Vector2F::zero(), ctx);
            });

            buffer_view.read(&app, |view, app| {
                let selections = view
                    .selections_in_range(DisplayPoint::zero()..view.max_point(app), app)
                    .collect::<Vec<_>>();
                assert_eq!(
                    selections,
                    [DisplayPoint::new(2, 2)..DisplayPoint::new(1, 1)]
                );
            });

            buffer_view.update(&mut app, |view, ctx| {
                view.end_selection(ctx);
                view.update_selection(DisplayPoint::new(3, 3), Vector2F::zero(), ctx);
            });

            buffer_view.read(&app, |view, app| {
                let selections = view
                    .selections_in_range(DisplayPoint::zero()..view.max_point(app), app)
                    .collect::<Vec<_>>();
                assert_eq!(
                    selections,
                    [DisplayPoint::new(2, 2)..DisplayPoint::new(1, 1)]
                );
            });

            buffer_view.update(&mut app, |view, ctx| {
                view.begin_selection(DisplayPoint::new(3, 3), true, ctx);
                view.update_selection(DisplayPoint::new(0, 0), Vector2F::zero(), ctx);
            });

            buffer_view.read(&app, |view, app| {
                let selections = view
                    .selections_in_range(DisplayPoint::zero()..view.max_point(app), app)
                    .collect::<Vec<_>>();
                assert_eq!(
                    selections,
                    [
                        DisplayPoint::new(2, 2)..DisplayPoint::new(1, 1),
                        DisplayPoint::new(3, 3)..DisplayPoint::new(0, 0)
                    ]
                );
            });

            buffer_view.update(&mut app, |view, ctx| {
                view.end_selection(ctx);
            });

            buffer_view.read(&app, |view, app| {
                let selections = view
                    .selections_in_range(DisplayPoint::zero()..view.max_point(app), app)
                    .collect::<Vec<_>>();
                assert_eq!(
                    selections,
                    [DisplayPoint::new(3, 3)..DisplayPoint::new(0, 0)]
                );
            });
        });
    }

    #[test]
    fn test_layout_line_numbers() -> Result<()> {
        App::test((), |mut app| async move {
            let layout_cache = TextLayoutCache::new(app.platform().fonts());
            let font_cache = app.font_cache();

            let buffer = app.add_model(|_| Buffer::new(0, sample_text(6, 6)));

            let settings = settings::channel(&font_cache).unwrap().1;
            let (_, view) =
                app.add_window(|ctx| BufferView::for_buffer(buffer.clone(), settings, ctx));

            view.read(&app, |view, app| {
                let layouts = view.layout_line_numbers(1000.0, &font_cache, &layout_cache, app)?;
                assert_eq!(layouts.len(), 6);
                Result::<()>::Ok(())
            })?;

            Ok(())
        })
    }

    #[test]
    fn test_fold() -> Result<()> {
        App::test((), |mut app| async move {
            let buffer = app.add_model(|_| {
                Buffer::new(
                    0,
                    "
                    impl Foo {
                        // Hello!

                        fn a() {
                            1
                        }

                        fn b() {
                            2
                        }

                        fn c() {
                            3
                        }
                    }
                "
                    .unindent(),
                )
            });
            let settings = settings::channel(&app.font_cache()).unwrap().1;
            let (_, view) =
                app.add_window(|ctx| BufferView::for_buffer(buffer.clone(), settings, ctx));

            view.update(&mut app, |view, ctx| {
                view.select_ranges(&[DisplayPoint::new(8, 0)..DisplayPoint::new(12, 0)], ctx)?;
                view.fold(&(), ctx);
                assert_eq!(
                    view.text(ctx.app()),
                    "
                    impl Foo {
                        // Hello!

                        fn a() {
                            1
                        }

                        fn b() {…
                        }

                        fn c() {…
                        }
                    }
                "
                    .unindent(),
                );

                view.fold(&(), ctx);
                assert_eq!(
                    view.text(ctx.app()),
                    "
                    impl Foo {…
                    }
                "
                    .unindent(),
                );

                view.unfold(&(), ctx);
                assert_eq!(
                    view.text(ctx.app()),
                    "
                    impl Foo {
                        // Hello!

                        fn a() {
                            1
                        }

                        fn b() {…
                        }

                        fn c() {…
                        }
                    }
                "
                    .unindent(),
                );

                view.unfold(&(), ctx);
                assert_eq!(view.text(ctx.app()), buffer.as_ref(ctx).text());

                Ok::<(), Error>(())
            })?;

            Ok(())
        })
    }

    #[test]
    fn test_move_cursor() -> Result<()> {
        App::test((), |mut app| async move {
            let buffer = app.add_model(|_| Buffer::new(0, sample_text(6, 6)));
            let settings = settings::channel(&app.font_cache()).unwrap().1;
            let (_, view) =
                app.add_window(|ctx| BufferView::for_buffer(buffer.clone(), settings, ctx));

            buffer.update(&mut app, |buffer, ctx| {
                buffer.edit(
                    vec![
                        Point::new(1, 0)..Point::new(1, 0),
                        Point::new(1, 1)..Point::new(1, 1),
                    ],
                    "\t",
                    Some(ctx),
                )
            })?;

            view.update(&mut app, |view, ctx| {
                view.move_down(&(), ctx);
                assert_eq!(
                    view.selections(ctx.app()),
                    &[DisplayPoint::new(1, 0)..DisplayPoint::new(1, 0)]
                );
                view.move_right(&(), ctx);
                assert_eq!(
                    view.selections(ctx.app()),
                    &[DisplayPoint::new(1, 4)..DisplayPoint::new(1, 4)]
                );
                Ok::<(), Error>(())
            })?;

            Ok(())
        })
    }

    #[test]
    fn test_backspace() -> Result<()> {
        App::test((), |mut app| async move {
            let buffer = app.add_model(|_| {
                Buffer::new(0, "one two three\nfour five six\nseven eight nine\nten\n")
            });
            let settings = settings::channel(&app.font_cache()).unwrap().1;
            let (_, view) =
                app.add_window(|ctx| BufferView::for_buffer(buffer.clone(), settings, ctx));

            view.update(&mut app, |view, ctx| -> Result<()> {
                view.select_ranges(
                    &[
                        // an empty selection - the preceding character is deleted
                        DisplayPoint::new(0, 2)..DisplayPoint::new(0, 2),
                        // one character selected - it is deleted
                        DisplayPoint::new(1, 3)..DisplayPoint::new(1, 4),
                        // a line suffix selected - it is deleted
                        DisplayPoint::new(2, 6)..DisplayPoint::new(3, 0),
                    ],
                    ctx,
                )?;
                view.backspace(&(), ctx);
                Ok(())
            })?;

            buffer.read(&mut app, |buffer, _| -> Result<()> {
                assert_eq!(buffer.text(), "oe two three\nfou five six\nseven ten\n");
                Ok(())
            })?;

            Ok(())
        })
    }

    impl BufferView {
        fn selections(&self, app: &AppContext) -> Vec<Range<DisplayPoint>> {
            self.selections_in_range(DisplayPoint::zero()..self.max_point(app), app)
                .collect::<Vec<_>>()
        }
    }
}