package kvm

import (
	"context"
	"fmt"
	"os"
	"sync"
	"time"

	"github.com/atotto/clipboard"
	"kvmote/internal/input"
	"kvmote/internal/transport"
)

func LogDebug(msg string) {
	f, err := os.OpenFile("kvmote_debug.log", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil {
		return
	}
	defer f.Close()
	timestamp := time.Now().Format("15:04:05.000")
	f.WriteString(fmt.Sprintf("[%s] %s\n", timestamp, msg))
}

type ClientPos int

const (
	PosNone ClientPos = iota
	PosLeft
	PosRight
	PosAbove
	PosBelow
)

type ClientLayout int

const (
	LayoutUS ClientLayout = iota
	LayoutAbnt2
	LayoutUsIntl
)

type Engine struct {
	mu           sync.Mutex
	transport    transport.Transport
	inputHandler input.InputHandler
	
	clientMode   bool
	clientPos    ClientPos
	clientLayout ClientLayout

	ctrlHeld       bool
	shiftHeld      bool
	altHeld        bool
	clipboardReady bool

	virtualX, virtualY int32
	pendingDX, pendingDY int32
	lastRawPos   input.Point
	edgeEntry    input.Point
	isWarping    bool
	lastModeChange time.Time
	
	scrollActive bool
	scrollTimer  time.Time
	wheelAccum   int32

	mouseThrottle time.Time
}

func NewEngine(t transport.Transport, h input.InputHandler) *Engine {
	return &Engine{
		transport:    t,
		inputHandler: h,
		clientPos:    PosRight,
	}
}

func (e *Engine) Transport() transport.Transport {
	return e.transport
}

func (e *Engine) Start(ctx context.Context) error {
	w, h := e.inputHandler.GetScreenResolution()
	LogDebug(fmt.Sprintf("Engine Iniciada. Tela: %dx%d. Pos: %v", w, h, e.clientPos))
	return e.inputHandler.Install(ctx, e.onMouse, e.onKey)
}

func (e *Engine) processarScroll(msg uint32, data uint32) {
	e.scrollActive = true
	e.scrollTimer = time.Now()
	
	deltaRaw := int16(data >> 16)
	
	// LOG TOTAL PARA DESCOBRIR O QUE O TOUCHPAD MANDA
	go LogDebug(fmt.Sprintf("SCROLL RAW: msg=0x%X data=0x%X delta=%d", msg, data, deltaRaw))

	if deltaRaw > 0 {
		e.transport.Send([]byte{'P', 0xDA}) // Up
		time.Sleep(5 * time.Millisecond)
		e.transport.Send([]byte{'U', 0xDA})
	} else if deltaRaw < 0 {
		e.transport.Send([]byte{'P', 0xD9}) // Down
		time.Sleep(5 * time.Millisecond)
		e.transport.Send([]byte{'U', 0xD9})
	}
}

func (e *Engine) onMouse(ev input.MouseEvent) bool {
	e.mu.Lock()
	defer e.mu.Unlock()

	if !e.transport.IsConnected() {
		return false
	}

	// LOG PARA DIAGNÓSTICO: Registrar qualquer mensagem que não seja movimento simples (0x0200)
	if ev.Message != 0x0200 {
		go LogDebug(fmt.Sprintf("MSG MOUSE: 0x%X | ClientMode: %v", ev.Message, e.clientMode))
	}

	if !e.clientMode {
		if ev.Message == 0x0200 && e.isAtExitEdge(ev.Point) {
			e.enterClientMode(ev.Point)
			return true
		}
		return false
	}

	// ─── MODO CLIENTE ATIVO ───

	switch ev.Message {
	case 0x020A, 0x020E: // Roda Vertical ou Horizontal
		e.processarScroll(ev.Message, ev.Data)
		return true

	case 0x0200: // Move
		if e.isWarping { e.isWarping = false; return true }

		if e.scrollActive {
			// Se estiver scrollando, ignoramos movimentos por um tempo curto (touchpads)
			if time.Since(e.scrollTimer) > 250*time.Millisecond {
				e.scrollActive = false
				e.virtualX, e.virtualY = 0, 0
			}
			e.lastRawPos = ev.Point
			return true
		}

		dx, dy := ev.Point.X - e.lastRawPos.X, ev.Point.Y - e.lastRawPos.Y
		e.virtualX += dx
		e.virtualY += dy
		e.pendingDX += dx
		e.pendingDY += dy

		if e.shouldReturnToHost() {
			if time.Since(e.lastModeChange) > 800*time.Millisecond {
				e.exitClientMode()
				return true
			}
			e.virtualX, e.virtualY = 0, 0
			return true
		}

		// Park no centro para manter o mouse sobre a janela do App
		// permitindo a captura do scroll.
		w, h := e.inputHandler.GetScreenResolution()
		e.isWarping = true
		e.inputHandler.SetCursorPos(w/2, h/2) 
		e.lastRawPos = input.Point{X: w / 2, Y: h / 2}

		if time.Since(e.mouseThrottle) >= 40*time.Millisecond {
			e.mouseThrottle = time.Now()
			sdx, sdy := int8(clamp(int(e.pendingDX), -127, 127)), int8(clamp(int(e.pendingDY), -127, 127))
			e.pendingDX, e.pendingDY = 0, 0
			e.transport.SendLossy([]byte{'M', byte(sdx), byte(sdy)})
		}
		return true

	case 0x0201: e.transport.Send([]byte{'D', 'L'}); return true
	case 0x0202: e.transport.Send([]byte{'E', 'L'}); return true
	case 0x0204: e.transport.Send([]byte{'D', 'R'}); return true
	case 0x0205: e.transport.Send([]byte{'E', 'R'}); return true
	}

	return true 
}

func (e *Engine) isAtExitEdge(p input.Point) bool {
	w, h := e.inputHandler.GetScreenResolution()
	const Margin = 10
	switch e.clientPos {
	case PosLeft: return p.X <= 0
	case PosRight: return p.X >= w-Margin
	case PosAbove: return p.Y <= 0
	case PosBelow: return p.Y >= h-Margin
	}
	return false
}

func (e *Engine) shouldReturnToHost() bool {
	switch e.clientPos {
	case PosLeft: return e.virtualX > 600
	case PosRight: return e.virtualX < -500
	case PosBelow: return e.virtualY < -150
	case PosAbove: return e.virtualY > 150
	}
	return false
}

func (e *Engine) enterClientMode(p input.Point) {
	LogDebug(fmt.Sprintf("Entrando Modo Cliente em (%d, %d)", p.X, p.Y))
	e.clientMode = true
	e.edgeEntry = p
	e.lastModeChange = time.Now()
	e.virtualX, e.virtualY = 0, 0
	e.pendingDX, e.pendingDY = 0, 0
	e.wheelAccum = 0
	e.mouseThrottle = time.Now()
	
	// Foco para receber scroll da interface
	e.inputHandler.RequestFocus()

	w, h := e.inputHandler.GetScreenResolution()
	e.isWarping = true
	// Park no centro como no início
	e.inputHandler.SetCursorPos(w/2, h/2)
	e.lastRawPos = input.Point{X: w / 2, Y: h / 2}
	
	// Sem esconder cursor para teste de scroll puro
	e.inputHandler.ShowCursor(true)

	// 'A' (ReleaseAll) limpa estados presos no firmware, 'O' sinaliza LED Magenta
	e.transport.Send([]byte{'A'})
	e.transport.Send([]byte{'O'})
}

func (e *Engine) exitClientMode() {
	LogDebug("Saindo Modo Cliente.")
	e.clientMode = false
	e.lastModeChange = time.Now()
	e.inputHandler.ShowCursor(true)
	w, h := e.inputHandler.GetScreenResolution()
	var ret input.Point
	const Offset = 120
	// Retornamos o cursor exatamente para a borda onde ele entrou
	switch e.clientPos {
	case PosRight: ret = input.Point{X: w - Offset, Y: e.edgeEntry.Y}
	case PosLeft:  ret = input.Point{X: Offset, Y: e.edgeEntry.Y}
	case PosAbove: ret = input.Point{X: e.edgeEntry.X, Y: Offset}
	case PosBelow: ret = input.Point{X: e.edgeEntry.X, Y: h - Offset}
	default:       ret = input.Point{X: w / 2, Y: h / 2}
	}
	e.inputHandler.SetCursorPos(ret.X, ret.Y)
	e.transport.Send([]byte{'H'})
	e.transport.Send([]byte{'A'})
}

func (e *Engine) HandleManualScroll(delta int) {
	e.mu.Lock()
	defer e.mu.Unlock()

	if !e.clientMode || !e.transport.IsConnected() {
		return
	}

	e.scrollActive = true
	e.scrollTimer = time.Now()
	
	// Acumulamos o delta da UI para não perder movimentos pequenos
	e.wheelAccum += int32(-delta) // Invertemos o delta da UI para bater com o padrão HID

	// Divisor menor = Mais sensível
	const Divisor = 15
	toSend := e.wheelAccum / Divisor

	if toSend != 0 {
		e.wheelAccum -= toSend * Divisor
		val := int8(clamp(int(toSend), -127, 127))
		
		go func(v int8) {
			e.transport.Send([]byte{'W', byte(v)})
			LogDebug(fmt.Sprintf("UI SCROLL -> WHEEL %d (accum remain=%d)", v, e.wheelAccum))
		}(val)
	}
}

func (e *Engine) onKey(ev input.KeyboardEvent) bool {
	e.mu.Lock()
	defer e.mu.Unlock()
	if !e.transport.IsConnected() { return false }
	isDown := ev.Message == 0x0100 || ev.Message == 0x0104
	switch ev.VKCode {
	case 0xA2, 0xA3, 0x11: e.ctrlHeld = isDown
	case 0xA0, 0xA1, 0x10: e.shiftHeld = isDown
	case 0xA4, 0xA5, 0x12: e.altHeld = isDown
	}
	if !e.clientMode {
		if isDown && ev.VKCode == 0x43 && e.ctrlHeld { e.clipboardReady = true }
		return false
	}
	if isDown && ev.VKCode == 0x56 && e.ctrlHeld && e.clipboardReady {
		e.clipboardReady = false
		go e.sendClipboard()
		return true
	}
	code, ok := vkToArduino(ev.VKCode)
	if ok {
		cmd := byte('U'); if isDown { cmd = 'P' }
		e.transport.Send([]byte{cmd, code})
	}
	return true
}

func (e *Engine) sendClipboard() {
	text, _ := clipboard.ReadAll()
	if text == "" { return }
	if len(text) > 2000 { text = text[:2000] }
	data := []byte(text)
	l := len(data)
	e.transport.Send(append([]byte{'T', byte(l >> 8), byte(l & 0xFF)}, data...))
}

func clamp(v, min, max int) int {
	if v < min { return min }; if v > max { return max }; return v
}

func (e *Engine) SendCtrlAltDel() {
	LogDebug("Enviando CTRL+ALT+DEL...")
	if !e.transport.IsConnected() {
		LogDebug("Erro: Transporte não conectado.")
		return
	}
	go func() {
		e.transport.Send([]byte{'P', 0x80})
		time.Sleep(10 * time.Millisecond)
		e.transport.Send([]byte{'P', 0x82})
		time.Sleep(10 * time.Millisecond)
		e.transport.Send([]byte{'P', 0xD4})
		time.Sleep(100 * time.Millisecond)
		e.transport.Send([]byte{'U', 0xD4})
		time.Sleep(10 * time.Millisecond)
		e.transport.Send([]byte{'U', 0x82})
		time.Sleep(10 * time.Millisecond)
		e.transport.Send([]byte{'U', 0x80})
		LogDebug("Sequência CTRL+ALT+DEL enviada.")
	}()
}

func (e *Engine) SetPosition(pos int) {
	e.mu.Lock()
	defer e.mu.Unlock()
	e.clientPos = ClientPos(pos)
}

func (e *Engine) SetLayout(layout int) {
	e.mu.Lock()
	defer e.mu.Unlock()
	e.clientLayout = ClientLayout(layout)
}

var keyMap = map[uint32]byte{
	0xA0: 0x81, 0xA1: 0x85, 0xA2: 0x80, 0xA3: 0x84, 0xA4: 0x82, 0xA5: 0x86, 0x5B: 0x83, 0x5C: 0x87,
	0x10: 0x81, 0x11: 0x80, 0x12: 0x82, 0x70: 0xC2, 0x71: 0xC3, 0x72: 0xC4, 0x73: 0xC5, 0x74: 0xC6,
	0x75: 0xC7, 0x76: 0xC8, 0x77: 0xC9, 0x78: 0xCA, 0x79: 0xCB, 0x7A: 0xCC, 0x7B: 0xCD, 0x26: 0xDA,
	0x28: 0xD9, 0x25: 0xD8, 0x27: 0xD7, 0x24: 0xD2, 0x23: 0xD5, 0x21: 0xD3, 0x22: 0xD6, 0x2D: 0xD1,
	0x2E: 0xD4, 0x0D: 0xB0, 0x1B: 0xB1, 0x08: 0xB2, 0x09: 0xB3, 0x14: 0xC1, 0x2C: 0xCE, 0x91: 0xCF, 0x13: 0xD0,
}

func vkToArduino(vk uint32) (byte, bool) {
	if m, ok := keyMap[vk]; ok { return m, true }
	if vk >= 0x41 && vk <= 0x5A { return byte(vk + 0x20), true }
	if vk >= 0x30 && vk <= 0x39 { return byte(vk), true }
	if vk >= 0x60 && vk <= 0x69 { return byte('0' + vk - 0x60), true }
	switch vk {
	case 0x20: return ' ', true; case 0xBD: return '-', true; case 0xBB: return '=', true
	case 0xDB: return '[', true; case 0xDD: return ']', true; case 0xDC: return '\\', true
	case 0xBA: return ';', true; case 0xDE: return '\'', true; case 0xBC: return ',', true
	case 0xBE: return '.', true; case 0xBF: return '/', true; case 0xC0: return '`', true
	case 0xE2: return 0xEC, true
	}
	return 0, false
}