use std::{borrow::Cow, cmp};

use editor::{
    display_map::ToDisplayPoint, movement, scroll::autoscroll::Autoscroll, ClipboardSelection,
    DisplayPoint,
};
use gpui::{impl_actions, ViewContext};
use language::{Bias, SelectionGoal};
use serde::Deserialize;
use workspace::Workspace;

use crate::{state::Mode, utils::copy_selections_content, Vim};

#[derive(Clone, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
struct Paste {
    #[serde(default)]
    before: bool,
    #[serde(default)]
    preserve_clipboard: bool,
}

impl_actions!(vim, [Paste]);

pub(crate) fn register(workspace: &mut Workspace, _: &mut ViewContext<Workspace>) {
    workspace.register_action(paste);
}

fn paste(_: &mut Workspace, action: &Paste, cx: &mut ViewContext<Workspace>) {
    Vim::update(cx, |vim, cx| {
        vim.record_current_action(cx);
        vim.update_active_editor(cx, |editor, cx| {
            let text_layout_details = editor.text_layout_details(cx);
            editor.transact(cx, |editor, cx| {
                editor.set_clip_at_line_ends(false, cx);

                let Some(item) = cx.read_from_clipboard() else {
                    return;
                };
                let clipboard_text = Cow::Borrowed(item.text());
                if clipboard_text.is_empty() {
                    return;
                }

                if !action.preserve_clipboard && vim.state().mode.is_visual() {
                    copy_selections_content(editor, vim.state().mode == Mode::VisualLine, cx);
                }

                // if we are copying from multi-cursor (of visual block mode), we want
                // to
                let clipboard_selections =
                    item.metadata::<Vec<ClipboardSelection>>()
                        .filter(|clipboard_selections| {
                            clipboard_selections.len() > 1 && vim.state().mode != Mode::VisualLine
                        });

                let (display_map, current_selections) = editor.selections.all_adjusted_display(cx);

                // unlike zed, if you have a multi-cursor selection from vim block mode,
                // pasting it will paste it on subsequent lines, even if you don't yet
                // have a cursor there.
                let mut selections_to_process = Vec::new();
                let mut i = 0;
                while i < current_selections.len() {
                    selections_to_process
                        .push((current_selections[i].start..current_selections[i].end, true));
                    i += 1;
                }
                if let Some(clipboard_selections) = clipboard_selections.as_ref() {
                    let left = current_selections
                        .iter()
                        .map(|selection| cmp::min(selection.start.column(), selection.end.column()))
                        .min()
                        .unwrap();
                    let mut row = current_selections.last().unwrap().end.row() + 1;
                    while i < clipboard_selections.len() {
                        let cursor =
                            display_map.clip_point(DisplayPoint::new(row, left), Bias::Left);
                        selections_to_process.push((cursor..cursor, false));
                        i += 1;
                        row += 1;
                    }
                }

                let first_selection_indent_column =
                    clipboard_selections.as_ref().and_then(|zed_selections| {
                        zed_selections
                            .first()
                            .map(|selection| selection.first_line_indent)
                    });
                let before = action.before || vim.state().mode == Mode::VisualLine;

                let mut edits = Vec::new();
                let mut new_selections = Vec::new();
                let mut original_indent_columns = Vec::new();
                let mut start_offset = 0;

                for (ix, (selection, preserve)) in selections_to_process.iter().enumerate() {
                    let (mut to_insert, original_indent_column) =
                        if let Some(clipboard_selections) = &clipboard_selections {
                            if let Some(clipboard_selection) = clipboard_selections.get(ix) {
                                let end_offset = start_offset + clipboard_selection.len;
                                let text = clipboard_text[start_offset..end_offset].to_string();
                                start_offset = end_offset + 1;
                                (text, Some(clipboard_selection.first_line_indent))
                            } else {
                                ("".to_string(), first_selection_indent_column)
                            }
                        } else {
                            (clipboard_text.to_string(), first_selection_indent_column)
                        };
                    let line_mode = to_insert.ends_with("\n");
                    let is_multiline = to_insert.contains("\n");

                    if line_mode && !before {
                        if selection.is_empty() {
                            to_insert =
                                "\n".to_owned() + &to_insert[..to_insert.len() - "\n".len()];
                        } else {
                            to_insert = "\n".to_owned() + &to_insert;
                        }
                    } else if !line_mode && vim.state().mode == Mode::VisualLine {
                        to_insert = to_insert + "\n";
                    }

                    let display_range = if !selection.is_empty() {
                        selection.start..selection.end
                    } else if line_mode {
                        let point = if before {
                            movement::line_beginning(&display_map, selection.start, false)
                        } else {
                            movement::line_end(&display_map, selection.start, false)
                        };
                        point..point
                    } else {
                        let point = if before {
                            selection.start
                        } else {
                            movement::saturating_right(&display_map, selection.start)
                        };
                        point..point
                    };

                    let point_range = display_range.start.to_point(&display_map)
                        ..display_range.end.to_point(&display_map);
                    let anchor = if is_multiline || vim.state().mode == Mode::VisualLine {
                        display_map.buffer_snapshot.anchor_before(point_range.start)
                    } else {
                        display_map.buffer_snapshot.anchor_after(point_range.end)
                    };

                    if *preserve {
                        new_selections.push((anchor, line_mode, is_multiline));
                    }
                    edits.push((point_range, to_insert));
                    original_indent_columns.extend(original_indent_column);
                }

                editor.edit_with_block_indent(edits, original_indent_columns, cx);

                // in line_mode vim will insert the new text on the next (or previous if before) line
                // and put the cursor on the first non-blank character of the first inserted line (or at the end if the first line is blank).
                // otherwise vim will insert the next text at (or before) the current cursor position,
                // the cursor will go to the last (or first, if is_multiline) inserted character.
                editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
                    s.replace_cursors_with(|map| {
                        let mut cursors = Vec::new();
                        for (anchor, line_mode, is_multiline) in &new_selections {
                            let mut cursor = anchor.to_display_point(map);
                            if *line_mode {
                                if !before {
                                    cursor = movement::down(
                                        map,
                                        cursor,
                                        SelectionGoal::None,
                                        false,
                                        &text_layout_details,
                                    )
                                    .0;
                                }
                                cursor = movement::indented_line_beginning(map, cursor, true);
                            } else if !is_multiline {
                                cursor = movement::saturating_left(map, cursor)
                            }
                            cursors.push(cursor);
                            if vim.state().mode == Mode::VisualBlock {
                                break;
                            }
                        }

                        cursors
                    });
                })
            });
        });
        vim.switch_mode(Mode::Normal, true, cx);
    });
}

