//go:build windows

package main

import (
	"fmt"
	"io"
	"runtime"
	"strconv"
	"strings"
	"sync"
	"syscall"
	"unsafe"
)

const (
	windowTitle = "D-InSAR 数据包恢复工具"

	wmDestroy = 0x0002
	wmCommand = 0x0111
	wmClose   = 0x0010
	wmSetFont = 0x0030

	bnClicked = 0

	wsOverlappedWindow = 0x00CF0000
	wsVisible          = 0x10000000
	wsChild            = 0x40000000
	wsTabStop          = 0x00010000
	wsBorder           = 0x00800000
	wsVScroll          = 0x00200000
	wsHScroll          = 0x00100000
	esLeft             = 0x0000
	esMultiline        = 0x0004
	esAutoVScroll      = 0x0040
	esAutoHScroll      = 0x0080
	esReadOnly         = 0x0800
	bsPushButton       = 0x00000000
	bsAutoCheckBox     = 0x00000003

	swShow       = 5
	cwUseDefault = 0x80000000

	gwlUserData = -21

	idInputEdit    = 1001
	idInputBrowse  = 1002
	idOutputEdit   = 1003
	idOutputBrowse = 1004
	idDryRun       = 1005
	idOverwrite    = 1006
	idLimitEdit    = 1007
	idStart        = 1008
	idLogEdit      = 1009
	idCheck        = 1010

	bmGetCheck = 0x00F0
	bstChecked = 1

	maxPathBuffer = 4096
)

var (
	user32   = syscall.NewLazyDLL("user32.dll")
	kernel32 = syscall.NewLazyDLL("kernel32.dll")
	gdi32    = syscall.NewLazyDLL("gdi32.dll")
	shell32  = syscall.NewLazyDLL("shell32.dll")
	ole32    = syscall.NewLazyDLL("ole32.dll")

	procRegisterClassExW  = user32.NewProc("RegisterClassExW")
	procCreateWindowExW   = user32.NewProc("CreateWindowExW")
	procDefWindowProcW    = user32.NewProc("DefWindowProcW")
	procDestroyWindow     = user32.NewProc("DestroyWindow")
	procDispatchMessageW  = user32.NewProc("DispatchMessageW")
	procGetMessageW       = user32.NewProc("GetMessageW")
	procPostQuitMessage   = user32.NewProc("PostQuitMessage")
	procSendMessageW      = user32.NewProc("SendMessageW")
	procShowWindow        = user32.NewProc("ShowWindow")
	procUpdateWindow      = user32.NewProc("UpdateWindow")
	procSetWindowTextW    = user32.NewProc("SetWindowTextW")
	procGetWindowTextW    = user32.NewProc("GetWindowTextW")
	procGetWindowTextLenW = user32.NewProc("GetWindowTextLengthW")
	procEnableWindow      = user32.NewProc("EnableWindow")
	procSetWindowLongPtrW = user32.NewProc("SetWindowLongPtrW")
	procGetWindowLongPtrW = user32.NewProc("GetWindowLongPtrW")
	procMessageBoxW       = user32.NewProc("MessageBoxW")

	procGetModuleHandleW = kernel32.NewProc("GetModuleHandleW")

	procCreateFontW = gdi32.NewProc("CreateFontW")

	procSHBrowseForFolderW   = shell32.NewProc("SHBrowseForFolderW")
	procSHGetPathFromIDListW = shell32.NewProc("SHGetPathFromIDListW")
	procCoTaskMemFree        = ole32.NewProc("CoTaskMemFree")
	procOleInitialize        = ole32.NewProc("OleInitialize")
	procOleUninitialize      = ole32.NewProc("OleUninitialize")
)

type point struct {
	x int32
	y int32
}

type msg struct {
	hwnd    uintptr
	message uint32
	wParam  uintptr
	lParam  uintptr
	time    uint32
	pt      point
}

type wndClassEx struct {
	cbSize        uint32
	style         uint32
	lpfnWndProc   uintptr
	cbClsExtra    int32
	cbWndExtra    int32
	hInstance     uintptr
	hIcon         uintptr
	hCursor       uintptr
	hbrBackground uintptr
	lpszMenuName  *uint16
	lpszClassName *uint16
	hIconSm       uintptr
}

