package window

import (
	"bytes"
	"math"
	"reflect"
	"strings"
	"testing"

	"b612.me/apps/b612/bed/event"
	"b612.me/apps/b612/bed/mode"
)

func TestWindowState(t *testing.T) {
	r := strings.NewReader("Hello, world!")
	width, height := 16, 10
	window, err := newWindow(r, "test", "test", nil, nil)
	if err != nil {
		t.Fatal(err)
	}
	window.setSize(width, height)

	s, err := window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}

	if expected := "test"; s.Name != expected {
		t.Errorf("state.Name should be %q but got %q", expected, s.Name)
	}

	if s.Width != width {
		t.Errorf("state.Width should be %d but got %d", width, s.Width)
	}

	if expected := int64(0); s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}

	if expected := int64(0); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}

	if expected := 13; s.Size != expected {
		t.Errorf("s.Size should be %d but got %d", expected, s.Size)
	}

	if expected := int64(13); s.Length != expected {
		t.Errorf("s.Length should be %d but got %d", expected, s.Length)
	}

	if expected := false; s.Pending != expected {
		t.Errorf("s.Pending should be %v but got %v", expected, s.Pending)
	}

	if expected := byte('\x00'); s.PendingByte != expected {
		t.Errorf("s.PendingByte should be %q but got %q", expected, s.PendingByte)
	}

	if !reflect.DeepEqual(s.EditedIndices, []int64{}) {
		t.Errorf("state.EditedIndices should be empty but got %v", s.EditedIndices)
	}

	expected := []byte("Hello, world!" + strings.Repeat("\x00", height*width-13))
	if !reflect.DeepEqual(s.Bytes, expected) {
		t.Errorf("s.Bytes should be %q but got %q", expected, s.Bytes)
	}
}

func TestWindowEmptyState(t *testing.T) {
	r := strings.NewReader("")
	width, height := 16, 10
	window, err := newWindow(r, "test", "test", nil, nil)
	if err != nil {
		t.Fatal(err)
	}
	window.setSize(width, height)

	s, err := window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}

	if expected := "test"; s.Name != expected {
		t.Errorf("state.Name should be %q but got %q", expected, s.Name)
	}

	if s.Width != width {
		t.Errorf("state.Width should be %d but got %d", width, s.Width)
	}

	if expected := int64(0); s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}

	if expected := int64(0); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}

	if expected := 0; s.Size != expected {
		t.Errorf("s.Size should be %d but got %d", expected, s.Size)
	}

	if expected := int64(0); s.Length != expected {
		t.Errorf("s.Length should be %d but got %d", expected, s.Length)
	}

	if expected := false; s.Pending != expected {
		t.Errorf("s.Pending should be %v but got %v", expected, s.Pending)
	}

	if expected := byte('\x00'); s.PendingByte != expected {
		t.Errorf("s.PendingByte should be %q but got %q", expected, s.PendingByte)
	}

	if !reflect.DeepEqual(s.EditedIndices, []int64{}) {
		t.Errorf("state.EditedIndices should be empty but got %v", s.EditedIndices)
	}

	expected := []byte(strings.Repeat("\x00", height*width))
	if !reflect.DeepEqual(s.Bytes, expected) {
		t.Errorf("s.Bytes should be %q but got %q", expected, s.Bytes)
	}

	window.scrollDown(0)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}

	if expected := int64(0); s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}
}

