use super::{
    buffer, movement, Anchor, Bias, Buffer, BufferElement, DisplayMap, DisplayPoint, Point,
    Selection, SelectionSetId, 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, AppContext, ClipboardItem,
    Element, ElementBox, Entity, FontCache, ModelHandle, MutableAppContext, View, ViewContext,
    WeakViewHandle,
};
use gpui::{geometry::vector::Vector2F, TextLayoutCache};
use parking_lot::Mutex;
use serde::{Deserialize, Serialize};
use smallvec::SmallVec;
use smol::Timer;
use std::{
    cmp::{self, Ordering},
    fmt::Write,
    iter::FromIterator,
    ops::Range,
    path::Path,
    sync::Arc,
    time::Duration,
};

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

pub fn init(app: &mut MutableAppContext) {
    app.add_bindings(vec![
        Binding::new("backspace", "buffer:backspace", Some("BufferView")),
        Binding::new("enter", "buffer:newline", Some("BufferView")),
        Binding::new("cmd-x", "buffer:cut", Some("BufferView")),
        Binding::new("cmd-c", "buffer:copy", Some("BufferView")),
        Binding::new("cmd-v", "buffer:paste", 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:cut", BufferView::cut);
    app.add_action("buffer:copy", BufferView::copy);
    app.add_action("buffer:paste", BufferView::paste);
    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>,
    selection_set_id: SelectionSetId,
    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,
}

#[derive(Serialize, Deserialize)]
struct ClipboardSelection {
    len: usize,
    is_entire_line: bool,
}

impl BufferView {
    pub fn single_line(settings: watch::Receiver<Settings>, ctx: &mut ViewContext<Self>) -> Self {
        let buffer = ctx.add_model(|ctx| Buffer::new(0, String::new(), ctx));
        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 (selection_set_id, _) = buffer.update(ctx, |buffer, ctx| {
            buffer.add_selection_set(
                vec![Selection {
                    start: buffer.anchor_before(0).unwrap(),
                    end: buffer.anchor_before(0).unwrap(),
                    reversed: false,
                    goal_column: None,
                }],
                Some(ctx),
            )
        });
        Self {
            handle: ctx.handle().downgrade(),
            buffer,
            display_map,
            selection_set_id,
            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.read(app);
        let visible_lines = viewport_height / line_height;
        let first_cursor_top = self
            .selections(app)
            .first()
            .unwrap()
            .head()
            .to_display_point(map, app)
            .unwrap()
            .row() as f32;
        let last_cursor_bottom = self
            .selections(app)
            .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.read(app);

        let mut target_left = std::f32::INFINITY;
        let mut target_right = 0.0_f32;
        for selection in self.selections(app) {
            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.read(ctx);
        let cursor = display_map
            .anchor_before(position, Bias::Left, ctx.as_ref())
            .unwrap();
        let selection = Selection {
            start: cursor.clone(),
            end: cursor,
            reversed: false,
            goal_column: None,
        };

        if !add {
            self.update_selections(Vec::new(), ctx);
        }
        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.read(ctx);
        let map = self.display_map.read(ctx);
        let cursor = map
            .anchor_before(position, Bias::Left, ctx.as_ref())
            .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.as_ref());
            let mut selections = self.selections(ctx.as_ref()).to_vec();
            selections.insert(ix, selection);
            self.update_selections(selections, ctx);
        } 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<usize>>,
    {
        let buffer = self.buffer.read(ctx);
        let mut selections = Vec::new();
        for range in ranges {
            selections.push(Selection {
                start: buffer.anchor_before(range.start)?,
                end: buffer.anchor_before(range.end)?,
                reversed: false,
                goal_column: None,
            });
        }
        self.update_selections(selections, ctx);
        Ok(())
    }

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

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

        self.start_transaction(ctx);
        let mut new_selections = Vec::new();
        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 char_count = text.chars().count() as isize;
            let mut delta = 0_isize;
            new_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.update_selections(new_selections, ctx);
        self.end_transaction(ctx);
    }

    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>) {
        self.start_transaction(ctx);
        let mut selections = self.selections(ctx.as_ref()).to_vec();
        {
            let buffer = self.buffer.read(ctx);
            let map = self.display_map.read(ctx);
            for selection in &mut selections {
                if selection.range(buffer).is_empty() {
                    let head = selection
                        .head()
                        .to_display_point(map, ctx.as_ref())
                        .unwrap();
                    let cursor = map
                        .anchor_before(
                            movement::left(map, head, ctx.as_ref()).unwrap(),
                            Bias::Left,
                            ctx.as_ref(),
                        )
                        .unwrap();
                    selection.set_head(&buffer, cursor);
                    selection.goal_column = None;
                }
            }
        }

        self.update_selections(selections, ctx);
        self.changed_selections(ctx);
        self.insert(&String::new(), ctx);
        self.end_transaction(ctx);
    }

    pub fn cut(&mut self, _: &(), ctx: &mut ViewContext<Self>) {
        self.start_transaction(ctx);
        let mut text = String::new();
        let mut selections = self.selections(ctx.as_ref()).to_vec();
        let mut clipboard_selections = Vec::with_capacity(selections.len());
        {
            let buffer = self.buffer.read(ctx);
            let max_point = buffer.max_point();
            for selection in &mut selections {
                let mut start = selection.start.to_point(buffer).expect("invalid start");
                let mut end = selection.end.to_point(buffer).expect("invalid end");
                let is_entire_line = start == end;
                if is_entire_line {
                    start = Point::new(start.row, 0);
                    end = cmp::min(max_point, Point::new(start.row + 1, 0));
                    selection.start = buffer.anchor_before(start).unwrap();
                    selection.end = buffer.anchor_before(end).unwrap();
                }
                let mut len = 0;
                for ch in buffer.text_for_range(start..end).unwrap() {
                    text.push(ch);
                    len += 1;
                }
                clipboard_selections.push(ClipboardSelection {
                    len,
                    is_entire_line,
                });
            }
        }
        self.update_selections(selections, ctx);
        self.changed_selections(ctx);
        self.insert(&String::new(), ctx);
        self.end_transaction(ctx);

        ctx.as_mut()
            .write_to_clipboard(ClipboardItem::new(text).with_metadata(clipboard_selections));
    }

    pub fn copy(&mut self, _: &(), ctx: &mut ViewContext<Self>) {
        let buffer = self.buffer.read(ctx);
        let max_point = buffer.max_point();
        let mut text = String::new();
        let selections = self.selections(ctx.as_ref());
        let mut clipboard_selections = Vec::with_capacity(selections.len());
        for selection in selections {
            let mut start = selection.start.to_point(buffer).expect("invalid start");
            let mut end = selection.end.to_point(buffer).expect("invalid end");
            let is_entire_line = start == end;
            if is_entire_line {
                start = Point::new(start.row, 0);
                end = cmp::min(max_point, Point::new(start.row + 1, 0));
            }
            let mut len = 0;
            for ch in buffer.text_for_range(start..end).unwrap() {
                text.push(ch);
                len += 1;
            }
            clipboard_selections.push(ClipboardSelection {
                len,
                is_entire_line,
            });
        }

        ctx.as_mut()
            .write_to_clipboard(ClipboardItem::new(text).with_metadata(clipboard_selections));
    }

    pub fn paste(&mut self, _: &(), ctx: &mut ViewContext<Self>) {
        if let Some(item) = ctx.as_mut().read_from_clipboard() {
            let clipboard_text = item.text();
            if let Some(mut clipboard_selections) = item.metadata::<Vec<ClipboardSelection>>() {
                let selections = self.selections(ctx.as_ref()).to_vec();
                if clipboard_selections.len() != selections.len() {
                    let merged_selection = ClipboardSelection {
                        len: clipboard_selections.iter().map(|s| s.len).sum(),
                        is_entire_line: clipboard_selections.iter().all(|s| s.is_entire_line),
                    };
                    clipboard_selections.clear();
                    clipboard_selections.push(merged_selection);
                }

                self.start_transaction(ctx);
                let mut new_selections = Vec::with_capacity(selections.len());
                let mut clipboard_chars = clipboard_text.chars().cycle();
                for (selection, clipboard_selection) in
                    selections.iter().zip(clipboard_selections.iter().cycle())
                {
                    let to_insert =
                        String::from_iter(clipboard_chars.by_ref().take(clipboard_selection.len));

                    self.buffer.update(ctx, |buffer, ctx| {
                        let selection_start = selection.start.to_point(buffer).unwrap();
                        let selection_end = selection.end.to_point(buffer).unwrap();

                        // If the corresponding selection was empty when this slice of the
                        // clipboard text was written, then the entire line containing the
                        // selection was copied. If this selection is also currently empty,
                        // then paste the line before the current line of the buffer.
                        let new_selection_start = selection.end.bias_right(buffer).unwrap();
                        if selection_start == selection_end && clipboard_selection.is_entire_line {
                            let line_start = Point::new(selection_start.row, 0);
                            buffer
                                .edit(Some(line_start..line_start), to_insert, Some(ctx))
                                .unwrap();
                        } else {
                            buffer
                                .edit(Some(&selection.start..&selection.end), to_insert, Some(ctx))
                                .unwrap();
                        };

                        let new_selection_start = new_selection_start.bias_left(buffer).unwrap();
                        new_selections.push(Selection {
                            start: new_selection_start.clone(),
                            end: new_selection_start,
                            reversed: false,
                            goal_column: None,
                        });
                    });
                }
                self.update_selections(new_selections, ctx);
                self.end_transaction(ctx);
            } else {
                self.insert(clipboard_text, 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.as_ref();
        let mut selections = self.selections(app).to_vec();
        {
            let map = self.display_map.read(app);
            for selection in &mut 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.update_selections(selections, ctx);
        self.changed_selections(ctx);
    }

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

    pub fn move_right(&mut self, _: &(), ctx: &mut ViewContext<Self>) {
        let mut selections = self.selections(ctx.as_ref()).to_vec();
        {
            let app = ctx.as_ref();
            let map = self.display_map.read(app);
            for selection in &mut 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.update_selections(selections, ctx);
        self.changed_selections(ctx);
    }

    pub fn select_right(&mut self, _: &(), ctx: &mut ViewContext<Self>) {
        let mut selections = self.selections(ctx.as_ref()).to_vec();
        {
            let app = ctx.as_ref();
            let buffer = self.buffer.read(app);
            let map = self.display_map.read(app);
            for selection in &mut selections {
                let head = selection
                    .head()
                    .to_display_point(map, ctx.as_ref())
                    .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.update_selections(selections, ctx);
        self.changed_selections(ctx);
    }

    pub fn move_up(&mut self, _: &(), ctx: &mut ViewContext<Self>) {
        if self.single_line {
            ctx.propagate_action();
        } else {
            let mut selections = self.selections(ctx.as_ref()).to_vec();
            {
                let app = ctx.as_ref();
                let map = self.display_map.read(app);
                for selection in &mut 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.update_selections(selections, ctx);
            self.changed_selections(ctx);
        }
    }

    pub fn select_up(&mut self, _: &(), ctx: &mut ViewContext<Self>) {
        if self.single_line {
            ctx.propagate_action();
        } else {
            let mut selections = self.selections(ctx.as_ref()).to_vec();
            {
                let app = ctx.as_ref();
                let buffer = self.buffer.read(app);
                let map = self.display_map.read(app);
                for selection in &mut 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.update_selections(selections, ctx);
            self.changed_selections(ctx);
        }
    }

    pub fn move_down(&mut self, _: &(), ctx: &mut ViewContext<Self>) {
        if self.single_line {
            ctx.propagate_action();
        } else {
            let mut selections = self.selections(ctx.as_ref()).to_vec();
            {
                let app = ctx.as_ref();
                let map = self.display_map.read(app);
                for selection in &mut 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.update_selections(selections, ctx);
            self.changed_selections(ctx);
        }
    }

    pub fn select_down(&mut self, _: &(), ctx: &mut ViewContext<Self>) {
        if self.single_line {
            ctx.propagate_action();
        } else {
            let mut selections = self.selections(ctx.as_ref()).to_vec();
            {
                let app = ctx.as_ref();
                let buffer = self.buffer.read(app);
                let map = self.display_map.read(app);
                for selection in &mut 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.update_selections(selections, ctx);
            self.changed_selections(ctx);
        }
    }

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

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

    pub fn last_selection(&self, app: &AppContext) -> Range<DisplayPoint> {
        self.selections(app)
            .last()
            .unwrap()
            .display_range(self.display_map.read(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.read(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(app)[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.read(app);
        let selections = self.selections(app);
        match selections.binary_search_by(|probe| probe.start.cmp(&start, buffer).unwrap()) {
            Ok(index) => index,
            Err(index) => {
                if index > 0
                    && selections[index - 1].end.cmp(&start, buffer).unwrap() == Ordering::Greater
                {
                    index - 1
                } else {
                    index
                }
            }
        }
    }

    fn selections<'a>(&self, app: &'a AppContext) -> &'a [Selection] {
        self.buffer
            .read(app)
            .selections(self.selection_set_id)
            .unwrap()
    }

    fn update_selections(&self, mut selections: Vec<Selection>, ctx: &mut ViewContext<Self>) {
        // Merge overlapping selections.
        let buffer = self.buffer.read(ctx);
        let mut i = 1;
        while i < selections.len() {
            if selections[i - 1]
                .end
                .cmp(&selections[i].start, buffer)
                .unwrap()
                >= Ordering::Equal
            {
                let removed = selections.remove(i);
                if removed.start.cmp(&selections[i - 1].start, buffer).unwrap() < Ordering::Equal {
                    selections[i - 1].start = removed.start;
                }
                if removed.end.cmp(&selections[i - 1].end, buffer).unwrap() > Ordering::Equal {
                    selections[i - 1].end = removed.end;
                }
            } else {
                i += 1;
            }
        }

        self.buffer.update(ctx, |buffer, ctx| {
            buffer
                .update_selection_set(self.selection_set_id, selections, Some(ctx))
                .unwrap()
        });
    }

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

    fn end_transaction(&self, ctx: &mut ViewContext<Self>) {
        self.buffer.update(ctx, |buffer, ctx| {
            buffer
                .end_transaction(Some(self.selection_set_id), Some(ctx))
                .unwrap()
        });
    }

    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.as_ref();
        let map = self.display_map.read(app);
        for selection in self.selections(app) {
            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.as_ref();
        let map = self.display_map.read(app);
        let buffer = self.buffer.read(app);
        let ranges = self
            .selections(app)
            .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
            .read(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.read(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.read(ctx);
            let ranges = self
                .selections(ctx.as_ref())
                .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.read(app).line(display_row, app)
    }

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

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

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

    pub fn text(&self, app: &AppContext) -> String {
        self.display_map.read(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.read(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.read(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.read(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),
            buffer::Event::FileHandleChanged => ctx.emit(Event::FileHandleChanged),
        }
    }
}

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

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 | Event::FileHandleChanged
        )
    }

    fn title(&self, app: &AppContext) -> std::string::String {
        if let Some(path) = self.buffer.read(app).path() {
            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, Arc<Path>)> {
        self.buffer.read(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.read(ctx).is_dirty()
    }
}

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

    #[test]
    fn test_selection_with_mouse() {
        App::test((), |app| {
            let buffer =
                app.add_model(|ctx| Buffer::new(0, "aaaaaa\nbbbbbb\ncccccc\ndddddd\n", ctx));
            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(app, |view, ctx| {
                view.begin_selection(DisplayPoint::new(2, 2), false, ctx);
            });

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

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

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

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

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

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

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

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

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

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

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

    #[test]
    fn test_layout_line_numbers() {
        App::test((), |app| {
            let layout_cache = TextLayoutCache::new(app.platform().fonts());
            let font_cache = app.font_cache().clone();

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

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

            let layouts = view
                .read(app)
                .layout_line_numbers(1000.0, &font_cache, &layout_cache, app.as_ref())
                .unwrap();
            assert_eq!(layouts.len(), 6);
        })
    }

    #[test]
    fn test_fold() {
        App::test((), |app| {
            let buffer = app.add_model(|ctx| {
                Buffer::new(
                    0,
                    "
                    impl Foo {
                        // Hello!

                        fn a() {
                            1
                        }

                        fn b() {
                            2
                        }

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

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

                        fn a() {
                            1
                        }

                        fn b() {…
                        }

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

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

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

                        fn a() {
                            1
                        }

                        fn b() {…
                        }

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

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

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

            buffer.update(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(app, |view, ctx| {
                view.move_down(&(), ctx);
                assert_eq!(
                    view.selection_ranges(ctx.as_ref()),
                    &[DisplayPoint::new(1, 0)..DisplayPoint::new(1, 0)]
                );
                view.move_right(&(), ctx);
                assert_eq!(
                    view.selection_ranges(ctx.as_ref()),
                    &[DisplayPoint::new(1, 4)..DisplayPoint::new(1, 4)]
                );
                Ok::<(), Error>(())
            })?;

            Ok(())
        })
    }

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

            view.update(app, |view, ctx| {
                view.select_display_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,
                )
                .unwrap();
                view.backspace(&(), ctx);
            });

            assert_eq!(
                buffer.read(app).text(),
                "oe two three\nfou five six\nseven ten\n"
            );
        })
    }

    #[test]
    fn test_clipboard() {
        App::test((), |app| {
            let buffer = app.add_model(|ctx| Buffer::new(0, "one two three four five six ", ctx));
            let settings = settings::channel(&app.font_cache()).unwrap().1;
            let view = app
                .add_window(|ctx| BufferView::for_buffer(buffer.clone(), settings, ctx))
                .1;

            // Cut with three selections. Clipboard text is divided into three slices.
            view.update(app, |view, ctx| {
                view.select_ranges(&[0..4, 8..14, 19..24], ctx).unwrap();
                view.cut(&(), ctx);
            });
            assert_eq!(view.read(app).text(app.as_ref()), "two four six ");

            // Paste with three cursors. Each cursor pastes one slice of the clipboard text.
            view.update(app, |view, ctx| {
                view.select_ranges(&[4..4, 9..9, 13..13], ctx).unwrap();
                view.paste(&(), ctx);
            });
            assert_eq!(
                view.read(app).text(app.as_ref()),
                "two one four three six five "
            );
            assert_eq!(
                view.read(app).selection_ranges(app.as_ref()),
                &[
                    DisplayPoint::new(0, 8)..DisplayPoint::new(0, 8),
                    DisplayPoint::new(0, 19)..DisplayPoint::new(0, 19),
                    DisplayPoint::new(0, 28)..DisplayPoint::new(0, 28)
                ]
            );

            // Paste again but with only two cursors. Since the number of cursors doesn't
            // match the number of slices in the clipboard, the entire clipboard text
            // is pasted at each cursor.
            view.update(app, |view, ctx| {
                view.select_ranges(&[0..0, 28..28], ctx).unwrap();
                view.insert(&"( ".to_string(), ctx);
                view.paste(&(), ctx);
                view.insert(&") ".to_string(), ctx);
            });
            assert_eq!(
                view.read(app).text(app.as_ref()),
                "( one three five ) two one four three six five ( one three five ) "
            );

            view.update(app, |view, ctx| {
                view.select_ranges(&[0..0], ctx).unwrap();
                view.insert(&"123\n4567\n89\n".to_string(), ctx);
            });
            assert_eq!(
                view.read(app).text(app.as_ref()),
                "123\n4567\n89\n( one three five ) two one four three six five ( one three five ) "
            );

            // Cut with three selections, one of which is full-line.
            view.update(app, |view, ctx| {
                view.select_display_ranges(
                    &[
                        DisplayPoint::new(0, 1)..DisplayPoint::new(0, 2),
                        DisplayPoint::new(1, 1)..DisplayPoint::new(1, 1),
                        DisplayPoint::new(2, 0)..DisplayPoint::new(2, 1),
                    ],
                    ctx,
                )
                .unwrap();
                view.cut(&(), ctx);
            });
            assert_eq!(
                view.read(app).text(app.as_ref()),
                "13\n9\n( one three five ) two one four three six five ( one three five ) "
            );

            // Paste with three selections, noticing how the copied selection that was full-line
            // gets inserted before the second cursor.
            view.update(app, |view, ctx| {
                view.select_display_ranges(
                    &[
                        DisplayPoint::new(0, 1)..DisplayPoint::new(0, 1),
                        DisplayPoint::new(1, 1)..DisplayPoint::new(1, 1),
                        DisplayPoint::new(2, 2)..DisplayPoint::new(2, 3),
                    ],
                    ctx,
                )
                .unwrap();
                view.paste(&(), ctx);
            });
            assert_eq!(
                view.read(app).text(app.as_ref()),
                "123\n4567\n9\n( 8ne three five ) two one four three six five ( one three five ) "
            );
            assert_eq!(
                view.read(app).selection_ranges(app.as_ref()),
                &[
                    DisplayPoint::new(0, 2)..DisplayPoint::new(0, 2),
                    DisplayPoint::new(2, 1)..DisplayPoint::new(2, 1),
                    DisplayPoint::new(3, 3)..DisplayPoint::new(3, 3),
                ]
            );

            // Copy with a single cursor only, which writes the whole line into the clipboard.
            view.update(app, |view, ctx| {
                view.select_display_ranges(
                    &[DisplayPoint::new(0, 1)..DisplayPoint::new(0, 1)],
                    ctx,
                )
                .unwrap();
                view.copy(&(), ctx);
            });

            // Paste with three selections, noticing how the copied full-line selection is inserted
            // before the empty selections but replaces the selection that is non-empty.
            view.update(app, |view, ctx| {
                view.select_display_ranges(
                    &[
                        DisplayPoint::new(0, 1)..DisplayPoint::new(0, 1),
                        DisplayPoint::new(1, 0)..DisplayPoint::new(1, 2),
                        DisplayPoint::new(2, 1)..DisplayPoint::new(2, 1),
                    ],
                    ctx,
                )
                .unwrap();
                view.paste(&(), ctx);
            });
            assert_eq!(
                view.read(app).text(app.as_ref()),
                "123\n123\n123\n67\n123\n9\n( 8ne three five ) two one four three six five ( one three five ) "
            );
            assert_eq!(
                view.read(app).selection_ranges(app.as_ref()),
                &[
                    DisplayPoint::new(1, 1)..DisplayPoint::new(1, 1),
                    DisplayPoint::new(3, 0)..DisplayPoint::new(3, 0),
                    DisplayPoint::new(5, 1)..DisplayPoint::new(5, 1),
                ]
            );
        });
    }

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