type browseInfo struct {
	hwndOwner      uintptr
	pidlRoot       uintptr
	pszDisplayName *uint16
	lpszTitle      *uint16
	ulFlags        uint32
	lpfn           uintptr
	lParam         uintptr
	iImage         int32
}

type guiApp struct {
	hwnd        uintptr
	font        uintptr
	inputEdit   uintptr
	outputEdit  uintptr
	dryRun      uintptr
	overwrite   uintptr
	limitEdit   uintptr
	startButton uintptr
	checkButton uintptr
	logEdit     uintptr
	mu          sync.Mutex
	logText     string
	running     bool
}

func runGUI() error {
	runtime.LockOSThread()
	defer runtime.UnlockOSThread()
	procOleInitialize.Call(0)
	defer procOleUninitialize.Call()

	instance, _, _ := procGetModuleHandleW.Call(0)
	className, _ := syscall.UTF16PtrFromString("DinsarRestoreWindow")
	title, _ := syscall.UTF16PtrFromString(windowTitle)

	wc := wndClassEx{
		cbSize:        uint32(unsafe.Sizeof(wndClassEx{})),
		lpfnWndProc:   syscall.NewCallback(windowProc),
		hInstance:     instance,
		hbrBackground: 5 + 1,
		lpszClassName: className,
	}
	if atom, _, err := procRegisterClassExW.Call(uintptr(unsafe.Pointer(&wc))); atom == 0 {
		return fmt.Errorf("RegisterClassExW failed: %v", err)
	}

	app := &guiApp{}
	hwnd, _, err := procCreateWindowExW.Call(
		0,
		uintptr(unsafe.Pointer(className)),
		uintptr(unsafe.Pointer(title)),
		wsOverlappedWindow|wsVisible,
		cwUseDefault,
		cwUseDefault,
		1040,
		720,
		0,
		0,
		instance,
		uintptr(unsafe.Pointer(app)),
	)
	if hwnd == 0 {
		return fmt.Errorf("CreateWindowExW failed: %v", err)
	}
	app.hwnd = hwnd

	procShowWindow.Call(hwnd, swShow)
	procUpdateWindow.Call(hwnd)

	var m msg
	for {
		ret, _, _ := procGetMessageW.Call(uintptr(unsafe.Pointer(&m)), 0, 0, 0)
		if int32(ret) <= 0 {
			break
		}
		procDispatchMessageW.Call(uintptr(unsafe.Pointer(&m)))
	}
	return nil
}

func windowProc(hwnd uintptr, msg uint32, wParam uintptr, lParam uintptr) uintptr {
	app := appFromWindow(hwnd)
	switch msg {
	case wmClose:
		if app != nil && app.isRunning() {
			messageBox(hwnd, "任务正在运行，请等待结束。", windowTitle)
			return 0
		}
		procDestroyWindow.Call(hwnd)
		return 0
	case wmDestroy:
		procPostQuitMessage.Call(0)
		return 0
	case wmCommand:
		id := int(wParam & 0xffff)
		notify := int((wParam >> 16) & 0xffff)
		if notify == bnClicked && app != nil {
			switch id {
			case idInputBrowse:
				if selected := chooseDirectory(hwnd, "选择 BundleRoot 输入目录"); selected != "" {
					setWindowText(app.inputEdit, selected)
				}
			case idOutputBrowse:
				if selected := chooseDirectory(hwnd, "选择 OutputRoot 输出目录"); selected != "" {
					setWindowText(app.outputEdit, selected)
				}
			case idStart:
				app.startRestore()
			case idCheck:
				app.startCheck()
			}
		}
		return 0
	case 0x0081: // WM_NCCREATE
		cs := (*createStruct)(unsafe.Pointer(lParam))
		procSetWindowLongPtrW.Call(hwnd, winIndex(gwlUserData), cs.createParams)
		return 1
	case 0x0001: // WM_CREATE
		app = appFromWindow(hwnd)
		if app != nil {
			app.hwnd = hwnd
			app.createControls()
		}
		return 0
	}
	ret, _, _ := procDefWindowProcW.Call(hwnd, uintptr(msg), wParam, lParam)
	return ret
}