func TestWindowCursorMotions(t *testing.T) {
	r := strings.NewReader(strings.Repeat("Hello, world!", 100))
	width, height := 16, 10
	window, err := newWindow(r, "test", "test", nil, nil)
	if err != nil {
		t.Fatal(err)
	}
	window.setSize(width, height)

	s, err := window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(0); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}

	window.cursorDown(0)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(width); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}

	window.cursorDown(1)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(width) * 2; s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}

	window.cursorUp(0)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(width); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}

	window.cursorDown(10)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(width) * 11; s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	if expected := int64(width) * 2; s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}
	if expected := " world!"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}

	window.cursorRight(mode.Normal, 3)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(width)*11 + 3; s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}

	window.cursorRight(mode.Normal, 20)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(width)*12 - 1; s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}

	window.cursorLeft(3)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(width)*12 - 4; s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}

	window.cursorLeft(20)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(width) * 11; s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}

	window.cursorPrev(154)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(22); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	if s.Offset != int64(width) {
		t.Errorf("s.Offset should be %d but got %d", width, s.Offset)
	}

	window.cursorNext(mode.Normal, 200)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(222); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	if expected := int64(width) * 4; s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}

	window.cursorNext(mode.Normal, 2000)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(1299); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	if expected := int64(width) * 72; s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}

	window.cursorHead(1)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(1296); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	if expected := int64(width) * 72; s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}

	window.cursorEnd(1)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(1299); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	if expected := int64(width) * 72; s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}

	window.cursorUp(20)
	window.cursorEnd(1)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(991); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	if expected := int64(width) * 61; s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}

	window.cursorEnd(11)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(1151); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	if expected := int64(width) * 62; s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}

	window.cursorDown(30)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(1299); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	if expected := int64(width) * 72; s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}

	window.cursorPrev(2000)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(0); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	if expected := int64(0); s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}

	window.cursorDown(2000)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(width) * 81; s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	if expected := int64(width) * 72; s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}

	window.cursorRight(mode.Normal, 1000)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(1299); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	if expected := int64(width) * 72; s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}

	window.cursorUp(2000)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(3); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	if expected := int64(0); s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}

	window.windowTop(0)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(0); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	if expected := int64(0); s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}

	window.windowTop(7)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(96); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	if expected := int64(0); s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}

	window.windowTop(20)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(144); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	if expected := int64(0); s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}

	window.windowMiddle()
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(64); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	if expected := int64(0); s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}

	window.windowBottom(0)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(144); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	if expected := int64(0); s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}

	window.windowBottom(7)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(48); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	if expected := int64(0); s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}

	window.windowBottom(20)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(0); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	if expected := int64(0); s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}

	window.cursorGotoPos(event.Absolute{Offset: 0}, "goto")
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(0); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}

	window.cursorGotoPos(event.Absolute{Offset: 50}, "goto")
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(50); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}

	window.cursorGotoPos(event.Absolute{Offset: 100}, "goto")
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(100); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}

	window.cursorGotoPos(event.Relative{Offset: -10}, "goto")
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(90); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}

	window.cursorGotoPos(event.Absolute{Offset: 30}, "%")
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(390); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}

	window.cursorGotoPos(event.Relative{Offset: 30}, "%")
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(780); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}

	window.cursorGotoPos(event.End{Offset: -30}, "%")
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(909); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}

	window.cursorGotoPos(event.Absolute{Offset: 30}, "go[to]")
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(480); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}

	window.cursorGotoPos(event.Relative{Offset: 30}, "go[to]")
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(960); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}

	window.cursorGotoPos(event.End{Offset: -30}, "go[to]")
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(819); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
}

func TestWindowScreenMotions(t *testing.T) {
	r := strings.NewReader(strings.Repeat("Hello, world!", 100))
	width, height := 16, 10
	window, err := newWindow(r, "test", "test", nil, nil)
	if err != nil {
		t.Fatal(err)
	}
	window.setSize(width, height)

	s, err := window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(0); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}

	window.pageDown()
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(128); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	if expected := int64(128); s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}

	window.pageDownHalf()
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(208); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	if expected := int64(208); s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}

	window.scrollDown(0)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(224); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	if expected := int64(224); s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}

	window.scrollUp(0)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(224); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	if expected := int64(208); s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}

	window.scrollDown(30)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(688); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	if expected := int64(688); s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}

	window.scrollUp(30)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(352); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	if expected := int64(208); s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}

	window.pageUpHalf()
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(272); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	if expected := int64(128); s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}

	window.pageUp()
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(0); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	if expected := int64(0); s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}

	window.pageEnd()
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(1296); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	if expected := int64(width) * 72; s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}

	window.pageTop()
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(0); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	if expected := int64(0); s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}

	window.cursorNext(mode.Normal, 5)
	window.scrollTop(5)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(85); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	if expected := int64(80); s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}

	window.cursorDown(4)
	window.scrollTop(0)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(149); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	if expected := int64(144); s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}

	window.scrollTopHead(10)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(160); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	if expected := int64(160); s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}

	window.cursorNext(mode.Normal, 5)
	window.scrollMiddle(12)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(197); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	if expected := int64(112); s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}

	window.scrollMiddleHead(15)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(240); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	if expected := int64(160); s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}

	window.cursorNext(mode.Normal, 5)
	window.scrollBottom(12)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(197); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	if expected := int64(48); s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}

	window.cursorDown(8)
	window.scrollBottom(0)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(325); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	if expected := int64(176); s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}

	window.scrollBottomHead(10)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(160); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	if expected := int64(16); s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}
}