// #[cfg(test)]
// mod test {
//     use crate::{
//         state::Mode,
//         test::{NeovimBackedTestContext, VimTestContext},
//     };
//     use indoc::indoc;

//     #[gpui::test]
//     async fn test_paste(cx: &mut gpui::TestAppContext) {
//         let mut cx = NeovimBackedTestContext::new(cx).await;

//         // single line
//         cx.set_shared_state(indoc! {"
//             The quick brown
//             fox ˇjumps over
//             the lazy dog"})
//             .await;
//         cx.simulate_shared_keystrokes(["v", "w", "y"]).await;
//         cx.assert_shared_clipboard("jumps o").await;
//         cx.set_shared_state(indoc! {"
//             The quick brown
//             fox jumps oveˇr
//             the lazy dog"})
//             .await;
//         cx.simulate_shared_keystroke("p").await;
//         cx.assert_shared_state(indoc! {"
//             The quick brown
//             fox jumps overjumps ˇo
//             the lazy dog"})
//             .await;

//         cx.set_shared_state(indoc! {"
//             The quick brown
//             fox jumps oveˇr
//             the lazy dog"})
//             .await;
//         cx.simulate_shared_keystroke("shift-p").await;
//         cx.assert_shared_state(indoc! {"
//             The quick brown
//             fox jumps ovejumps ˇor
//             the lazy dog"})
//             .await;

