//go:build darwin

package input

/*
#cgo CFLAGS: -x objective-c
#cgo LDFLAGS: -framework AppKit -framework CoreGraphics -framework Carbon -framework ApplicationServices
#include <AppKit/AppKit.h>
#include <CoreGraphics/CoreGraphics.h>
#include <Carbon/Carbon.h>
#include <ApplicationServices/ApplicationServices.h>
#include <stdlib.h>
#include <string.h>

static int ensureInputPermission(void) {
    NSDictionary* opts = @{(__bridge NSString*)kAXTrustedCheckOptionPrompt: @YES};
    return AXIsProcessTrustedWithOptions((__bridge CFDictionaryRef)opts) ? 1 : 0;
}

static void setClipboardText(const char* text) {
    NSPasteboard* pb = [NSPasteboard generalPasteboard];
    [pb clearContents];
    NSString* str = [NSString stringWithUTF8String:text];
    [pb setString:str forType:NSPasteboardTypeString];
}

static void clearClipboardText(void) {
    NSPasteboard* pb = [NSPasteboard generalPasteboard];
    [pb clearContents];
}

static char* getClipboardText(void) {
    NSPasteboard* pb = [NSPasteboard generalPasteboard];
    NSString* str = [pb stringForType:NSPasteboardTypeString];
    if (!str) return NULL;
    const char* utf8 = [str UTF8String];
    if (!utf8) return NULL;
    return strdup(utf8);
}

static void simulateCmdV() {
    CGEventSourceRef source = CGEventSourceCreate(kCGEventSourceStateCombinedSessionState);

    CGEventRef cmdDown = CGEventCreateKeyboardEvent(source, (CGKeyCode)kVK_Command, true);
    CGEventSetFlags(cmdDown, kCGEventFlagMaskCommand);
    CGEventPost(kCGHIDEventTap, cmdDown);

    CGEventRef vDown = CGEventCreateKeyboardEvent(source, (CGKeyCode)kVK_ANSI_V, true);
    CGEventSetFlags(vDown, kCGEventFlagMaskCommand);
    CGEventPost(kCGHIDEventTap, vDown);

    CGEventRef vUp = CGEventCreateKeyboardEvent(source, (CGKeyCode)kVK_ANSI_V, false);
    CGEventSetFlags(vUp, kCGEventFlagMaskCommand);
    CGEventPost(kCGHIDEventTap, vUp);

    CGEventRef cmdUp = CGEventCreateKeyboardEvent(source, (CGKeyCode)kVK_Command, false);
    CGEventSetFlags(cmdUp, 0);
    CGEventPost(kCGHIDEventTap, cmdUp);

    CFRelease(cmdDown);
    CFRelease(vDown);
    CFRelease(vUp);
    CFRelease(cmdUp);
    CFRelease(source);
}

static void typeUnicodeChar(unsigned int codepoint) {
    CGEventSourceRef source = CGEventSourceCreate(kCGEventSourceStateCombinedSessionState);
    UniChar chars[2];
    int len = 0;

    if (codepoint <= 0xFFFF) {
        chars[0] = (UniChar)codepoint;
        len = 1;
    } else {
        codepoint -= 0x10000;
        chars[0] = (UniChar)(0xD800 + (codepoint >> 10));
        chars[1] = (UniChar)(0xDC00 + (codepoint & 0x3FF));
        len = 2;
    }

    CGEventRef keyDown = CGEventCreateKeyboardEvent(source, 0, true);
    CGEventKeyboardSetUnicodeString(keyDown, len, chars);
    CGEventPost(kCGHIDEventTap, keyDown);

    CGEventRef keyUp = CGEventCreateKeyboardEvent(source, 0, false);
    CGEventKeyboardSetUnicodeString(keyUp, len, chars);
    CGEventPost(kCGHIDEventTap, keyUp);

    CFRelease(keyDown);
    CFRelease(keyUp);
    CFRelease(source);
}
*/
import "C"

import (
	"fmt"
	"sync"
	"time"
	"unsafe"
	"voicesnap/internal/logger"
)

const (
	darwinClipboardVerifyTimeout = 500 * time.Millisecond
	darwinClipboardPollInterval  = 15 * time.Millisecond
	darwinClipboardRestoreDelay  = 900 * time.Millisecond
)

type darwinPaster struct{}

type darwinClipboardSnapshot struct {
	text    string
	hasText bool
}

type darwinPasteState struct {
	mu             sync.Mutex
	generation     uint64
	pendingRestore bool
	pendingText    string
	restoreTo      darwinClipboardSnapshot
}

var globalDarwinPasteState darwinPasteState

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