func TestWindowDeleteBytes(t *testing.T) {
	r := strings.NewReader("Hello, world!")
	width, height := 16, 10
	window, err := newWindow(r, "test", "test", nil, nil)
	if err != nil {
		t.Fatal(err)
	}
	window.setSize(width, height)

	window.cursorNext(mode.Normal, 7)
	window.deleteBytes(0)
	s, err := window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := "Hello, orld!\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}
	if expected := int64(7); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}

	window.deleteBytes(3)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := "Hello, d!\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}
	if expected := int64(7); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}

	window.deleteBytes(3)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := "Hello, \x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}
	if expected := int64(6); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}

	window.deleteByte()
	window.deleteByte()
	window.deleteByte()
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := "Hell\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}
	if expected := int64(3); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}

	window.deleteBytes(0)
	window.deleteBytes(0)
	window.deleteBytes(0)
	window.deleteBytes(0)
	window.deleteBytes(0)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := "\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}
	if expected := int64(0); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	if expected := int64(0); s.Length != expected {
		t.Errorf("s.Length should be %d but got %d", expected, s.Length)
	}
}

func TestWindowDeletePrevBytes(t *testing.T) {
	r := strings.NewReader("Hello, world!")
	width, height := 16, 10
	window, err := newWindow(r, "test", "test", nil, nil)
	if err != nil {
		t.Fatal(err)
	}
	window.setSize(width, height)

	window.cursorNext(mode.Normal, 5)
	window.deletePrevBytes(0)
	s, err := window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := "Hell, world!\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}
	if expected := int64(4); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}

	window.deletePrevBytes(3)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := "H, world!\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}
	if expected := int64(1); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}

	window.deletePrevBytes(3)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := ", world!\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}
	if expected := int64(0); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
}

func TestWindowIncrementDecrement(t *testing.T) {
	r := strings.NewReader("Hello, world!")
	width, height := 16, 10
	window, err := newWindow(r, "test", "test", nil, nil)
	if err != nil {
		t.Fatal(err)
	}
	window.setSize(width, height)

	window.increment(0)
	s, err := window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := "Iello, world!\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}

	window.increment(1000)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := "1ello, world!\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}

	window.increment(math.MaxInt64)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := "0ello, world!\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}

	window.decrement(0)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := "/ello, world!\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}

	window.decrement(1000)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := "Gello, world!\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}

	window.decrement(math.MaxInt64)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := "Hello, world!\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}

	window.cursorNext(mode.Normal, 7)
	window.increment(1000)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := "Hello, _orld!\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}
}

func TestWindowIncrementDecrementEmpty(t *testing.T) {
	r := strings.NewReader("")
	width, height := 16, 10
	window, err := newWindow(r, "test", "test", nil, nil)
	if err != nil {
		t.Fatal(err)
	}
	window.setSize(width, height)

	s, err := window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := 0; s.Size != expected {
		t.Errorf("s.Size should be %d but got %d", expected, s.Size)
	}
	if expected := int64(0); s.Length != expected {
		t.Errorf("s.Length should be %d but got %d", expected, s.Length)
	}

	window.increment(0)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := "\x01\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}
	if expected := 1; s.Size != expected {
		t.Errorf("s.Size should be %d but got %d", expected, s.Size)
	}
	if expected := int64(1); s.Length != expected {
		t.Errorf("s.Length should be %d but got %d", expected, s.Length)
	}

	window, err = newWindow(r, "test", "test", nil, nil)
	if err != nil {
		t.Fatal(err)
	}
	window.setSize(width, height)

	window.decrement(0)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := "\xff\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}
	if expected := 1; s.Size != expected {
		t.Errorf("s.Size should be %d but got %d", expected, s.Size)
	}
	if expected := int64(1); s.Length != expected {
		t.Errorf("s.Length should be %d but got %d", expected, s.Length)
	}
}

