main.go

package main

import (
	"encoding/csv"
	"fmt"
	"io"
	"log"
	"os"
	"os/exec"
	"path/filepath"
	"runtime"
	"strconv"
	"strings"
	"sync"
	"syscall"
	"time"
	"unsafe"

	"fullscreen-monitor-manager/internal/autostart"
	"fullscreen-monitor-manager/internal/config"
	"fullscreen-monitor-manager/internal/ui"

	"github.com/getlantern/systray"
	"golang.org/x/sys/windows"
)

// State represents the global application state
type State struct {
	configMgr          *config.Manager
	monitorsDisabled   bool
	autoPaused         bool
	disabledMonitors   []string
	fullscreenMonitor  string        // name of monitor with fullscreen window
	originalPrimary    string        // save original primary monitor
	monitors           []MonitorData // list of monitors from MMT
	settingsWindowOpen bool
	savedWindowPos     []SavedWindow // saved window positions
	mu                 sync.RWMutex
	stopChan           chan bool
	logger             *log.Logger
	logLevel           string // "debug" or "info"
}

// SavedWindow stores window position information
type SavedWindow struct {
	Hwnd          windows.HWND
	ProcessName   string
	Title         string
	Rect          RECT
	MonitorName   string
	IsVisible     bool
	IsMaximized   bool
	WasSuccessful bool // track if restoration was successful
}

// MonitorData contains information about a monitor from MMT
type MonitorData struct {
	Name         string // \\.\DISPLAY1
	LeftTop      RECT   // coordinates
	RightBottom  RECT
	Active       bool
	Primary      bool
	MonitorModel string // e.g. "DELL P2421D"
	MonitorName  string // e.g. "Generic PnP Monitor"
	Resolution   string // e.g. "2560 X 1440"
}

// RECT represents a rectangle structure
type RECT struct {
	Left   int32
	Top    int32
	Right  int32
	Bottom int32
}

// MONITORINFO contains monitor information
type MONITORINFO struct {
	CbSize    uint32
	RcMonitor RECT
	RcWork    RECT
	DwFlags   uint32
}

// MONITORINFOEX extends MONITORINFO with device name
type MONITORINFOEX struct {
	CbSize    uint32
	RcMonitor RECT
	RcWork    RECT
	DwFlags   uint32
	SzDevice  [32]uint16 // CCHDEVICENAME = 32
}

const (
	MONITOR_DEFAULTTONEAREST = 2
	SW_MAXIMIZE              = 3
	SW_RESTORE               = 9
	SWP_NOSIZE               = 0x0001
	SWP_NOZORDER             = 0x0004
	SWP_NOACTIVATE           = 0x0010
	GWL_STYLE                = -16
	WS_VISIBLE               = 0x10000000
	WS_MAXIMIZE              = 0x01000000
)

var (
	state *State

	// Windows API functions
	user32                       = windows.NewLazySystemDLL("user32.dll")
	procGetForegroundWindow      = user32.NewProc("GetForegroundWindow")
	procGetWindowRect            = user32.NewProc("GetWindowRect")
	procMonitorFromWindow        = user32.NewProc("MonitorFromWindow")
	procGetMonitorInfo           = user32.NewProc("GetMonitorInfoW")
	procGetWindowThreadProcessId = user32.NewProc("GetWindowThreadProcessId")
	procEnumWindows              = user32.NewProc("EnumWindows")
	procIsWindowVisible          = user32.NewProc("IsWindowVisible")
	procGetWindowTextW           = user32.NewProc("GetWindowTextW")
	procGetWindowTextLengthW     = user32.NewProc("GetWindowTextLengthW")
	procSetWindowPos             = user32.NewProc("SetWindowPos")
	procGetWindowLongW           = user32.NewProc("GetWindowLongW")
	procShowWindow               = user32.NewProc("ShowWindow")
)

// getForegroundWindow retrieves the active window
func getForegroundWindow() windows.HWND {
	r, _, _ := procGetForegroundWindow.Call()
	return windows.HWND(r)
}

// setMonitorPrimary sets the monitor as primary using MultiMonitorTool
func setMonitorPrimary(monitorName string) error {
	if monitorName == "" {
		state.logger.Printf("[Primary] Skipping empty monitor name")
		return nil
	}

	cfg := state.configMgr.GetConfig()
	state.logger.Printf("[Primary] Setting %s as primary monitor...", monitorName)

	args := []string{"/SetPrimary", monitorName}
	cmd := createMMTCommand(cfg.MMTPath, args...)
	if err := cmd.Run(); err != nil {
		state.logger.Printf("[Primary] ❌ Failed to set as primary: %v", err)
		return err
	}

	state.logger.Printf("[Primary] ✅ %s set as primary", monitorName)

	// Give the system time to process
	time.Sleep(200 * time.Millisecond)

	// Verify by reloading monitors
	if err := loadMonitorsFromMMT(); err == nil {
		state.mu.RLock()
		for _, m := range state.monitors {
			if m.Primary {
				if state.configMgr.GetConfig().LogLevel == "debug" {
					state.logger.Printf("[DEBUG][Primary] Verified: %s is now primary", m.Name)
				}
				break
			}
		}
		state.mu.RUnlock()
	}

	return nil
}

// getWindowRect retrieves the window dimensions
func getWindowRect(hwnd windows.HWND) (RECT, error) {
	var rect RECT
	r, _, err := procGetWindowRect.Call(uintptr(hwnd), uintptr(unsafe.Pointer(&rect)))
	if r == 0 {
		return rect, fmt.Errorf("GetWindowRect failed: %v", err)
	}
	return rect, nil
}

// monitorFromWindow retrieves the monitor for a window
func monitorFromWindow(hwnd windows.HWND, dwFlags uint32) windows.Handle {
	r, _, _ := procMonitorFromWindow.Call(uintptr(hwnd), uintptr(dwFlags))
	return windows.Handle(r)
}

// getMonitorInfo retrieves monitor information
func getMonitorInfo(hMonitor windows.Handle) (MONITORINFO, error) {
	var mi MONITORINFO
	mi.CbSize = uint32(unsafe.Sizeof(mi))
	r, _, err := procGetMonitorInfo.Call(uintptr(hMonitor), uintptr(unsafe.Pointer(&mi)))
	if r == 0 {
		return mi, fmt.Errorf("GetMonitorInfo failed: %v", err)
	}
	return mi, nil
}