func (p *darwinPaster) Paste(text string, keepClipboard bool) error {
	pasteStart := time.Now()
	textRunes := len([]rune(text))

	permissionStart := time.Now()
	if C.ensureInputPermission() == 0 {
		logger.Info(
			"PERF paste_clipboard_done result=permission_error permission_ms=%d text_runes=%d keep_clipboard=%t total_ms=%d",
			time.Since(permissionStart).Milliseconds(),
			textRunes,
			keepClipboard,
			time.Since(pasteStart).Milliseconds(),
		)
		return fmt.Errorf("accessibility permission is required to paste")
	}
	permissionElapsed := time.Since(permissionStart)

	state := &globalDarwinPasteState
	stateLockStart := time.Now()
	state.mu.Lock()
	stateLockElapsed := time.Since(stateLockStart)
	state.generation++
	generation := state.generation

	snapshotStart := time.Now()
	originalClipboard := currentDarwinClipboardSnapshot()
	if !keepClipboard {
		originalClipboard = resolveDarwinRestoreTarget(
			originalClipboard,
			state.pendingRestore,
			state.pendingText,
			state.restoreTo,
		)
	}
	snapshotElapsed := time.Since(snapshotStart)

	cstr := C.CString(text)
	defer C.free(unsafe.Pointer(cstr))
	setClipboardStart := time.Now()
	C.setClipboardText(cstr)
	setClipboardElapsed := time.Since(setClipboardStart)

	verifyStart := time.Now()
	if !waitForDarwinClipboardText(text, darwinClipboardVerifyTimeout) {
		verifyElapsed := time.Since(verifyStart)
		state.pendingRestore = false
		state.mu.Unlock()
		logger.Info(
			"PERF paste_clipboard_done result=verify_failed permission_ms=%d state_lock_ms=%d snapshot_ms=%d set_ms=%d verify_ms=%d text_runes=%d keep_clipboard=%t total_ms=%d",
			permissionElapsed.Milliseconds(),
			stateLockElapsed.Milliseconds(),
			snapshotElapsed.Milliseconds(),
			setClipboardElapsed.Milliseconds(),
			verifyElapsed.Milliseconds(),
			textRunes,
			keepClipboard,
			time.Since(pasteStart).Milliseconds(),
		)
		return fmt.Errorf("clipboard verification failed before paste")
	}
	verifyElapsed := time.Since(verifyStart)

	cmdVStart := time.Now()
	C.simulateCmdV()
	cmdVElapsed := time.Since(cmdVStart)

	if keepClipboard {
		state.pendingRestore = false
		state.mu.Unlock()
		logger.Info(
			"PERF paste_clipboard_done result=success permission_ms=%d state_lock_ms=%d snapshot_ms=%d set_ms=%d verify_ms=%d cmdv_ms=%d text_runes=%d keep_clipboard=%t total_ms=%d",
			permissionElapsed.Milliseconds(),
			stateLockElapsed.Milliseconds(),
			snapshotElapsed.Milliseconds(),
			setClipboardElapsed.Milliseconds(),
			verifyElapsed.Milliseconds(),
			cmdVElapsed.Milliseconds(),
			textRunes,
			keepClipboard,
			time.Since(pasteStart).Milliseconds(),
		)
		return nil
	}

	state.pendingRestore = true
	state.pendingText = text
	state.restoreTo = originalClipboard
	state.mu.Unlock()

	go restoreDarwinClipboardAfterPaste(generation, text, originalClipboard)
	logger.Info(
		"PERF paste_clipboard_done result=success permission_ms=%d state_lock_ms=%d snapshot_ms=%d set_ms=%d verify_ms=%d cmdv_ms=%d text_runes=%d keep_clipboard=%t total_ms=%d",
		permissionElapsed.Milliseconds(),
		stateLockElapsed.Milliseconds(),
		snapshotElapsed.Milliseconds(),
		setClipboardElapsed.Milliseconds(),
		verifyElapsed.Milliseconds(),
		cmdVElapsed.Milliseconds(),
		textRunes,
		keepClipboard,
		time.Since(pasteStart).Milliseconds(),
	)
	return nil
}

func (p *darwinPaster) TypeText(text string) error {
	if C.ensureInputPermission() == 0 {
		return fmt.Errorf("accessibility permission is required to type")
	}
	for _, r := range text {
		C.typeUnicodeChar(C.uint(r))
	}
	return nil
}

func currentDarwinClipboardSnapshot() darwinClipboardSnapshot {
	cText := C.getClipboardText()
	if cText == nil {
		return darwinClipboardSnapshot{}
	}
	defer C.free(unsafe.Pointer(cText))
	return darwinClipboardSnapshot{
		text:    C.GoString(cText),
		hasText: true,
	}
}

func resolveDarwinRestoreTarget(current darwinClipboardSnapshot, pending bool, pendingText string, restoreTo darwinClipboardSnapshot) darwinClipboardSnapshot {
	if pending && current.hasText && current.text == pendingText {
		return restoreTo
	}
	return current
}

func waitForDarwinClipboardText(expected string, timeout time.Duration) bool {
	deadline := time.Now().Add(timeout)
	for {
		current := currentDarwinClipboardSnapshot()
		if current.hasText && current.text == expected {
			return true
		}
		if time.Now().After(deadline) {
			return false
		}
		time.Sleep(darwinClipboardPollInterval)
	}
}

func restoreDarwinClipboardAfterPaste(generation uint64, pastedText string, restoreTo darwinClipboardSnapshot) {
	time.Sleep(darwinClipboardRestoreDelay)

	state := &globalDarwinPasteState
	state.mu.Lock()
	defer state.mu.Unlock()

	if state.generation != generation || !state.pendingRestore || state.pendingText != pastedText {
		return
	}

	current := currentDarwinClipboardSnapshot()
	if !shouldRestoreDarwinClipboard(
		state.generation,
		generation,
		state.pendingRestore,
		state.pendingText,
		pastedText,
		current,
	) {
		state.pendingRestore = false
		return
	}

	restoreDarwinClipboardSnapshot(restoreTo)
	state.pendingRestore = false
}

func shouldRestoreDarwinClipboard(currentGeneration, restoreGeneration uint64, pending bool, pendingText, pastedText string, current darwinClipboardSnapshot) bool {
	if currentGeneration != restoreGeneration || !pending || pendingText != pastedText {
		return false
	}
	return current.hasText && current.text == pastedText
}

func restoreDarwinClipboardSnapshot(snapshot darwinClipboardSnapshot) {
	if !snapshot.hasText {
		C.clearClipboardText()
		return
	}

	cText := C.CString(snapshot.text)
	defer C.free(unsafe.Pointer(cText))
	C.setClipboardText(cText)
}