func TestWindowInsertByte(t *testing.T) {
	r := strings.NewReader("Hello, world!")
	width, height := 16, 1
	window, err := newWindow(r, "test", "test", nil, nil)
	if err != nil {
		t.Fatal(err)
	}
	window.setSize(width, height)

	window.cursorNext(mode.Normal, 7)
	window.startInsert()

	window.insertByte(mode.Insert, 0x04)
	s, err := window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := true; s.Pending != expected {
		t.Errorf("s.Pending should be %v but got %v", expected, s.Pending)
	}
	if expected := byte('\x40'); s.PendingByte != expected {
		t.Errorf("s.PendingByte should be %q but got %q", expected, s.PendingByte)
	}

	window.insertByte(mode.Insert, 0x0a)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := "Hello, Jworld!\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}
	if expected := false; s.Pending != expected {
		t.Errorf("s.Pending should be %v but got %v", expected, s.Pending)
	}
	if expected := byte('\x00'); s.PendingByte != expected {
		t.Errorf("s.PendingByte should be %q but got %q", expected, s.PendingByte)
	}
	if expected := int64(14); s.Length != expected {
		t.Errorf("s.Length should be %d but got %d", expected, s.Length)
	}

	window.exitInsert()
	window.startAppendEnd()
	window.insertByte(mode.Insert, 0x04)
	window.insertByte(mode.Insert, 0x0b)
	window.insertByte(mode.Insert, 0x04)
	window.insertByte(mode.Insert, 0x0c)
	window.insertByte(mode.Insert, 0x04)
	window.insertByte(mode.Insert, 0x0d)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := "M\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}
	if expected := false; s.Pending != expected {
		t.Errorf("s.Pending should be %v but got %v", expected, s.Pending)
	}
	if expected := byte('\x00'); s.PendingByte != expected {
		t.Errorf("s.PendingByte should be %q but got %q", expected, s.PendingByte)
	}
	if expected := int64(18); s.Length != expected {
		t.Errorf("s.Length should be %d but got %d", expected, s.Length)
	}
	if expected := int64(16); s.Offset != expected {
		t.Errorf("s.Offset should be %d but got %d", expected, s.Offset)
	}
}

func TestWindowInsertEmpty(t *testing.T) {
	r := strings.NewReader("")
	width, height := 16, 10
	window, err := newWindow(r, "test", "test", nil, nil)
	if err != nil {
		t.Fatal(err)
	}
	window.setSize(width, height)

	window.startInsert()
	window.insertByte(mode.Insert, 0x04)
	window.insertByte(mode.Insert, 0x0a)
	s, err := window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := "J\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}
	if expected := false; s.Pending != expected {
		t.Errorf("s.Pending should be %v but got %v", expected, s.Pending)
	}
	if expected := byte('\x00'); s.PendingByte != expected {
		t.Errorf("s.PendingByte should be %q but got %q", expected, s.PendingByte)
	}
	if expected := int64(2); s.Length != expected {
		t.Errorf("s.Length should be %d but got %d", expected, s.Length)
	}

	window.exitInsert()
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := "J\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}
	if expected := int64(1); s.Length != expected {
		t.Errorf("s.Length should be %d but got %d", expected, s.Length)
	}
	if expected := int64(0); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
}

