package main

import (
	"bufio"
	"image"
	"image/color"
	"os"
	"strconv"
	"strings"

	"fyne.io/fyne/v2"
	"fyne.io/fyne/v2/app"
	"fyne.io/fyne/v2/canvas"

	"janouch.name/desktop-tools/liust-50/charset"
)

const (
	displayWidth  = 20
	displayHeight = 2
	charWidth     = 5 + 1
	charHeight    = 7 + 1
	magnification = 5
)

// TODO(p): See how this works exactly, and implement it.
const (
	cursorModeOff = iota
	cursorModeBlink
	cursorModeLightUp
)

type Display struct {
	image      *canvas.Image
	chars      [displayHeight][displayWidth]uint8
	charset    uint8
	cursorX    int
	cursorY    int
	cursorMode int
}

func NewDisplay() *Display {
	return &Display{charset: 2}
}

func (d *Display) Clear() {
	for y := 0; y < displayHeight; y++ {
		for x := 0; x < displayWidth; x++ {
			d.chars[y][x] = 0x20 // space
		}
	}
}

func (d *Display) ClearToEnd() {
	for x := d.cursorX; x < displayWidth; x++ {
		d.chars[d.cursorY][x] = 0x20 // space
	}
}

func (d *Display) drawCharacter(
	img *image.RGBA, charImg image.Image, cx, cy int) {
	if charImg == nil {
		return
	}

	bounds := charImg.Bounds()
	width, height := bounds.Dx(), bounds.Dy()
	for dy := 0; dy < height; dy++ {
		for dx := 0; dx < width; dx++ {
			c := charImg.At(bounds.Min.X+dx, bounds.Min.Y+dy)
			if r, _, _, _ := c.RGBA(); r >= 0x8000 {
				c = color.RGBA{0x00, 0xFF, 0xA0, 0xFF}
			} else {
				c = color.RGBA{0x20, 0x20, 0x20, 0xFF}
			}
			img.Set(1+cx*charWidth+dx, 1+cy*charHeight+dy, c)
		}
	}
}

func (d *Display) Render() image.Image {
	width := 1 + displayWidth*charWidth
	height := 1 + displayHeight*charHeight

	img := image.NewRGBA(image.Rect(0, 0, width, height))
	for y := 0; y < height; y++ {
		for x := 0; x < width; x++ {
			img.Set(x, y, color.Black)
		}
	}

	for cy := 0; cy < displayHeight; cy++ {
		for cx := 0; cx < displayWidth; cx++ {
			charImg := charset.ResolveCharToImage(d.chars[cy][cx], d.charset)
			d.drawCharacter(img, charImg, cx, cy)
		}
	}

	return img
}

func (d *Display) PutChar(ch uint8) {
	if d.cursorX >= displayWidth || d.cursorY >= displayHeight {
		return
	}

	d.chars[d.cursorY][d.cursorX] = ch
	d.cursorX++
	if d.cursorX >= displayWidth {
		d.cursorX = displayWidth - 1
	}
}

func (d *Display) LineFeed() {
	d.cursorY++
	if d.cursorY >= displayHeight {
		d.cursorY = displayHeight - 1

		// XXX: This relies on displayHeight being exactly 2.
		d.chars[0] = d.chars[1]
		for x := 0; x < displayWidth; x++ {
			d.chars[1][x] = 0x20
		}
	}
}

func (d *Display) CarriageReturn() {
	d.cursorX = 0
}

func (d *Display) Backspace() {
	if d.cursorX > 0 {
		d.cursorX--
	}
}