// getMonitorDeviceName retrieves the device name for a monitor (e.g., \\.\DISPLAY1)
func getMonitorDeviceName(hMonitor windows.Handle) (string, error) {
	var miex MONITORINFOEX
	miex.CbSize = uint32(unsafe.Sizeof(miex))
	r, _, err := procGetMonitorInfo.Call(uintptr(hMonitor), uintptr(unsafe.Pointer(&miex)))
	if r == 0 {
		return "", fmt.Errorf("GetMonitorInfo failed: %v", err)
	}

	// Convert UTF-16 to string
	deviceName := windows.UTF16ToString(miex.SzDevice[:])
	return deviceName, nil
}

// isFullscreen checks if a window is in fullscreen mode
func isFullscreen(hwnd windows.HWND) (bool, error) {
	if hwnd == 0 {
		return false, nil
	}

	rect, err := getWindowRect(hwnd)
	if err != nil {
		return false, err
	}

	hMon := monitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST)
	if hMon == 0 {
		return false, fmt.Errorf("MonitorFromWindow failed")
	}

	mi, err := getMonitorInfo(hMon)
	if err != nil {
		return false, err
	}

	cfg := state.configMgr.GetConfig()
	tolerance := int32(cfg.FullscreenTolerancePx)

	fullscreen := (rect.Left <= mi.RcMonitor.Left+tolerance &&
		rect.Top <= mi.RcMonitor.Top+tolerance &&
		rect.Right >= mi.RcMonitor.Right-tolerance &&
		rect.Bottom >= mi.RcMonitor.Bottom-tolerance)

	return fullscreen, nil
}

// getProcessName retrieves the process name for a window
func getProcessName(hwnd windows.HWND) (string, error) {
	var processID uint32
	procGetWindowThreadProcessId.Call(
		uintptr(hwnd),
		uintptr(unsafe.Pointer(&processID)),
	)

	if processID == 0 {
		return "", fmt.Errorf("failed to get process ID")
	}

	// Open the process
	kernel32 := windows.NewLazySystemDLL("kernel32.dll")
	procOpenProcess := kernel32.NewProc("OpenProcess")
	procQueryFullProcessImageName := kernel32.NewProc("QueryFullProcessImageNameW")
	procCloseHandle := kernel32.NewProc("CloseHandle")

	const PROCESS_QUERY_LIMITED_INFORMATION = 0x1000
	hProcess, _, _ := procOpenProcess.Call(
		uintptr(PROCESS_QUERY_LIMITED_INFORMATION),
		0,
		uintptr(processID),
	)

	if hProcess == 0 {
		return "", fmt.Errorf("failed to open process")
	}
	defer procCloseHandle.Call(hProcess)

	// Get the full path
	var buf [windows.MAX_PATH]uint16
	size := uint32(len(buf))
	procQueryFullProcessImageName.Call(
		hProcess,
		0,
		uintptr(unsafe.Pointer(&buf[0])),
		uintptr(unsafe.Pointer(&size)),
	)

	fullPath := windows.UTF16ToString(buf[:])

	// Extract only the filename
	parts := strings.Split(fullPath, "\\")
	if len(parts) > 0 {
		return parts[len(parts)-1], nil
	}

	return fullPath, nil
}

// createMMTCommand creates a command to run MMT with a hidden window
func createMMTCommand(mmtPath string, args ...string) *exec.Cmd {
	// If it's just a filename - search for it in the current directory
	if !strings.Contains(mmtPath, "/") && !strings.Contains(mmtPath, "\\") {
		// Try to find the absolute path
		if path, err := os.Executable(); err == nil {
			baseDir := filepath.Dir(path)
			fullPath := filepath.Join(baseDir, mmtPath)
			if _, err := os.Stat(fullPath); err == nil {
				mmtPath = fullPath
			}
		}
	}

	// Add parameters to hide the window (move it offscreen)
	fullArgs := append([]string{"/WindowLeft", "-32000", "/WindowTop", "-32000"}, args...)

	// Direct execution - simpler and more reliable
	cmd := exec.Command(mmtPath, fullArgs...)

	// Hide window using Windows API
	cmd.SysProcAttr = &windows.SysProcAttr{
		HideWindow:    true,
		CreationFlags: 0x08000000, // CREATE_NO_WINDOW
	}

	// Redirect stdout/stderr to null
	cmd.Stdout = io.Discard
	cmd.Stderr = io.Discard

	return cmd
}

func loadMonitorsFromMMT() error {
	state.logger.Printf("Loading monitors from MultiMonitorTool...")

	mmtPath := state.configMgr.GetConfig().MMTPath
	monitorsFile := filepath.Join("config_files", "monitors.txt")
	cmd := createMMTCommand(mmtPath, "/scomma", monitorsFile)

	if err := cmd.Run(); err != nil {
		return fmt.Errorf("failed to run MultiMonitorTool: %w", err)
	}

	file, err := os.Open(monitorsFile)
	if err != nil {
		return fmt.Errorf("failed to open monitors file: %w", err)
	}
	defer file.Close()

	// Read file - MMT /scomma generates UTF-8, not UTF-16
	data, err := io.ReadAll(file)
	if err != nil {
		return fmt.Errorf("failed to read monitors file: %w", err)
	}

	// Parse the output
	monitors := parseMMTOutput(string(data))

	state.mu.Lock()
	state.monitors = monitors
	state.mu.Unlock()

	state.logger.Printf("Loaded %d monitors from MultiMonitorTool", len(monitors))
	if state.configMgr.GetConfig().LogLevel == "debug" {
		for _, m := range monitors {
			state.logger.Printf("[DEBUG]   %s: (%d,%d)-(%d,%d) Active:%v Primary:%v",
				m.Name, m.LeftTop.Left, m.LeftTop.Top,
				m.RightBottom.Right, m.RightBottom.Bottom, m.Active, m.Primary)
		}
	}

	return nil
}

// saveMonitorConfig saves current monitor configuration to file
func saveMonitorConfig() error {
	state.logger.Printf("Saving monitor configuration...")

	mmtPath := state.configMgr.GetConfig().MMTPath
	configPath := filepath.Join("config_files", "monitors_config.cfg")

	// Ensure config_files directory exists
	if err := os.MkdirAll("config_files", 0755); err != nil {
		return fmt.Errorf("failed to create config_files directory: %w", err)
	}

	cmd := createMMTCommand(mmtPath, "/SaveConfig", configPath)
	if err := cmd.Run(); err != nil {
		return fmt.Errorf("failed to save monitor config: %w", err)
	}

	state.logger.Printf("Monitor configuration saved to %s", configPath)
	return nil
}