func TestWindowInsertHead(t *testing.T) {
	r := strings.NewReader(strings.Repeat("Hello, world!", 2))
	width, height := 16, 10
	window, err := newWindow(r, "test", "test", nil, nil)
	if err != nil {
		t.Fatal(err)
	}
	window.setSize(width, height)

	window.pageEnd()
	window.startInsertHead()
	s, err := window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(16); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}

	window.insertByte(mode.Insert, 0x03)
	window.insertByte(mode.Insert, 0x0a)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := "Hello, world!Hel:lo, world!\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}
	if expected := false; s.Pending != expected {
		t.Errorf("s.Pending should be %v but got %v", expected, s.Pending)
	}
	if expected := byte('\x00'); s.PendingByte != expected {
		t.Errorf("s.PendingByte should be %q but got %q", expected, s.PendingByte)
	}
	if expected := int64(27); s.Length != expected {
		t.Errorf("s.Length should be %d but got %d", expected, s.Length)
	}
	if expected := int64(17); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
}

func TestWindowInsertHeadEmpty(t *testing.T) {
	r := strings.NewReader("")
	width, height := 16, 10
	window, err := newWindow(r, "test", "test", nil, nil)
	if err != nil {
		t.Fatal(err)
	}
	window.setSize(width, height)

	window.startInsertHead()
	s, err := window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := false; s.Pending != expected {
		t.Errorf("s.Pending should be %v but got %v", expected, s.Pending)
	}
	if expected := byte('\x00'); s.PendingByte != expected {
		t.Errorf("s.PendingByte should be %q but got %q", expected, s.PendingByte)
	}
	if expected := int64(1); s.Length != expected {
		t.Errorf("s.Length should be %d but got %d", expected, s.Length)
	}
	if expected := int64(0); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}

	window.insertByte(mode.Insert, 0x04)
	window.insertByte(mode.Insert, 0x0a)
	window.exitInsert()
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := "J\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}
	if expected := int64(1); s.Length != expected {
		t.Errorf("s.Length should be %d but got %d", expected, s.Length)
	}
	if expected := int64(0); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
}

func TestWindowAppend(t *testing.T) {
	r := strings.NewReader("Hello, world!")
	width, height := 16, 10
	window, err := newWindow(r, "test", "test", nil, nil)
	if err != nil {
		t.Fatal(err)
	}
	window.setSize(width, height)

	window.cursorNext(mode.Normal, 7)
	window.startAppend()
	s, err := window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(8); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}

	window.insertByte(mode.Insert, 0x03)
	window.insertByte(mode.Insert, 0x0a)
	window.exitInsert()
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := "Hello, w:orld!\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}
	if expected := int64(14); s.Length != expected {
		t.Errorf("s.Length should be %d but got %d", expected, s.Length)
	}
	if expected := int64(8); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}

	window.cursorNext(mode.Normal, 10)
	window.startAppend()
	window.insertByte(mode.Insert, 0x03)
	window.insertByte(mode.Insert, 0x0A)
	window.exitInsert()
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := "Hello, w:orld!:\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}
	if expected := int64(15); s.Length != expected {
		t.Errorf("s.Length should be %d but got %d", expected, s.Length)
	}
	if expected := int64(14); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
}

func TestWindowAppendEmpty(t *testing.T) {
	r := strings.NewReader("")
	width, height := 16, 10
	window, err := newWindow(r, "test", "test", nil, nil)
	if err != nil {
		t.Fatal(err)
	}
	window.setSize(width, height)

	window.startAppend()
	window.exitInsert()
	s, err := window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(0); s.Length != expected {
		t.Errorf("s.Length should be %d but got %d", expected, s.Length)
	}
	if expected := int64(0); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}

	window.startAppend()
	window.insertByte(mode.Insert, 0x03)
	window.insertByte(mode.Insert, 0x0a)
	window.exitInsert()
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := ":\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}
	if expected := int64(1); s.Length != expected {
		t.Errorf("s.Length should be %d but got %d", expected, s.Length)
	}
	if expected := int64(0); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}

	window.startAppendEnd()
	window.insertByte(mode.Insert, 0x03)
	window.insertByte(mode.Insert, 0x0b)
	window.exitInsert()
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := ":;\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}
	if expected := int64(2); s.Length != expected {
		t.Errorf("s.Length should be %d but got %d", expected, s.Length)
	}
	if expected := int64(1); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
}