func (d *Display) SetCursor(x, y int) {
	if x >= 0 && x < displayWidth {
		d.cursorX = x
	}
	if y >= 0 && y < displayHeight {
		d.cursorY = y
	}
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

func parseANSI(input string) (command string, params []int) {
	if !strings.HasPrefix(input, "\x1b[") {
		return "", nil
	}

	input = input[2:]
	if len(input) == 0 {
		return "", nil
	}

	cmdIdx := len(input) - 1
	command = string(input[cmdIdx])

	paramStr := input[:cmdIdx]
	if paramStr == "" {
		return command, []int{}
	}

	parts := strings.Split(paramStr, ";")
	for _, p := range parts {
		p = strings.TrimSpace(p)
		if val, err := strconv.Atoi(p); err == nil {
			params = append(params, val)
		}
	}
	return command, params
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

type escapeParser struct {
	seq     strings.Builder
	inEsc   bool
	inCSI   bool
	display *Display
}

func newEscapeParser(d *Display) *escapeParser {
	return &escapeParser{display: d}
}

func (ep *escapeParser) reset() {
	ep.inEsc = false
	ep.inCSI = false
	ep.seq.Reset()
}

func (ep *escapeParser) handleCSICommand() bool {
	cmd, params := parseANSI(ep.seq.String())

	switch cmd {
	case "J": // Clear display
		// XXX: No params case is unverified.
		if len(params) == 0 || params[0] == 2 {
			ep.display.Clear()
		}
	case "K": // Delete to end of line
		// XXX: No params case is unverified (but it should work).
		if len(params) == 0 || params[0] == 0 {
			ep.display.ClearToEnd()
		}
	case "H": // Cursor position
		y, x := 0, 0
		if len(params) >= 1 {
			y = params[0] - 1 // 1-indexed to 0-indexed
		}
		if len(params) >= 2 {
			x = params[1] - 1
		}
		ep.display.SetCursor(x, y)
	}
	return true
}

func (ep *escapeParser) handleEscapeSequence(b byte) bool {
	ep.seq.WriteByte(b)

	if ep.seq.Len() == 2 && b == '[' {
		ep.inCSI = true
		return false
	}

	if ep.seq.Len() == 3 && ep.seq.String()[1] == 'R' {
		ep.display.charset = b
		ep.reset()
		return true
	}

	if ep.inCSI && (b >= 'A' && b <= 'Z' || b >= 'a' && b <= 'z') {
		refresh := ep.handleCSICommand()
		ep.reset()
		return refresh
	}

	if ep.seq.Len() == 6 && ep.seq.String()[1:5] == "\\?LC" {
		ep.display.cursorMode = int(ep.seq.String()[5])
		return true
	}

	return false
}

func (ep *escapeParser) handleControlChar(b byte) bool {
	switch b {
	case 0x0A: // LF
		ep.display.LineFeed()
		return true
	case 0x0D: // CR
		ep.display.CarriageReturn()
		return true
	case 0x08: // BS
		ep.display.Backspace()
		return true
	default:
		if b >= 0x20 {
			ep.display.PutChar(b)
			return true
		}
	}
	return false
}

func (ep *escapeParser) handleByte(b byte) (needsRefresh bool) {
	if b == 0x1b { // ESC
		ep.reset()
		ep.inEsc = true
		ep.seq.WriteByte(b)
		return false
	}

	if ep.inEsc {
		return ep.handleEscapeSequence(b)
	}

	return ep.handleControlChar(b)
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

func main() {
	myApp := app.New()
	window := myApp.NewWindow("Toshiba Tec LIUST-50 Simulator")

	display := NewDisplay()
	display.Clear()

	img := canvas.NewImageFromImage(display.Render())
	img.FillMode = canvas.ImageFillOriginal
	img.ScaleMode = canvas.ImageScalePixels

	window.SetContent(img)

	window.Resize(fyne.NewSize(600, 100))

	go func() {
		reader := bufio.NewReader(os.Stdin)
		parser := newEscapeParser(display)

		for {
			b, err := reader.ReadByte()
			if err != nil {
				fyne.DoAndWait(func() {
					window.SetTitle(err.Error())
				})
				return
			}

			if parser.handleByte(b) {
				fyne.DoAndWait(func() {
					img.Image = display.Render()
					img.Refresh()
				})
			}
		}
	}()

	window.ShowAndRun()
}