//go:build windows

package input

import (
	"fmt"
	"syscall"
	"time"
	"unsafe"
)

var (
	user32                         = syscall.NewLazyDLL("user32.dll")
	kernel32                       = syscall.NewLazyDLL("kernel32.dll")
	procOpenClipboard              = user32.NewProc("OpenClipboard")
	procCloseClipboard             = user32.NewProc("CloseClipboard")
	procEmptyClipboard             = user32.NewProc("EmptyClipboard")
	procSetClipboardData           = user32.NewProc("SetClipboardData")
	procGetClipboardData           = user32.NewProc("GetClipboardData")
	procIsClipboardFormatAvailable = user32.NewProc("IsClipboardFormatAvailable")
	procSendInput                  = user32.NewProc("SendInput")
	procGlobalAlloc                = kernel32.NewProc("GlobalAlloc")
	procGlobalLock                 = kernel32.NewProc("GlobalLock")
	procGlobalUnlock               = kernel32.NewProc("GlobalUnlock")
	procGlobalSize                 = kernel32.NewProc("GlobalSize")
)

const (
	cfUnicodeText    = 13
	gmemMoveable     = 0x0002
	inputKeyboard    = 1
	keyeventfKeyUp   = 0x0002
	keyeventfUnicode = 0x0004
	vkControl        = 0x11
	vkV              = 0x56
)

type keyboardInput struct {
	wVk         uint16
	wScan       uint16
	dwFlags     uint32
	time        uint32
	dwExtraInfo uintptr
}

type input struct {
	inputType uint32
	ki        keyboardInput
	padding   [8]byte // Alignment padding
}

type windowsPaster struct{}

func newPlatformPaster() Paster {
	return &windowsPaster{}
}

func (p *windowsPaster) Paste(text string, keepClipboard bool) error {
	// Save original clipboard content
	var oldClip *string
	if !keepClipboard {
		oldClip = getClipboardText()
	}

	if err := setClipboard(text); err != nil {
		return err
	}

	// Simulate Ctrl+V
	inputs := []input{
		makeKeyInput(vkControl, 0, 0),
		makeKeyInput(vkV, 0, 0),
		makeKeyInput(vkV, 0, keyeventfKeyUp),
		makeKeyInput(vkControl, 0, keyeventfKeyUp),
	}

	ret, _, err := procSendInput.Call(
		uintptr(len(inputs)),
		uintptr(unsafe.Pointer(&inputs[0])),
		uintptr(unsafe.Sizeof(inputs[0])),
	)
	if ret == 0 {
		return fmt.Errorf("SendInput failed: %v", err)
	}

	// Restore original clipboard after a short delay (let Ctrl+V complete)
	if oldClip != nil {
		go func() {
			time.Sleep(300 * time.Millisecond)
			setClipboard(*oldClip)
		}()
	}

	return nil
}

func (p *windowsPaster) TypeText(text string) error {
	runes := []rune(text)
	inputs := make([]input, len(runes)*2)

	for i, r := range runes {
		// Key down
		inputs[i*2] = input{
			inputType: inputKeyboard,
			ki: keyboardInput{
				wVk:     0,
				wScan:   uint16(r),
				dwFlags: keyeventfUnicode,
			},
		}
		// Key up
		inputs[i*2+1] = input{
			inputType: inputKeyboard,
			ki: keyboardInput{
				wVk:     0,
				wScan:   uint16(r),
				dwFlags: keyeventfUnicode | keyeventfKeyUp,
			},
		}
	}

	ret, _, err := procSendInput.Call(
		uintptr(len(inputs)),
		uintptr(unsafe.Pointer(&inputs[0])),
		uintptr(unsafe.Sizeof(inputs[0])),
	)
	if ret == 0 {
		return fmt.Errorf("SendInput (unicode) failed: %v", err)
	}
	return nil
}

// getClipboardText reads the current clipboard text, returns nil if empty or non-text.
func getClipboardText() *string {
	ret, _, _ := procIsClipboardFormatAvailable.Call(cfUnicodeText)
	if ret == 0 {
		return nil
	}

	for i := 0; i < 5; i++ {
		ret, _, _ := procOpenClipboard.Call(0)
		if ret != 0 {
			hMem, _, _ := procGetClipboardData.Call(cfUnicodeText)
			if hMem == 0 {
				procCloseClipboard.Call()
				return nil
			}

			size, _, _ := procGlobalSize.Call(hMem)
			if size == 0 {
				procCloseClipboard.Call()
				return nil
			}

			ptr, _, _ := procGlobalLock.Call(hMem)
			if ptr == 0 {
				procCloseClipboard.Call()
				return nil
			}

			// Read UTF-16 string
			text := syscall.UTF16ToString((*[1 << 20]uint16)(unsafe.Pointer(ptr))[:size/2])
			procGlobalUnlock.Call(hMem)
			procCloseClipboard.Call()
			return &text
		}
		time.Sleep(30 * time.Millisecond)
	}
	return nil
}

func setClipboard(text string) error {
	// Retry opening clipboard up to 10 times
	for i := 0; i < 10; i++ {
		ret, _, _ := procOpenClipboard.Call(0)
		if ret != 0 {
			defer procCloseClipboard.Call()

			procEmptyClipboard.Call()

			utf16 := syscall.StringToUTF16(text)
			size := len(utf16) * 2

			hMem, _, _ := procGlobalAlloc.Call(gmemMoveable, uintptr(size))
			if hMem == 0 {
				return fmt.Errorf("GlobalAlloc failed")
			}

			ptr, _, _ := procGlobalLock.Call(hMem)
			if ptr == 0 {
				return fmt.Errorf("GlobalLock failed")
			}

			// Copy UTF-16 data
			src := unsafe.Pointer(&utf16[0])
			dst := unsafe.Pointer(ptr)
			copy((*[1 << 30]byte)(dst)[:size], (*[1 << 30]byte)(src)[:size])

			procGlobalUnlock.Call(hMem)
			procSetClipboardData.Call(cfUnicodeText, hMem)

			return nil
		}
		time.Sleep(50 * time.Millisecond)
	}
	return fmt.Errorf("failed to open clipboard after 10 attempts")
}

func makeKeyInput(vk uint16, scan uint16, flags uint32) input {
	return input{
		inputType: inputKeyboard,
		ki: keyboardInput{
			wVk:     vk,
			wScan:   scan,
			dwFlags: flags,
		},
	}
}