func TestWindowReplaceByte(t *testing.T) {
	r := strings.NewReader("Hello, world!")
	width, height := 16, 10
	window, err := newWindow(r, "test", "test", nil, nil)
	if err != nil {
		t.Fatal(err)
	}
	window.setSize(width, height)

	window.cursorNext(mode.Normal, 7)
	window.startReplaceByte()
	s, err := window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(7); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}

	window.insertByte(mode.Replace, 0x03)
	window.insertByte(mode.Replace, 0x0a)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := "Hello, :orld!\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}
	if expected := int64(13); s.Length != expected {
		t.Errorf("s.Length should be %d but got %d", expected, s.Length)
	}
	if expected := int64(7); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
}

func TestWindowReplaceByteEmpty(t *testing.T) {
	r := strings.NewReader("")
	width, height := 16, 10
	window, err := newWindow(r, "test", "test", nil, nil)
	if err != nil {
		t.Fatal(err)
	}
	window.setSize(width, height)

	window.startReplaceByte()
	s, err := window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(0); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}

	window.insertByte(mode.Replace, 0x03)
	window.insertByte(mode.Replace, 0x0a)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := ":\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}
	if expected := int64(1); s.Length != expected {
		t.Errorf("s.Length should be %d but got %d", expected, s.Length)
	}
	if expected := int64(0); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
}

func TestWindowReplace(t *testing.T) {
	r := strings.NewReader("Hello, world!")
	width, height := 16, 10
	window, err := newWindow(r, "test", "test", nil, nil)
	if err != nil {
		t.Fatal(err)
	}
	window.setSize(width, height)

	window.cursorNext(mode.Normal, 10)
	window.startReplace()
	s, err := window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(10); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}

	window.insertByte(mode.Replace, 0x03)
	window.insertByte(mode.Replace, 0x0a)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := "Hello, wor:d!\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}
	if expected := int64(13); s.Length != expected {
		t.Errorf("s.Length should be %d but got %d", expected, s.Length)
	}
	if expected := int64(11); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}

	window.insertByte(mode.Replace, 0x03)
	window.insertByte(mode.Replace, 0x0b)
	window.insertByte(mode.Replace, 0x03)
	window.insertByte(mode.Replace, 0x0c)
	window.insertByte(mode.Replace, 0x03)
	window.insertByte(mode.Replace, 0x0d)
	window.insertByte(mode.Replace, 0x03)
	window.insertByte(mode.Replace, 0x0e)
	window.exitInsert()
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := "Hello, wor:;<=>\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}
	if expected := int64(15); s.Length != expected {
		t.Errorf("s.Length should be %d but got %d", expected, s.Length)
	}
	if expected := int64(14); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
}

func TestWindowReplaceEmpty(t *testing.T) {
	r := strings.NewReader("")
	width, height := 16, 10
	window, err := newWindow(r, "test", "test", nil, nil)
	if err != nil {
		t.Fatal(err)
	}
	window.setSize(width, height)

	window.startReplace()
	s, err := window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := int64(0); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}

	window.insertByte(mode.Replace, 0x03)
	window.insertByte(mode.Replace, 0x0a)
	window.insertByte(mode.Replace, 0x03)
	window.insertByte(mode.Replace, 0x0b)
	window.exitInsert()
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := ":;\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}
	if expected := int64(2); s.Length != expected {
		t.Errorf("s.Length should be %d but got %d", expected, s.Length)
	}
	if expected := int64(1); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
}

func TestWindowInsertByte2(t *testing.T) {
	r := strings.NewReader("")
	width, height := 16, 10
	window, err := newWindow(r, "test", "test", nil, nil)
	if err != nil {
		t.Fatal(err)
	}
	window.setSize(width, height)

	window.startInsert()
	window.insertByte(mode.Insert, 0x00)
	window.insertByte(mode.Insert, 0x01)
	window.insertByte(mode.Insert, 0x02)
	window.insertByte(mode.Insert, 0x03)
	window.insertByte(mode.Insert, 0x04)
	window.insertByte(mode.Insert, 0x05)
	window.insertByte(mode.Insert, 0x06)
	window.insertByte(mode.Insert, 0x07)
	window.insertByte(mode.Insert, 0x08)
	window.insertByte(mode.Insert, 0x09)
	window.insertByte(mode.Insert, 0x0a)
	window.insertByte(mode.Insert, 0x0b)
	window.insertByte(mode.Insert, 0x0c)
	window.insertByte(mode.Insert, 0x0d)
	window.insertByte(mode.Insert, 0x0e)
	window.insertByte(mode.Insert, 0x0f)
	window.exitInsert()
	s, err := window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := "\x01\x23\x45\x67\x89\xab\xcd\xef\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}
}