// restoreMonitorConfig restores monitor configuration from file
func restoreMonitorConfig() error {
	configPath := filepath.Join("config_files", "monitors_config.cfg")

	// Check if config file exists
	if _, err := os.Stat(configPath); os.IsNotExist(err) {
		state.logger.Printf("Monitor config file not found, skipping restore")
		return nil
	}

	state.logger.Printf("Restoring monitor configuration from %s...", configPath)

	mmtPath := state.configMgr.GetConfig().MMTPath
	cmd := createMMTCommand(mmtPath, "/LoadConfig", configPath)
	if err := cmd.Run(); err != nil {
		return fmt.Errorf("failed to restore monitor config: %w", err)
	}

	// Wait for monitors to settle
	time.Sleep(500 * time.Millisecond)

	state.logger.Printf("Monitor configuration restored")
	return nil
}

// parseMMTOutput parses the output from MultiMonitorTool
func parseMMTOutput(data string) []MonitorData {
	data = strings.TrimSpace(data)
	if data == "" {
		return nil
	}

	// CSV output from /scomma
	if strings.HasPrefix(data, "Resolution,") && strings.Contains(data, "Left-Top") {
		return parseMMTCSV(data)
	}

	var monitors []MonitorData
	lines := strings.Split(data, "\n")

	var current MonitorData

	for _, line := range lines {
		line = strings.TrimSpace(line)

		if strings.HasPrefix(line, "Left-Top") {
			var left, top int32
			fmt.Sscanf(line, "Left-Top : %d, %d", &left, &top)
			current.LeftTop = RECT{Left: left, Top: top}
		} else if strings.HasPrefix(line, "Right-Bottom") {
			var right, bottom int32
			fmt.Sscanf(line, "Right-Bottom : %d, %d", &right, &bottom)
			current.RightBottom = RECT{Right: right, Bottom: bottom}
		} else if strings.HasPrefix(line, "Active") {
			current.Active = strings.Contains(line, "Yes")
		} else if strings.HasPrefix(line, "Primary") {
			current.Primary = strings.Contains(line, "Yes")
		} else if strings.HasPrefix(line, "Name") && strings.Contains(line, "DISPLAY") {
			// Name comes last - now we have all data, save and store
			parts := strings.SplitN(line, ":", 2)
			if len(parts) == 2 {
				current.Name = strings.TrimSpace(parts[1])
				// Store the current monitor
				if current.Name != "" {
					monitors = append(monitors, current)
				}
				// Start a new one
				current = MonitorData{}
			}
		}
	}

	return monitors
}

func parseMMTCSV(data string) []MonitorData {
	var monitors []MonitorData

	reader := csv.NewReader(strings.NewReader(data))
	reader.TrimLeadingSpace = true

	records, err := reader.ReadAll()
	if err != nil {
		state.logger.Printf("CSV parsing error: %v", err)
		return monitors
	}

	if len(records) < 2 {
		state.logger.Printf("CSV has no data rows (only %d records)", len(records))
		return monitors
	}

	header := records[0]
	cfg := state.configMgr.GetConfig()
	if cfg.LogLevel == "debug" {
		state.logger.Printf("[DEBUG] CSV headers: %v", header)
	}

	idx := func(name string) int {
		for i, h := range header {
			if strings.EqualFold(strings.TrimSpace(h), name) {
				return i
			}
		}
		return -1
	}

	idxLeftTop := idx("Left-Top")
	idxRightBottom := idx("Right-Bottom")
	idxActive := idx("Active")
	idxPrimary := idx("Primary")
	idxName := idx("Name")
	idxMonitorString := idx("Monitor String")
	idxMonitorName := idx("Monitor Name")
	idxResolution := idx("Resolution")

	if cfg.LogLevel == "debug" {
		state.logger.Printf("[DEBUG] Column indices - LeftTop:%d, RightBottom:%d, Active:%d, Primary:%d, Name:%d",
			idxLeftTop, idxRightBottom, idxActive, idxPrimary, idxName)
	}

	for i, row := range records[1:] {
		if idxName < 0 || idxName >= len(row) {
			state.logger.Printf("Row %d: Name column not found or out of bounds", i+1)
			continue
		}

		name := strings.TrimSpace(row[idxName])
		if name == "" {
			state.logger.Printf("Row %d: Name is empty", i+1)
			continue
		}

		var m MonitorData
		m.Name = name

		if idxLeftTop >= 0 && idxLeftTop < len(row) {
			m.LeftTop = parseCSVLeftTop(row[idxLeftTop])
		}
		if idxRightBottom >= 0 && idxRightBottom < len(row) {
			m.RightBottom = parseCSVRightBottom(row[idxRightBottom])
		}
		if idxActive >= 0 && idxActive < len(row) {
			m.Active = strings.EqualFold(strings.TrimSpace(row[idxActive]), "Yes")
		}
		if idxPrimary >= 0 && idxPrimary < len(row) {
			m.Primary = strings.EqualFold(strings.TrimSpace(row[idxPrimary]), "Yes")
		}
		if idxMonitorString >= 0 && idxMonitorString < len(row) {
			m.MonitorName = strings.TrimSpace(row[idxMonitorString]) // "Generic PnP Monitor"
		}
		if idxMonitorName >= 0 && idxMonitorName < len(row) {
			m.MonitorModel = strings.TrimSpace(row[idxMonitorName]) // "DELL P2421D"
		}
		if idxResolution >= 0 && idxResolution < len(row) {
			m.Resolution = strings.TrimSpace(row[idxResolution])
		}

		if state.configMgr.GetConfig().LogLevel == "debug" {
			state.logger.Printf("[DEBUG] Parsed monitor: %s (Active:%v, Primary:%v, Model:%s)", name, m.Active, m.Primary, m.MonitorModel)
		}
		monitors = append(monitors, m)
	}

	return monitors
}

func parseCSVLeftTop(value string) RECT {
	parts := strings.Split(value, ",")
	if len(parts) != 2 {
		return RECT{}
	}

	left, _ := strconv.ParseInt(strings.TrimSpace(parts[0]), 10, 32)
	top, _ := strconv.ParseInt(strings.TrimSpace(parts[1]), 10, 32)
	return RECT{Left: int32(left), Top: int32(top)}
}

func parseCSVRightBottom(value string) RECT {
	parts := strings.Split(value, ",")
	if len(parts) != 2 {
		return RECT{}
	}

	right, _ := strconv.ParseInt(strings.TrimSpace(parts[0]), 10, 32)
	bottom, _ := strconv.ParseInt(strings.TrimSpace(parts[1]), 10, 32)

	return RECT{Right: int32(right), Bottom: int32(bottom)}
}