//         // line mode
//         cx.set_shared_state(indoc! {"
//             The quick brown
//             fox juˇmps over
//             the lazy dog"})
//             .await;
//         cx.simulate_shared_keystrokes(["d", "d"]).await;
//         cx.assert_shared_clipboard("fox jumps over\n").await;
//         cx.assert_shared_state(indoc! {"
//             The quick brown
//             the laˇzy dog"})
//             .await;
//         cx.simulate_shared_keystroke("p").await;
//         cx.assert_shared_state(indoc! {"
//             The quick brown
//             the lazy dog
//             ˇfox jumps over"})
//             .await;
//         cx.simulate_shared_keystrokes(["k", "shift-p"]).await;
//         cx.assert_shared_state(indoc! {"
//             The quick brown
//             ˇfox jumps over
//             the lazy dog
//             fox jumps over"})
//             .await;

//         // multiline, cursor to first character of pasted text.
//         cx.set_shared_state(indoc! {"
//             The quick brown
//             fox jumps ˇover
//             the lazy dog"})
//             .await;
//         cx.simulate_shared_keystrokes(["v", "j", "y"]).await;
//         cx.assert_shared_clipboard("over\nthe lazy do").await;

//         cx.simulate_shared_keystroke("p").await;
//         cx.assert_shared_state(indoc! {"
//             The quick brown
//             fox jumps oˇover
//             the lazy dover
//             the lazy dog"})
//             .await;
//         cx.simulate_shared_keystrokes(["u", "shift-p"]).await;
//         cx.assert_shared_state(indoc! {"
//             The quick brown
//             fox jumps ˇover
//             the lazy doover
//             the lazy dog"})
//             .await;
//     }

//     #[gpui::test]
//     async fn test_paste_visual(cx: &mut gpui::TestAppContext) {
//         let mut cx = NeovimBackedTestContext::new(cx).await;

//         // copy in visual mode
//         cx.set_shared_state(indoc! {"
//                 The quick brown
//                 fox jˇumps over
//                 the lazy dog"})
//             .await;
//         cx.simulate_shared_keystrokes(["v", "i", "w", "y"]).await;
//         cx.assert_shared_state(indoc! {"
//                 The quick brown
//                 fox ˇjumps over
//                 the lazy dog"})
//             .await;
//         // paste in visual mode
//         cx.simulate_shared_keystrokes(["w", "v", "i", "w", "p"])
//             .await;
//         cx.assert_shared_state(indoc! {"
//                 The quick brown
//                 fox jumps jumpˇs
//                 the lazy dog"})
//             .await;
//         cx.assert_shared_clipboard("over").await;
//         // paste in visual line mode
//         cx.simulate_shared_keystrokes(["up", "shift-v", "shift-p"])
//             .await;
//         cx.assert_shared_state(indoc! {"
//             ˇover
//             fox jumps jumps
//             the lazy dog"})
//             .await;
//         cx.assert_shared_clipboard("over").await;
//         // paste in visual block mode
//         cx.simulate_shared_keystrokes(["ctrl-v", "down", "down", "p"])
//             .await;
//         cx.assert_shared_state(indoc! {"
//             oveˇrver
//             overox jumps jumps
//             overhe lazy dog"})
//             .await;