type createStruct struct {
	createParams uintptr
	instance     uintptr
	menu         uintptr
	parent       uintptr
	cy           int32
	cx           int32
	y            int32
	x            int32
	style        int32
	name         *uint16
	class        *uint16
	exStyle      uint32
}

func appFromWindow(hwnd uintptr) *guiApp {
	if hwnd == 0 {
		return nil
	}
	ptr, _, _ := procGetWindowLongPtrW.Call(hwnd, winIndex(gwlUserData))
	if ptr == 0 {
		return nil
	}
	return (*guiApp)(unsafe.Pointer(ptr))
}

func (a *guiApp) createControls() {
	a.font = createFont("Microsoft YaHei UI", 20)

	createLabel(a.hwnd, "输入目录 BundleRoot", 24, 28, 210, 30, a.font)
	a.inputEdit = createEdit(a.hwnd, "", idInputEdit, 240, 24, 640, 34, false, a.font)
	createButton(a.hwnd, "选择...", idInputBrowse, 895, 24, 100, 34, a.font)

	createLabel(a.hwnd, "输出目录 OutputRoot", 24, 78, 210, 30, a.font)
	a.outputEdit = createEdit(a.hwnd, "", idOutputEdit, 240, 74, 640, 34, false, a.font)
	createButton(a.hwnd, "选择...", idOutputBrowse, 895, 74, 100, 34, a.font)

	a.dryRun = createCheckBox(a.hwnd, "Dry run 只打印计划", idDryRun, 240, 128, 230, 32, a.font)
	a.overwrite = createCheckBox(a.hwnd, "覆盖已有 Task", idOverwrite, 500, 128, 190, 32, a.font)
	createLabel(a.hwnd, "Limit", 720, 130, 60, 30, a.font)
	a.limitEdit = createEdit(a.hwnd, "", idLimitEdit, 780, 126, 100, 34, false, a.font)

	a.checkButton = createButton(a.hwnd, "数据自检", idCheck, 760, 174, 105, 38, a.font)
	a.startButton = createButton(a.hwnd, "开始恢复", idStart, 890, 174, 105, 38, a.font)
	createLabel(a.hwnd, "运行日志", 24, 226, 140, 30, a.font)
	a.logEdit = createEdit(a.hwnd, "", idLogEdit, 24, 262, 970, 365, true, a.font)

	a.appendLog("请选择输入目录后可先数据自检；选择输出目录后可开始恢复。\r\n")
}

func (a *guiApp) startRestore() {
	if a.isRunning() {
		return
	}

	input := strings.TrimSpace(getWindowText(a.inputEdit))
	output := strings.TrimSpace(getWindowText(a.outputEdit))
	if input == "" {
		messageBox(a.hwnd, "请选择输入目录 BundleRoot。", windowTitle)
		return
	}
	if output == "" {
		messageBox(a.hwnd, "请选择输出目录 OutputRoot。", windowTitle)
		return
	}
	limit, ok := a.parseLimit()
	if !ok {
		return
	}

	cfg := config{
		inputRoot:    input,
		outputRoot:   output,
		skipExisting: true,
		overwrite:    isChecked(a.overwrite),
		limit:        limit,
		dryRun:       isChecked(a.dryRun),
		logWriter:    guiLogWriter{app: a},
	}
	if cfg.overwrite {
		cfg.skipExisting = false
	}

	a.setRunning(true)
	a.setLog("")
	a.appendLog("开始执行...\r\n")
	go func() {
		result, err := run(cfg)
		if err != nil {
			a.appendLog("错误: " + err.Error() + "\r\n")
			messageBox(a.hwnd, "执行失败：\r\n"+err.Error(), windowTitle)
		} else {
			a.appendLog(fmt.Sprintf("完成: restored=%d skipped=%d failed=%d warnings=%d\r\n",
				result.report.Restored,
				result.report.Skipped,
				result.report.Failed,
				len(result.report.Warnings),
			))
			messageBox(a.hwnd, "执行完成。", windowTitle)
		}
		a.setRunning(false)
	}()
}