func TestWindowBackspace(t *testing.T) {
	r := strings.NewReader("Hello, world!")
	width, height := 16, 10
	window, err := newWindow(r, "test", "test", nil, nil)
	if err != nil {
		t.Fatal(err)
	}
	window.setSize(width, height)

	window.cursorNext(mode.Normal, 5)
	window.startInsert()
	window.backspace(mode.Insert)
	s, err := window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := "Hell, world!\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}
	window.backspace(mode.Insert)
	window.backspace(mode.Insert)
	window.backspace(mode.Insert)
	window.backspace(mode.Insert)
	window.backspace(mode.Insert)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := ", world!\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}
}

func TestWindowBackspacePending(t *testing.T) {
	r := strings.NewReader("Hello, world!")
	width, height := 16, 10
	window, err := newWindow(r, "test", "test", nil, nil)
	if err != nil {
		t.Fatal(err)
	}
	window.setSize(width, height)

	window.cursorNext(mode.Normal, 5)
	window.startInsert()
	window.insertByte(mode.Insert, 0x03)
	s, err := window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := true; s.Pending != expected {
		t.Errorf("s.Pending should be %v but got %v", expected, s.Pending)
	}
	if expected := byte('\x30'); s.PendingByte != expected {
		t.Errorf("s.PendingByte should be %q but got %q", expected, s.PendingByte)
	}

	window.backspace(mode.Insert)
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := "Hello, world!\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}
	if expected := false; s.Pending != expected {
		t.Errorf("s.Pending should be %v but got %v", expected, s.Pending)
	}
	if expected := byte('\x00'); s.PendingByte != expected {
		t.Errorf("s.PendingByte should be %q but got %q", expected, s.PendingByte)
	}
}

func TestWindowEventRune(t *testing.T) {
	width, height := 16, 10
	redrawCh := make(chan struct{})
	window, err := newWindow(strings.NewReader(""), "test", "test", nil, redrawCh)
	if err != nil {
		t.Fatal(err)
	}
	window.setSize(width, height)

	str := "48723fffab"
	go func() {
		defer close(redrawCh)
		window.emit(event.Event{Type: event.StartInsert})
		for _, r := range str {
			window.emit(event.Event{Type: event.Rune, Rune: r, Mode: mode.Insert})
		}
	}()
	<-redrawCh
	for range str {
		<-redrawCh
	}
	s, err := window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := "\x48\x72\x3f\xff\xab\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}
	<-redrawCh
}

func TestWindowEventRuneText(t *testing.T) {
	width, height := 16, 10
	redrawCh := make(chan struct{})
	window, err := newWindow(strings.NewReader(""), "test", "test", nil, redrawCh)
	if err != nil {
		t.Fatal(err)
	}
	window.setSize(width, height)

	str := "Hello, World!\nこんにちは、世界！\n鰰は魚の一種"
	go func() {
		defer close(redrawCh)
		window.emit(event.Event{Type: event.SwitchFocus})
		window.emit(event.Event{Type: event.StartInsert})
		for _, r := range str {
			window.emit(event.Event{Type: event.Rune, Rune: r, Mode: mode.Insert})
		}
	}()
	<-redrawCh
	<-redrawCh
	for range str {
		<-redrawCh
	}
	s, err := window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := str + "\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}
	<-redrawCh
}