//         // copy in visual line mode
//         cx.set_shared_state(indoc! {"
//                 The quick brown
//                 fox juˇmps over
//                 the lazy dog"})
//             .await;
//         cx.simulate_shared_keystrokes(["shift-v", "d"]).await;
//         cx.assert_shared_state(indoc! {"
//                 The quick brown
//                 the laˇzy dog"})
//             .await;
//         // paste in visual mode
//         cx.simulate_shared_keystrokes(["v", "i", "w", "p"]).await;
//         cx.assert_shared_state(
//             &indoc! {"
//                 The quick brown
//                 the_
//                 ˇfox jumps over
//                 _dog"}
//             .replace("_", " "), // Hack for trailing whitespace
//         )
//         .await;
//         cx.assert_shared_clipboard("lazy").await;
//         cx.set_shared_state(indoc! {"
//             The quick brown
//             fox juˇmps over
//             the lazy dog"})
//             .await;
//         cx.simulate_shared_keystrokes(["shift-v", "d"]).await;
//         cx.assert_shared_state(indoc! {"
//             The quick brown
//             the laˇzy dog"})
//             .await;
//         // paste in visual line mode
//         cx.simulate_shared_keystrokes(["k", "shift-v", "p"]).await;
//         cx.assert_shared_state(indoc! {"
//             ˇfox jumps over
//             the lazy dog"})
//             .await;
//         cx.assert_shared_clipboard("The quick brown\n").await;
//     }

//     #[gpui::test]
//     async fn test_paste_visual_block(cx: &mut gpui::TestAppContext) {
//         let mut cx = NeovimBackedTestContext::new(cx).await;
//         // copy in visual block mode
//         cx.set_shared_state(indoc! {"
//             The ˇquick brown
//             fox jumps over
//             the lazy dog"})
//             .await;
//         cx.simulate_shared_keystrokes(["ctrl-v", "2", "j", "y"])
//             .await;
//         cx.assert_shared_clipboard("q\nj\nl").await;
//         cx.simulate_shared_keystrokes(["p"]).await;
//         cx.assert_shared_state(indoc! {"
//             The qˇquick brown
//             fox jjumps over
//             the llazy dog"})
//             .await;
//         cx.simulate_shared_keystrokes(["v", "i", "w", "shift-p"])
//             .await;
//         cx.assert_shared_state(indoc! {"
//             The ˇq brown
//             fox jjjumps over
//             the lllazy dog"})
//             .await;
//         cx.simulate_shared_keystrokes(["v", "i", "w", "shift-p"])
//             .await;

//         cx.set_shared_state(indoc! {"
//             The ˇquick brown
//             fox jumps over
//             the lazy dog"})
//             .await;
//         cx.simulate_shared_keystrokes(["ctrl-v", "j", "y"]).await;
//         cx.assert_shared_clipboard("q\nj").await;
//         cx.simulate_shared_keystrokes(["l", "ctrl-v", "2", "j", "shift-p"])
//             .await;
//         cx.assert_shared_state(indoc! {"
//             The qˇqick brown
//             fox jjmps over
//             the lzy dog"})
//             .await;

//         cx.simulate_shared_keystrokes(["shift-v", "p"]).await;
//         cx.assert_shared_state(indoc! {"
//             ˇq
//             j
//             fox jjmps over
//             the lzy dog"})
//             .await;
//     }

//     #[gpui::test]
//     async fn test_paste_indent(cx: &mut gpui::TestAppContext) {
//         let mut cx = VimTestContext::new_typescript(cx).await;

//         cx.set_state(
//             indoc! {"
//             class A {ˇ
//             }
//         "},
//             Mode::Normal,
//         );
//         cx.simulate_keystrokes(["o", "a", "(", ")", "{", "escape"]);
//         cx.assert_state(
//             indoc! {"
//             class A {
//                 a()ˇ{}
//             }
//             "},
//             Mode::Normal,
//         );
//         // cursor goes to the first non-blank character in the line;
//         cx.simulate_keystrokes(["y", "y", "p"]);
//         cx.assert_state(
//             indoc! {"
//             class A {
//                 a(){}
//                 ˇa(){}
//             }
//             "},
//             Mode::Normal,
//         );
//         // indentation is preserved when pasting
//         cx.simulate_keystrokes(["u", "shift-v", "up", "y", "shift-p"]);
//         cx.assert_state(
//             indoc! {"
//                 ˇclass A {
//                     a(){}
//                 class A {
//                     a(){}
//                 }
//                 "},
//             Mode::Normal,
//         );
//     }
// }