func (a *guiApp) startCheck() {
	if a.isRunning() {
		return
	}

	input := strings.TrimSpace(getWindowText(a.inputEdit))
	if input == "" {
		messageBox(a.hwnd, "请选择输入目录 BundleRoot。", windowTitle)
		return
	}
	limit, ok := a.parseLimit()
	if !ok {
		return
	}

	cfg := config{
		inputRoot: input,
		limit:     limit,
		checkOnly: true,
		logWriter: guiLogWriter{app: a},
	}

	a.setRunning(true)
	a.setLog("")
	a.appendLog("开始数据自检...\r\n")
	go func() {
		result, err := runCheck(cfg)
		if err != nil {
			a.appendLog("错误: " + err.Error() + "\r\n")
			messageBox(a.hwnd, "自检失败：\r\n"+err.Error(), windowTitle)
		} else if result.report.Failed > 0 {
			a.appendLog(fmt.Sprintf("自检完成: total=%d checked=%d valid=%d failed=%d warnings=%d\r\n",
				result.report.TotalPairs,
				result.report.Checked,
				result.report.Valid,
				result.report.Failed,
				len(result.report.Warnings),
			))
			messageBox(a.hwnd, fmt.Sprintf("自检完成，但发现 %d 个失败项。请查看日志。", result.report.Failed), windowTitle)
		} else {
			a.appendLog(fmt.Sprintf("自检通过: total=%d checked=%d valid=%d warnings=%d\r\n",
				result.report.TotalPairs,
				result.report.Checked,
				result.report.Valid,
				len(result.report.Warnings),
			))
			messageBox(a.hwnd, "自检通过。", windowTitle)
		}
		a.setRunning(false)
	}()
}

func (a *guiApp) parseLimit() (int, bool) {
	limitText := strings.TrimSpace(getWindowText(a.limitEdit))
	if limitText == "" {
		return 0, true
	}
	parsed, err := strconv.Atoi(limitText)
	if err != nil || parsed < 0 {
		messageBox(a.hwnd, "Limit 必须是大于等于 0 的整数。", windowTitle)
		return 0, false
	}
	return parsed, true
}

func (a *guiApp) isRunning() bool {
	a.mu.Lock()
	defer a.mu.Unlock()
	return a.running
}

func (a *guiApp) setRunning(running bool) {
	a.mu.Lock()
	a.running = running
	a.mu.Unlock()
	enable := uintptr(1)
	if running {
		enable = 0
	}
	procEnableWindow.Call(a.startButton, enable)
	procEnableWindow.Call(a.checkButton, enable)
	procEnableWindow.Call(a.inputEdit, enable)
	procEnableWindow.Call(a.outputEdit, enable)
	procEnableWindow.Call(a.dryRun, enable)
	procEnableWindow.Call(a.overwrite, enable)
	procEnableWindow.Call(a.limitEdit, enable)
}

func (a *guiApp) setLog(text string) {
	a.mu.Lock()
	a.logText = text
	a.mu.Unlock()
	setWindowText(a.logEdit, text)
}

func (a *guiApp) appendLog(text string) {
	a.mu.Lock()
	a.logText += text
	fullText := a.logText
	a.mu.Unlock()
	setWindowText(a.logEdit, fullText)
}

type guiLogWriter struct {
	app *guiApp
}

func (w guiLogWriter) Write(p []byte) (int, error) {
	if w.app != nil {
		w.app.appendLog(strings.ReplaceAll(string(p), "\n", "\r\n"))
	}
	return len(p), nil
}

func createLabel(parent uintptr, text string, x, y, width, height int32, font uintptr) uintptr {
	return createControl("STATIC", text, wsChild|wsVisible, 0, parent, 0, x, y, width, height, font)
}

func createEdit(parent uintptr, text string, id int, x, y, width, height int32, multiline bool, font uintptr) uintptr {
	style := uint32(wsChild | wsVisible | wsBorder | wsTabStop | esLeft | esAutoHScroll)
	if multiline {
		style = wsChild | wsVisible | wsBorder | wsVScroll | wsHScroll | esLeft | esMultiline | esAutoVScroll | esAutoHScroll | esReadOnly
	}
	return createControl("EDIT", text, style, 0, parent, id, x, y, width, height, font)
}