func TestWindowEventUndoRedo(t *testing.T) {
	width, height := 16, 10
	redrawCh, waitCh := make(chan struct{}), make(chan struct{})
	window, err := newWindow(strings.NewReader("Hello, world!"), "test", "test", nil, redrawCh)
	if err != nil {
		t.Fatal(err)
	}
	window.setSize(width, height)

	go func() {
		defer func() {
			close(redrawCh)
			close(waitCh)
		}()
		window.emit(event.Event{Type: event.Undo})
		window.emit(event.Event{Type: event.SwitchFocus})
		window.emit(event.Event{Type: event.StartAppend, Mode: mode.Insert})

		<-waitCh
		window.emit(event.Event{Type: event.Rune, Rune: 'x', Mode: mode.Insert})
		window.emit(event.Event{Type: event.Rune, Rune: 'y', Mode: mode.Insert})
		window.emit(event.Event{Type: event.Rune, Rune: 'z', Mode: mode.Insert})
		window.emit(event.Event{Type: event.ExitInsert})

		<-waitCh
		window.emit(event.Event{Type: event.StartInsert, Mode: mode.Insert})
		window.emit(event.Event{Type: event.Rune, Rune: 'x', Mode: mode.Insert})
		window.emit(event.Event{Type: event.Rune, Rune: 'y', Mode: mode.Insert})
		window.emit(event.Event{Type: event.CursorLeft, Mode: mode.Insert})
		window.emit(event.Event{Type: event.Rune, Rune: 'z', Mode: mode.Insert})
		window.emit(event.Event{Type: event.ExitInsert})

		<-waitCh
		window.emit(event.Event{Type: event.Undo, Count: 2})
		window.emit(event.Event{Type: event.StartInsert, Mode: mode.Insert})
		window.emit(event.Event{Type: event.Rune, Rune: 'w', Mode: mode.Insert})

		<-waitCh
		window.emit(event.Event{Type: event.ExitInsert})
		window.emit(event.Event{Type: event.Undo})

		<-waitCh
		window.emit(event.Event{Type: event.Redo, Count: 2})
	}()

	for range 3 {
		<-redrawCh
	}
	s, err := window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := "Hello, world!\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}
	if expected := int64(1); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	waitCh <- struct{}{}

	for range 4 {
		<-redrawCh
	}
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := "Hxyzello, world!\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}
	if expected := int64(3); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	waitCh <- struct{}{}

	for range 6 {
		<-redrawCh
	}
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := "Hxyxzyzello, world!\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}
	if expected := int64(5); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	waitCh <- struct{}{}

	for range 3 {
		<-redrawCh
	}
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := "Hxywzello, world!\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}
	if expected := int64(4); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	waitCh <- struct{}{}

	for range 2 {
		<-redrawCh
	}
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := "Hxyzello, world!\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}
	if expected := int64(3); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	waitCh <- struct{}{}

	<-redrawCh
	s, err = window.state(width, height)
	if err != nil {
		t.Fatal(err)
	}
	if expected := "Hxywzello, world!\x00"; !strings.HasPrefix(string(s.Bytes), expected) {
		t.Errorf("s.Bytes should start with %q but got %q", expected, string(s.Bytes))
	}
	if expected := int64(4); s.Cursor != expected {
		t.Errorf("s.Cursor should be %d but got %d", expected, s.Cursor)
	}
	<-redrawCh
	<-waitCh
}

func TestWindowWriteTo(t *testing.T) {
	r := strings.NewReader("Hello, world!")
	window, err := newWindow(r, "test", "test", nil, nil)
	if err != nil {
		t.Fatal(err)
	}
	window.setSize(20, 10)
	window.cursorNext(mode.Normal, 3)
	window.startVisual()
	window.cursorNext(mode.Normal, 7)
	for _, testCase := range []struct {
		r        *event.Range
		expected string
	}{
		{nil, "Hello, world!"},
		{&event.Range{From: event.VisualStart{}, To: event.VisualEnd{}}, "lo, worl"},
	} {
		b := new(bytes.Buffer)
		n, err := window.writeTo(testCase.r, b)
		if expected := int64(len(testCase.expected)); n != expected {
			t.Errorf("writeTo should return %d but got: %d", expected, n)
		}
		if err != nil {
			t.Errorf("err should be nil but got: %v", err)
		}
		if b.String() != testCase.expected {
			t.Errorf("window should write %q with range %+v but got %q", testCase.expected, testCase.r, b.String())
		}
	}
}