package term

import (
	"bytes"
	"fmt"
	"io"
)

var logWriterDetail = false

// Writer represents the output to a terminal.
type Writer interface {
	// Buffer returns the current buffer.
	Buffer() *Buffer
	// ResetBuffer resets the current buffer.
	ResetBuffer()
	// UpdateBuffer updates the terminal display to reflect current buffer.
	UpdateBuffer(bufNoti, buf *Buffer, fullRefresh bool) error
	// ClearScreen clears the terminal screen and places the cursor at the top
	// left corner.
	ClearScreen()
	// ShowCursor shows the cursor.
	ShowCursor()
	// HideCursor hides the cursor.
	HideCursor()
}

// writer renders the editor UI.
type writer struct {
	file   io.Writer
	curBuf *Buffer
}

// NewWriter returns a Writer that writes VT100 sequences to the given io.Writer.
func NewWriter(f io.Writer) Writer {
	return &writer{f, &Buffer{}}
}

func (w *writer) Buffer() *Buffer {
	return w.curBuf
}

func (w *writer) ResetBuffer() {
	w.curBuf = &Buffer{}
}

// deltaPos calculates the escape sequence needed to move the cursor from one
// position to another. It use relative movements to move to the destination
// line and absolute movement to move to the destination column.
func deltaPos(from, to Pos) []byte {
	buf := new(bytes.Buffer)
	if from.Line < to.Line {
		// move down
		fmt.Fprintf(buf, "\033[%dB", to.Line-from.Line)
	} else if from.Line > to.Line {
		// move up
		fmt.Fprintf(buf, "\033[%dA", from.Line-to.Line)
	}
	fmt.Fprint(buf, "\r")
	if to.Col > 0 {
		fmt.Fprintf(buf, "\033[%dC", to.Col)
	}
	return buf.Bytes()
}

const (
	hideCursor = "\033[?25l"
	showCursor = "\033[?25h"
)

// UpdateBuffer updates the terminal display to reflect current buffer.
func (w *writer) UpdateBuffer(bufNoti, buf *Buffer, fullRefresh bool) error {
	if buf.Width != w.curBuf.Width && w.curBuf.Lines != nil {
		// Width change, force full refresh
		w.curBuf.Lines = nil
		fullRefresh = true
	}

	bytesBuf := new(bytes.Buffer)

	bytesBuf.WriteString(hideCursor)

	// Rewind cursor
	if pLine := w.curBuf.Dot.Line; pLine > 0 {
		fmt.Fprintf(bytesBuf, "\033[%dA", pLine)
	}
	bytesBuf.WriteString("\r")

	if fullRefresh {
		// Erase from here. We may be in the top right corner of the screen; if
		// we simply do an erase here, tmux will save the current screen in the
		// scrollback buffer (presumably as a heuristics to detect full-screen
		// applications), but that is not something we want. So we write a space
		// first, and then erase, before rewinding back.
		//
		// Source code for tmux behavior:
		// https://github.com/tmux/tmux/blob/5f5f029e3b3a782dc616778739b2801b00b17c0e/screen-write.c#L1139
		bytesBuf.WriteString(" \033[J\r")
	}

	// style of last written cell.
	style := ""

	switchStyle := func(newstyle string) {
		if newstyle != style {
			fmt.Fprintf(bytesBuf, "\033[0;%sm", newstyle)
			style = newstyle
		}
	}

	writeCells := func(cs []Cell) {
		for _, c := range cs {
			switchStyle(c.Style)
			bytesBuf.WriteString(c.Text)
		}
	}

	if bufNoti != nil {
		if logWriterDetail {
			logger.Printf("going to write %d lines of notifications", len(bufNoti.Lines))
		}

		// Write notifications
		for _, line := range bufNoti.Lines {
			writeCells(line)
			switchStyle("")
			bytesBuf.WriteString("\033[K\n")
		}
		// TODO(xiaq): This is hacky; try to improve it.
		if len(w.curBuf.Lines) > 0 {
			w.curBuf.Lines = w.curBuf.Lines[1:]
		}
	}

	if logWriterDetail {
		logger.Printf("going to write %d lines, oldBuf had %d", len(buf.Lines), len(w.curBuf.Lines))
	}

	for i, line := range buf.Lines {
		if i > 0 {
			bytesBuf.WriteString("\n")
		}
		var j int // First column where buf and oldBuf differ
		// No need to update current line
		if !fullRefresh && i < len(w.curBuf.Lines) {
			var eq bool
			if eq, j = CompareCells(line, w.curBuf.Lines[i]); eq {
				continue
			}
		}
		// Move to the first differing column if necessary.
		firstCol := CellsWidth(line[:j])
		if firstCol != 0 {
			fmt.Fprintf(bytesBuf, "\033[%dC", firstCol)
		}
		// Erase the rest of the line if necessary.
		if !fullRefresh && i < len(w.curBuf.Lines) && j < len(w.curBuf.Lines[i]) {
			switchStyle("")
			bytesBuf.WriteString("\033[K")
		}
		writeCells(line[j:])
	}
	if len(w.curBuf.Lines) > len(buf.Lines) && !fullRefresh {
		// If the old buffer is higher, erase old content.
		// Note that we cannot simply write \033[J, because if the cursor is
		// just over the last column -- which is precisely the case if we have a
		// rprompt, \033[J will also erase the last column.
		switchStyle("")
		bytesBuf.WriteString("\n\033[J\033[A")
	}
	switchStyle("")
	cursor := buf.Cursor()
	bytesBuf.Write(deltaPos(cursor, buf.Dot))

	// Show cursor.
	bytesBuf.WriteString(showCursor)

	if logWriterDetail {
		logger.Printf("going to write %q", bytesBuf.String())
	}

	_, err := w.file.Write(bytesBuf.Bytes())
	if err != nil {
		return err
	}

	w.curBuf = buf
	return nil
}

func (w *writer) HideCursor() {
	fmt.Fprint(w.file, hideCursor)
}

func (w *writer) ShowCursor() {
	fmt.Fprint(w.file, showCursor)
}

func (w *writer) ClearScreen() {
	fmt.Fprint(w.file,
		"\033[H",  // move cursor to the top left corner
		"\033[2J", // clear entire buffer
	)
}