// saveWindowPositions saves positions of all visible windows
func saveWindowPositions() error {
	state.logger.Printf("[WindowPos] Saving window positions...")

	var savedWindows []SavedWindow

	// Callback for EnumWindows
	callback := syscall.NewCallback(func(hwnd windows.HWND, lParam uintptr) uintptr {
		// Check if window is visible
		visible, _, _ := procIsWindowVisible.Call(uintptr(hwnd))
		if visible == 0 {
			return 1 // Continue enumeration
		}

		// Get window style to check if maximized
		style, _, _ := procGetWindowLongW.Call(uintptr(hwnd), uintptr(^uint(15)))
		isMaximized := (style & WS_MAXIMIZE) != 0

		// Get window rect
		var rect RECT
		ret, _, _ := procGetWindowRect.Call(uintptr(hwnd), uintptr(unsafe.Pointer(&rect)))
		if ret == 0 {
			return 1 // Continue
		}

		// Skip windows that are too small (likely not user windows)
		width := rect.Right - rect.Left
		height := rect.Bottom - rect.Top
		if width < 100 || height < 100 {
			return 1
		}

		// Get window title
		titleLen, _, _ := procGetWindowTextLengthW.Call(uintptr(hwnd))
		if titleLen == 0 {
			return 1 // Skip windows without title
		}

		titleBuf := make([]uint16, titleLen+1)
		procGetWindowTextW.Call(uintptr(hwnd), uintptr(unsafe.Pointer(&titleBuf[0])), uintptr(titleLen+1))
		title := windows.UTF16ToString(titleBuf)

		if title == "" {
			return 1 // Skip
		}

		// Get process name
		procName, err := getProcessName(hwnd)
		if err != nil {
			procName = "unknown"
		}

		// Find which monitor this window is on
		hMon := monitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST)
		monitorName := ""
		if hMon != 0 {
			mi, err := getMonitorInfo(hMon)
			if err == nil {
				monitorName = findMonitorByCoordinates(mi.RcMonitor)
			}
		}

		// Save window info
		sw := SavedWindow{
			Hwnd:        hwnd,
			ProcessName: procName,
			Title:       title,
			Rect:        rect,
			MonitorName: monitorName,
			IsVisible:   true,
			IsMaximized: isMaximized,
		}

		savedWindows = append(savedWindows, sw)

		return 1 // Continue enumeration
	})

	// Enumerate all top-level windows
	ret, _, _ := procEnumWindows.Call(callback, 0)
	if ret == 0 {
		return fmt.Errorf("EnumWindows failed")
	}

	// Store in state
	state.mu.Lock()
	state.savedWindowPos = savedWindows
	state.mu.Unlock()

	state.logger.Printf("[WindowPos] Saved %d window positions", len(savedWindows))

	// Log some windows for debugging
	if state.configMgr.GetConfig().LogLevel == "debug" {
		for i, sw := range savedWindows {
			if i < 5 { // Log first 5
				state.logger.Printf("[DEBUG][WindowPos]   %s - %s (%d,%d) on %s",
					sw.ProcessName, sw.Title, sw.Rect.Left, sw.Rect.Top, sw.MonitorName)
			}
		}
	}

	return nil
}

// restoreWindowPositions restores saved window positions
func restoreWindowPositions() error {
	state.mu.RLock()
	savedWindows := make([]SavedWindow, len(state.savedWindowPos))
	copy(savedWindows, state.savedWindowPos)
	state.mu.RUnlock()

	if len(savedWindows) == 0 {
		state.logger.Printf("[WindowPos] No saved window positions to restore")
		return nil
	}

	state.logger.Printf("[WindowPos] Restoring %d window positions...", len(savedWindows))

	restored := 0
	failed := 0

	// Restore in reverse order to preserve Z-order (bottom to top)
	// EnumWindows gives us top-to-bottom order, so reversing it
	// and applying each with HWND_TOP will recreate the original stack
	for i := len(savedWindows) - 1; i >= 0; i-- {
		sw := savedWindows[i]

		// Check if window still exists and is visible
		visible, _, _ := procIsWindowVisible.Call(uintptr(sw.Hwnd))
		if visible == 0 {
			continue
		}

		// Restore window position with HWND_TOP (each successive window goes on top)
		// Since we're going in reverse order, the original top window will be restored last
		flags := SWP_NOACTIVATE

		ret, _, _ := procSetWindowPos.Call(
			uintptr(sw.Hwnd),
			0, // HWND_TOP - places window on top of Z-order
			uintptr(sw.Rect.Left),
			uintptr(sw.Rect.Top),
			uintptr(sw.Rect.Right-sw.Rect.Left),
			uintptr(sw.Rect.Bottom-sw.Rect.Top),
			uintptr(flags),
		)

		if ret != 0 {
			// Restore maximized state if needed
			if sw.IsMaximized {
				procShowWindow.Call(uintptr(sw.Hwnd), SW_MAXIMIZE)
			}
			restored++
			if state.configMgr.GetConfig().LogLevel == "debug" {
				state.logger.Printf("[DEBUG][WindowPos]   ✓ %s - %s", sw.ProcessName, sw.Title)
			}
		} else {
			failed++
		}
	}

	state.logger.Printf("[WindowPos] Restored: %d successful, %d failed", restored, failed)

	// Clear saved positions
	state.mu.Lock()
	state.savedWindowPos = nil
	state.mu.Unlock()

	return nil
}

// findMonitorByCoordinates finds a monitor by coordinates
func findMonitorByCoordinates(monRect RECT) string {
	state.mu.RLock()
	defer state.mu.RUnlock()

	// Find the monitor that contains these coordinates
	for _, m := range state.monitors {
		if m.Active &&
			monRect.Left >= m.LeftTop.Left &&
			monRect.Top >= m.LeftTop.Top &&
			monRect.Right <= m.RightBottom.Right &&
			monRect.Bottom <= m.RightBottom.Bottom {
			return m.Name
		}
	}

	return ""
}

// getMonitorNumber returns the monitor number (1, 2, 3) for convenient logging
func getMonitorNumber(monitorName string) int {
	state.mu.RLock()
	defer state.mu.RUnlock()

	for i, m := range state.monitors {
		if m.Name == monitorName {
			return i + 1
		}
	}
	return 0
}

// getDisabledMonitorIDs returns the IDs of monitors to disable
func getDisabledMonitorIDs(fullscreenMonitorName string) []string {
	state.mu.RLock()
	defer state.mu.RUnlock()

	var disabled []string

	for _, m := range state.monitors {
		if m.Active && m.Name != "" && m.Name != fullscreenMonitorName {
			disabled = append(disabled, m.Name)
		}
	}

	return disabled
}