func createButton(parent uintptr, text string, id int, x, y, width, height int32, font uintptr) uintptr {
	return createControl("BUTTON", text, wsChild|wsVisible|wsTabStop|bsPushButton, 0, parent, id, x, y, width, height, font)
}

func createCheckBox(parent uintptr, text string, id int, x, y, width, height int32, font uintptr) uintptr {
	return createControl("BUTTON", text, wsChild|wsVisible|wsTabStop|bsAutoCheckBox, 0, parent, id, x, y, width, height, font)
}

func createControl(className string, text string, style uint32, exStyle uint32, parent uintptr, id int, x, y, width, height int32, font uintptr) uintptr {
	classPtr, _ := syscall.UTF16PtrFromString(className)
	textPtr, _ := syscall.UTF16PtrFromString(text)
	hwnd, _, _ := procCreateWindowExW.Call(
		uintptr(exStyle),
		uintptr(unsafe.Pointer(classPtr)),
		uintptr(unsafe.Pointer(textPtr)),
		uintptr(style),
		uintptr(x),
		uintptr(y),
		uintptr(width),
		uintptr(height),
		parent,
		uintptr(id),
		0,
		0,
	)
	if hwnd != 0 && font != 0 {
		procSendMessageW.Call(hwnd, wmSetFont, font, 1)
	}
	return hwnd
}

func createFont(name string, size int32) uintptr {
	namePtr, _ := syscall.UTF16PtrFromString(name)
	font, _, _ := procCreateFontW.Call(
		uintptr(-size),
		0,
		0,
		0,
		400,
		0,
		0,
		0,
		1,
		0,
		0,
		0,
		0,
		uintptr(unsafe.Pointer(namePtr)),
	)
	return font
}

func setWindowText(hwnd uintptr, text string) {
	ptr, _ := syscall.UTF16PtrFromString(text)
	procSetWindowTextW.Call(hwnd, uintptr(unsafe.Pointer(ptr)))
}

func getWindowText(hwnd uintptr) string {
	length, _, _ := procGetWindowTextLenW.Call(hwnd)
	buffer := make([]uint16, int(length)+1)
	procGetWindowTextW.Call(hwnd, uintptr(unsafe.Pointer(&buffer[0])), uintptr(len(buffer)))
	return syscall.UTF16ToString(buffer)
}

func isChecked(hwnd uintptr) bool {
	ret, _, _ := procSendMessageW.Call(hwnd, bmGetCheck, 0, 0)
	return ret == bstChecked
}

func messageBox(hwnd uintptr, text string, title string) {
	textPtr, _ := syscall.UTF16PtrFromString(text)
	titlePtr, _ := syscall.UTF16PtrFromString(title)
	procMessageBoxW.Call(hwnd, uintptr(unsafe.Pointer(textPtr)), uintptr(unsafe.Pointer(titlePtr)), 0)
}

func chooseDirectory(hwnd uintptr, title string) string {
	titlePtr, _ := syscall.UTF16PtrFromString(title)
	displayName := make([]uint16, maxPathBuffer)
	bi := browseInfo{
		hwndOwner:      hwnd,
		pszDisplayName: &displayName[0],
		lpszTitle:      titlePtr,
		ulFlags:        0x00000001 | 0x00000010 | 0x00000040,
	}
	pidl, _, _ := procSHBrowseForFolderW.Call(uintptr(unsafe.Pointer(&bi)))
	if pidl == 0 {
		return ""
	}
	defer procCoTaskMemFree.Call(pidl)

	pathBuffer := make([]uint16, maxPathBuffer)
	ret, _, _ := procSHGetPathFromIDListW.Call(pidl, uintptr(unsafe.Pointer(&pathBuffer[0])))
	if ret == 0 {
		return ""
	}
	return syscall.UTF16ToString(pathBuffer)
}

func winIndex(value int32) uintptr {
	return uintptr(value)
}

var _ io.Writer = guiLogWriter{}