// disableExcept disables managed monitors except the one in fullscreen mode
func disableExcept(fullscreenMonID string) error {
	cfg := state.configMgr.GetConfig()

	state.mu.RLock()
	var disabled []string

	// If no managed monitors configured, don't disable anything
	if len(cfg.ManagedMonitors) == 0 {
		state.mu.RUnlock()
		state.logger.Printf("No managed monitors configured - skipping disable")
		return nil
	}

	for _, m := range state.monitors {
		if m.Name == "" || m.Name == fullscreenMonID {
			continue
		}

		// Only disable monitors that are in ManagedMonitors list
		isManaged := false
		for _, managed := range cfg.ManagedMonitors {
			if m.Name == managed {
				isManaged = true
				break
			}
		}
		if !isManaged {
			continue
		}

		disabled = append(disabled, m.Name)
	}
	state.mu.RUnlock()

	if len(disabled) == 0 {
		state.logger.Printf("No managed monitors to disable (fullscreen on %s)", fullscreenMonID)
		return nil
	}

	// Save current monitor configuration before making changes
	if err := saveMonitorConfig(); err != nil {
		state.logger.Printf("Warning: Failed to save monitor config: %v", err)
	}

	// Save window positions if enabled
	if cfg.RestoreWindowPositions {
		if err := saveWindowPositions(); err != nil {
			state.logger.Printf("Warning: Failed to save window positions: %v", err)
		}
	}

	state.logger.Printf("Disabling managed monitors (except %s): %v", fullscreenMonID, disabled)

	// Set fullscreen monitor as primary (helps Windows manage monitor state better)
	if err := setMonitorPrimary(fullscreenMonID); err != nil {
		state.logger.Printf("Warning: Could not set primary monitor: %v", err)
	}

	// Use /disable batch command (primary method)
	args := []string{"/disable"}
	args = append(args, disabled...)

	cmd := createMMTCommand(cfg.MMTPath, args...)
	if err := cmd.Run(); err != nil {
		state.logger.Printf("Warning: /disable failed: %v", err)
	} else {
		state.logger.Printf("✅ /disable batch executed successfully")
	}

	state.mu.Lock()
	state.disabledMonitors = disabled
	state.fullscreenMonitor = fullscreenMonID
	state.mu.Unlock()

	return nil
}

// restoreConfig restores the monitor configuration
func restoreConfig() error {
	cfg := state.configMgr.GetConfig()

	// Check if we should use LoadConfig method
	if cfg.UseConfigRestore {
		if cfg.LogLevel == "debug" {
			state.logger.Printf("[DEBUG][Restore] Using MMT /LoadConfig method")
		}
		return restoreConfigUsingMMT()
	}

	// Legacy method: manual enable + setPrimary
	if cfg.LogLevel == "debug" {
		state.logger.Printf("[DEBUG][Restore] Using legacy /enable method")
	}
	return restoreConfigLegacy()
}

// restoreConfigUsingMMT restores configuration using MMT /LoadConfig
func restoreConfigUsingMMT() error {
	// Simply restore the saved config - it handles everything
	if err := restoreMonitorConfig(); err != nil {
		state.logger.Printf("[Restore] Failed to restore config: %v", err)
		return err
	}

	// Wait for monitors to stabilize
	time.Sleep(500 * time.Millisecond)

	// Reload monitor state
	if err := loadMonitorsFromMMT(); err != nil {
		state.logger.Printf("[Restore] Warning: could not reload monitors: %v", err)
	}

	// Restore window positions if enabled
	cfg := state.configMgr.GetConfig()
	if cfg.RestoreWindowPositions {
		// Small delay to let monitors stabilize
		time.Sleep(500 * time.Millisecond)
		if err := restoreWindowPositions(); err != nil {
			state.logger.Printf("Warning: Failed to restore window positions: %v", err)
		}
	}

	// Clear state
	state.mu.Lock()
	state.disabledMonitors = nil
	state.fullscreenMonitor = ""
	state.mu.Unlock()

	state.logger.Printf("[Restore] Configuration restored successfully")
	return nil
}

// restoreConfigLegacy restores configuration using manual enable/setPrimary
func restoreConfigLegacy() error {
	state.mu.Lock()
	fullscreenMon := state.fullscreenMonitor
	state.mu.Unlock()

	cfg := state.configMgr.GetConfig()

	// Enable only managed monitors (or all if no managed list)
	state.mu.RLock()
	var toEnable []string
	for _, m := range state.monitors {
		if m.Name == "" || m.Name == fullscreenMon {
			continue
		}

		// Only enable monitors that are in ManagedMonitors list (if list is set)
		if len(cfg.ManagedMonitors) > 0 {
			isManaged := false
			for _, managed := range cfg.ManagedMonitors {
				if m.Name == managed {
					isManaged = true
					break
				}
			}
			if !isManaged {
				continue
			}
		}

		toEnable = append(toEnable, m.Name)
	}
	state.mu.RUnlock()

	if len(toEnable) == 0 {
		state.logger.Println("No managed monitors to enable")
		state.mu.Lock()
		state.disabledMonitors = nil
		state.fullscreenMonitor = ""
		state.mu.Unlock()
		return nil
	}

	if cfg.LogLevel == "debug" {
		state.logger.Printf("[DEBUG] Enabling managed monitors: %v", toEnable)
	}

	// Execute /enable once (like disable)
	args := []string{"/enable"}
	args = append(args, toEnable...)
	cmd := createMMTCommand(cfg.MMTPath, args...)
	if err := cmd.Run(); err != nil {
		state.logger.Printf("[Enable] Command failed: %v", err)
	}

	// Wait and verify result
	time.Sleep(500 * time.Millisecond)
	if err := loadMonitorsFromMMT(); err != nil {
		state.logger.Printf("Warning: could not verify monitor state after enable: %v", err)
	}

	// Restore original primary monitor FIRST (before window positions)
	state.mu.RLock()
	origPrimary := state.originalPrimary
	state.mu.RUnlock()

	if origPrimary != "" {
		if cfg.LogLevel == "debug" {
			state.logger.Printf("[DEBUG][Restore] Restoring primary monitor to: %s", origPrimary)
		}
		if err := setMonitorPrimary(origPrimary); err != nil {
			state.logger.Printf("[Restore] Warning: Could not restore primary monitor: %v", err)
			// Don't fail - continue anyway
		}
		// Wait for primary change to settle
		time.Sleep(500 * time.Millisecond)
	}

	// Restore window positions if enabled (AFTER primary is restored)
	if cfg.RestoreWindowPositions {
		if err := restoreWindowPositions(); err != nil {
			state.logger.Printf("Warning: Failed to restore window positions: %v", err)
		}
	}

	state.mu.Lock()
	state.disabledMonitors = nil
	state.fullscreenMonitor = ""
	state.mu.Unlock()

	return nil
}

// isProcessIgnored checks if a process is in the ignore list
func isProcessIgnored(procName string) bool {
	// Ignore user-defined
	if state.configMgr.IsProcessIgnored(procName) {
		return true
	}

	// Try to get full exe path for system check
	exePath := ""
	// Find hwnd of foreground window (or pass as param for optimization)
	hwnd := getForegroundWindow()
	if hwnd != 0 {
		var processID uint32
		procGetWindowThreadProcessId.Call(uintptr(hwnd), uintptr(unsafe.Pointer(&processID)))
		if processID != 0 {
			kernel32 := windows.NewLazySystemDLL("kernel32.dll")
			procOpenProcess := kernel32.NewProc("OpenProcess")
			procQueryFullProcessImageName := kernel32.NewProc("QueryFullProcessImageNameW")
			procCloseHandle := kernel32.NewProc("CloseHandle")
			const PROCESS_QUERY_LIMITED_INFORMATION = 0x1000
			hProcess, _, _ := procOpenProcess.Call(uintptr(PROCESS_QUERY_LIMITED_INFORMATION), 0, uintptr(processID))
			if hProcess != 0 {
				defer procCloseHandle.Call(hProcess)
				var buf [windows.MAX_PATH]uint16
				size := uint32(len(buf))
				procQueryFullProcessImageName.Call(hProcess, 0, uintptr(unsafe.Pointer(&buf[0])), uintptr(unsafe.Pointer(&size)))
				exePath = windows.UTF16ToString(buf[:])
			}
		}
	}

	// ignore system processes in C:\Windows\System32 and C:\Windows
	exePathLower := strings.ToLower(exePath)
	windir := strings.ToLower(os.Getenv("WINDIR"))
	if windir != "" && (strings.HasPrefix(exePathLower, windir+"\\system32") || strings.HasPrefix(exePathLower, windir+"\\")) {
		return true // System process
	}

	// ignore known Windows shell/system UI processes (див. нижче)
	switch strings.ToLower(procName) {
	case "textinputhost.exe", "shellexperiencehost.exe", "systemsettings.exe", "searchapp.exe", "startmenuexperiencehost.exe", "applicationframehost.exe", "lockapp.exe", "dwm.exe", "explorer.exe", "searchui.exe", "ctfmon.exe":
		return true
	}

	return false
}

// monitoringLoop is the main monitoring loop
func monitoringLoop() {
	cfg := state.configMgr.GetConfig()
	ticker := time.NewTicker(time.Duration(cfg.PollIntervalMs) * time.Millisecond)
	defer ticker.Stop()

	// Add separate ticker for monitor refresh
	refreshTicker := time.NewTicker(time.Duration(cfg.MonitorRefreshIntervalMs) * time.Millisecond)
	defer refreshTicker.Stop()

	var lastCheckTime time.Time
	var forceRestoreAttempts = 0
	const maxRestoreAttempts = 3

	for {
		select {
		case <-state.stopChan:
			return
		case <-refreshTicker.C:
			// Periodically refresh monitor list and save configuration
			if err := loadMonitorsFromMMT(); err != nil {
				state.logger.Printf("[Monitor Refresh] Failed to reload monitors: %v", err)
			} else {
				state.mu.RLock()
				monitorCount := len(state.monitors)
				state.mu.RUnlock()
				state.logger.Printf("[Monitor Refresh] Reloaded %d monitors", monitorCount)

				// Save current configuration after refresh (unless monitors are disabled)
				state.mu.RLock()
				disabled := state.monitorsDisabled
				state.mu.RUnlock()

				if !disabled {
					if err := saveMonitorConfig(); err != nil {
						state.logger.Printf("[Monitor Refresh] Warning: Failed to save config: %v", err)
					}
				}
			}
		case <-ticker.C:
			if state.autoPaused {
				continue
			}

			hwnd := getForegroundWindow()
			if hwnd == 0 {
				continue
			}

			// Get the process name
			procName, err := getProcessName(hwnd)
			if err != nil {
				continue
			}

			// Check if process is in the ignore list
			if isProcessIgnored(procName) {
				continue
			}

			fullscreen, err := isFullscreen(hwnd)
			if err != nil {
				continue
			}

			// Get window info for logging
			hMon := monitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST)
			if hMon == 0 {
				continue
			}

			mi, err := getMonitorInfo(hMon)
			if err != nil {
				continue
			}

			// SAFETY CHECK: If monitors should be disabled but the last action was long ago,
			// verify the state and re-disable if needed (handles stuck states)
			if state.monitorsDisabled && time.Since(lastCheckTime) > 5*time.Second {
				lastCheckTime = time.Now()

				// Reload monitor state to check if they're actually disabled
				if err := loadMonitorsFromMMT(); err == nil {
					allDisabled := true
					for _, disabled := range state.disabledMonitors {
						for _, monitor := range state.monitors {
							if monitor.Name == disabled && monitor.Active {
								allDisabled = false
								state.logger.Printf("[WARN] Monitor %s should be disabled but is ACTIVE!", disabled)
								break
							}
						}
					}

					if !allDisabled && forceRestoreAttempts < maxRestoreAttempts {
						forceRestoreAttempts++
						state.logger.Printf("[WARN] Re-enforcing disable on monitors (attempt %d/%d)", forceRestoreAttempts, maxRestoreAttempts)

						state.mu.RLock()
						disabled := append([]string{}, state.disabledMonitors...)
						state.mu.RUnlock()

						if len(disabled) > 0 {
							cfg := state.configMgr.GetConfig()
							args := []string{"/disable"}
							args = append(args, disabled...)
							cmd := createMMTCommand(cfg.MMTPath, args...)
							if err := cmd.Run(); err != nil {
								state.logger.Printf("[WARN] Failed to re-disable monitors: %v", err)
							}
						}
					}
				}
			}

			if fullscreen && !state.monitorsDisabled {
				// Fullscreen detected - disable other monitors
				// Find the correct monitor name by coordinates
				monitorName := findMonitorByCoordinates(mi.RcMonitor)
				if monitorName == "" {
					continue
				}

				monitorNum := getMonitorNumber(monitorName)
				state.logger.Printf("[INFO] Fullscreen on monitor #%d (%s), window: %dx%d at %d,%d",
					monitorNum, monitorName,
					mi.RcMonitor.Right-mi.RcMonitor.Left, mi.RcMonitor.Bottom-mi.RcMonitor.Top,
					mi.RcMonitor.Left, mi.RcMonitor.Top)

				if err := disableExcept(monitorName); err != nil {
					state.logger.Printf("Error disabling monitors: %v\n", err)
				} else {
					state.mu.Lock()
					state.monitorsDisabled = true
					state.mu.Unlock()
					forceRestoreAttempts = 0 // Reset counter on successful disable
					lastCheckTime = time.Now()
					state.logger.Printf("Fullscreen detected - monitors disabled (except %s)", monitorName)
				}

			} else if !fullscreen && state.monitorsDisabled {
				// Before restoring, check if there are ANY other fullscreen windows
				hasOtherFullscreen := false
				currentHwnd := hwnd // Save current window handle

				// Enumerate all windows to check for fullscreen
				callback := syscall.NewCallback(func(enumHwnd windows.HWND, lParam uintptr) uintptr {
					// Skip current window that just lost fullscreen
					if enumHwnd == windows.HWND(currentHwnd) {
						return 1 // Continue to next window
					}

					// Check if window is visible
					visible, _, _ := procIsWindowVisible.Call(uintptr(enumHwnd))
					isVisible := visible != 0

					// Get process name
					procName, procErr := getProcessName(enumHwnd)
					isIgnored := false
					if procErr == nil {
						isIgnored = isProcessIgnored(procName)
					}

					// Check if this window is fullscreen
					isFS, fsErr := isFullscreen(enumHwnd)

					if isVisible && fsErr == nil && isFS && procErr == nil && !isIgnored {
						hasOtherFullscreen = true
						if cfg.LogLevel == "debug" {
							state.logger.Printf("[DEBUG] Found other fullscreen: %s (hwnd=%v)", procName, enumHwnd)
						}
						return 0 // Stop enumeration - found another fullscreen window
					}
					return 1 // Continue
				})
				procEnumWindows.Call(callback, 0)

				// Only restore if no other fullscreen windows exist
				if hasOtherFullscreen {
					if cfg.LogLevel == "debug" {
						state.logger.Printf("[DEBUG] Other fullscreen window detected - skipping restore")
					}
					continue
				}

				// Lost fullscreen - restore config
				if cfg.LogLevel == "debug" {
					state.logger.Printf("[DEBUG] Fullscreen exit detected - window: %dx%d at %d,%d (not fullscreen on this monitor)",
						mi.RcMonitor.Right-mi.RcMonitor.Left, mi.RcMonitor.Bottom-mi.RcMonitor.Top,
						mi.RcMonitor.Left, mi.RcMonitor.Top)
					state.logger.Printf("[DEBUG] Disabled monitors: %v - attempting to restore", state.disabledMonitors)
				}

				if err := restoreConfig(); err != nil {
					state.logger.Printf("❌ Error restoring config: %v\n", err)
				} else {
					// Verify restoration
					time.Sleep(200 * time.Millisecond) // Give MMT time to process

					// Reload monitor state to verify
					if err := loadMonitorsFromMMT(); err != nil {
						state.logger.Printf("Warning: failed to verify monitor state: %v", err)
					}

					state.mu.Lock()
					state.monitorsDisabled = false
					state.mu.Unlock()
					forceRestoreAttempts = 0 // Reset counter on successful restore
					lastCheckTime = time.Now()
					state.logger.Println("✅ Fullscreen exited - monitors restored")
				}
			}
		}
	}
}

// setupLogger initializes logging
func setupLogger() (*log.Logger, error) {
	logDir := "logs"
	os.MkdirAll(logDir, 0755)

	logFile, err := os.OpenFile(logDir+"/app.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
	if err != nil {
		return nil, err
	}

	mw := io.MultiWriter(logFile)
	logger := log.New(mw, "[FSM] ", log.LstdFlags)
	return logger, nil
}

// loadTrayIcon loads the icon from a file
func loadTrayIcon() {
	// Try to load the ICO file
	iconPath := "assets/icons/tray-icon.ico"
	if data, err := os.ReadFile(iconPath); err == nil {
		systray.SetIcon(data)
	} else {
		state.logger.Printf("Warning: could not load icon from %s: %v\n", iconPath, err)
		// If icon not found - use default
	}
}

// onReady is called when the tray is ready
func onReady() {
	state.logger.Println("Application started")

	// Load the monitor list from MMT
	if err := loadMonitorsFromMMT(); err != nil {
		state.logger.Printf("Warning: failed to load monitors from MMT: %v", err)
	} else {
		cfg := state.configMgr.GetConfig()
		if cfg.LogLevel == "debug" {
			state.logger.Printf("[DEBUG] Loaded %d monitors from MMT", len(state.monitors))
		}

		// Save original primary monitor
		state.mu.Lock()
		for _, m := range state.monitors {
			if m.Primary {
				state.originalPrimary = m.Name
				if cfg.LogLevel == "debug" {
					state.logger.Printf("[DEBUG][Init] Original primary monitor: %s", state.originalPrimary)
				}
				break
			}
		}
		state.mu.Unlock()

		// Save initial monitor configuration
		if err := saveMonitorConfig(); err != nil {
			state.logger.Printf("Warning: Failed to save initial monitor config: %v", err)
		}

		// Initialize: Enable all monitors on startup to ensure they're all active
		if len(state.monitors) > 0 {
			var allMonitors []string
			for _, m := range state.monitors {
				if m.Name != "" {
					allMonitors = append(allMonitors, m.Name)
				}
			}

			if len(allMonitors) > 0 {
				cfg := state.configMgr.GetConfig()
				if cfg.LogLevel == "debug" {
					state.logger.Printf("[DEBUG][INIT] Enabling all monitors: %v", allMonitors)
				}

				// Try up to 2 times to ensure all monitors are enabled
				for attempt := 1; attempt <= 2; attempt++ {
					cmd := createMMTCommand(cfg.MMTPath, append([]string{"/enable"}, allMonitors...)...)
					if err := cmd.Run(); err != nil {
						state.logger.Printf("[INIT] Attempt %d: Error enabling monitors: %v", attempt, err)
					} else if cfg.LogLevel == "debug" {
						state.logger.Printf("[DEBUG][INIT] Attempt %d: Enable command executed", attempt)
					}
					time.Sleep(200 * time.Millisecond)
				}

				// Reload to verify
				if err := loadMonitorsFromMMT(); err == nil && cfg.LogLevel == "debug" {
					state.logger.Printf("[DEBUG][INIT] Monitor states after enable:")
					for _, m := range state.monitors {
						state.logger.Printf("[DEBUG][INIT]   %s: Active=%v Primary=%v", m.Name, m.Active, m.Primary)
					}
				}
			}
		}
	}

	// Load the icon
	loadTrayIcon()

	// Start the monitoring loop in a goroutine
	go monitoringLoop()

	// Tray menu
	// Initially set to "Pause" since autoPaused is false at startup
	mPause := systray.AddMenuItem("⏸ Pause", "Pause automatic monitor control")
	mSettings := systray.AddMenuItem("⚙️ Settings", "Open settings window")
	systray.AddSeparator()
	mExit := systray.AddMenuItem("❌ Exit", "Exit the application")

	go func() {
		for {
			select {
			case <-mPause.ClickedCh:
				state.mu.Lock()
				if state.autoPaused {
					state.autoPaused = false
					mPause.SetTitle("⏸ Pause")
					state.logger.Println("Auto-control resumed")
				} else {
					state.autoPaused = true
					mPause.SetTitle("▶ Resume")
					state.logger.Println("Auto-control paused")
				}
				state.mu.Unlock()

			case <-mSettings.ClickedCh:
				state.mu.Lock()
				if state.settingsWindowOpen {
					state.mu.Unlock()
					continue
				}
				state.settingsWindowOpen = true
				state.mu.Unlock()

				cfg := state.configMgr.GetConfig()
				showSettingsDialog(cfg.IgnoreProcesses)

				state.mu.Lock()
				state.settingsWindowOpen = false
				state.mu.Unlock()

			case <-mExit.ClickedCh:
				state.logger.Println("Exit requested - restoring config")
				restoreConfig()
				systray.Quit()
				return
			}
		}
	}()
}

// showSettingsDialog displays the GUI settings window
func showSettingsDialog(ignoreList []string) {
	cfg := state.configMgr.GetConfig()

	// Get available monitor information
	state.mu.RLock()
	availableMonitors := make([]ui.MonitorInfo, 0)
	for _, m := range state.monitors {
		if m.Name != "" {
			availableMonitors = append(availableMonitors, ui.MonitorInfo{
				Name:         m.Name,
				MonitorModel: m.MonitorModel,
				MonitorName:  m.MonitorName,
				Resolution:   m.Resolution,
			})
		}
	}
	state.mu.RUnlock()

	// Show the GUI window
	result, err := ui.ShowSettingsGUI(
		cfg.PollIntervalMs,
		cfg.FullscreenTolerancePx,
		cfg.MonitorRefreshIntervalMs,
		ignoreList,
		cfg.ManagedMonitors,
		availableMonitors,
		cfg.UseConfigRestore,
		cfg.RestoreWindowPositions,
		cfg.AutoStartEnabled,
		nil, // saveConfig callback - no longer used
		nil, // restoreConfig callback - no longer used
	)
	if err != nil {
		state.logger.Printf("Error showing settings GUI: %v", err)
		messageBoxW(0, fmt.Sprintf("❌ Error opening window: %v", err), "Error", 0)
		return
	}

	// If user clicked "Save"
	if result.Saved {
		// Update the configuration
		cfg.PollIntervalMs = result.PollInterval
		cfg.FullscreenTolerancePx = result.Tolerance
		cfg.MonitorRefreshIntervalMs = result.MonitorRefreshInterval
		cfg.IgnoreProcesses = result.IgnoreProcesses
		cfg.ManagedMonitors = result.ManagedMonitors
		cfg.UseConfigRestore = result.UseConfigRestore
		cfg.RestoreWindowPositions = result.RestoreWindowPositions
		cfg.AutoStartEnabled = result.AutoStartEnabled

		// Handle autostart shortcut
		appName := "FullscreenMonitorManager"
		exePath, _ := os.Executable()
		if result.AutoStartEnabled {
			_ = autostart.CreateStartupShortcut(appName, exePath)
		} else {
			_ = autostart.RemoveStartupShortcut(appName)
		}

		if err := state.configMgr.UpdateConfig(cfg); err != nil {
			messageBoxW(0, fmt.Sprintf("❌ Save error: %v", err), "Error", 0)
			state.logger.Printf("Error saving config: %v", err)
		} else {
			messageBoxW(0, "✅ Settings saved!", "Success", 0)
			state.logger.Printf("Settings updated: interval=%d, tolerance=%d, refresh=%d, processes=%d, monitors=%v",
				result.PollInterval, result.Tolerance, result.MonitorRefreshInterval, len(result.IgnoreProcesses), result.ManagedMonitors)
		}
	}
}

// messageBoxW displays a MessageBox with button types
func messageBoxW(hwnd uintptr, message, title string, msgType uint32) int {
	user32 := windows.NewLazySystemDLL("user32.dll")
	procMessageBox := user32.NewProc("MessageBoxW")

	msgPtr, _ := windows.UTF16PtrFromString(message)
	titlePtr, _ := windows.UTF16PtrFromString(title)

	// msgType: 0=MB_OK, 1=MB_OKCANCEL, 4=MB_YESNO
	ret, _, _ := procMessageBox.Call(hwnd, uintptr(unsafe.Pointer(msgPtr)), uintptr(unsafe.Pointer(titlePtr)), uintptr(msgType))

	return int(ret)
}

// onExit is called when the application exits
func onExit() {
	state.logger.Println("Application exiting - restoring monitor configuration")

	// Try to restore but don't crash if it fails
	defer func() {
		if r := recover(); r != nil {
			state.logger.Printf("Error during exit cleanup: %v", r)
		}
	}()

	if err := restoreConfig(); err != nil {
		state.logger.Printf("Warning: Error during exit restore: %v", err)
	}

	close(state.stopChan)
	time.Sleep(500 * time.Millisecond)
}

// init performs initialization
func init() {
	// Make sure we're running on Windows
	if runtime.GOOS != "windows" {
		fmt.Fprintf(os.Stderr, "This application requires Windows\n")
		os.Exit(1)
	}
}

// main is the application entry point
func main() {
	var err error
	logger, err := setupLogger()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Failed to setup logger: %v\n", err)
		os.Exit(1)
	}

	if err := os.MkdirAll("config_files", 0755); err != nil {
		logger.Printf("Error creating config_files dir: %v", err)
	}
	cfgMgr, err := config.NewManager("config_files/config.json")
	if err != nil {
		logger.Printf("Failed to load config: %v\n", err)
		os.Exit(1)
	}

	cfg := cfgMgr.GetConfig()
	logLevel := cfg.LogLevel
	if logLevel == "" {
		logLevel = "info" // default
	}

	state = &State{
		configMgr: cfgMgr,
		stopChan:  make(chan bool),
		logger:    logger,
		logLevel:  logLevel,
	}

	logger.Printf("Starting Fullscreen Monitor Manager (log level: %s)", logLevel)
	logger.Printf("Go version: %s, OS: %s, Arch: %s\n", runtime.Version(), runtime.GOOS, runtime.GOARCH)

	systray.Run(onReady, onExit)
}