package services

import (
	"log"
	"strconv"

	"github.com/wailsapp/wails/v3/pkg/application"
	"github.com/wailsapp/wails/v3/pkg/events"
)

const (
	windowStartStateNormal    = "normal"
	windowStartStateMaximized = "maximized"

	settingKeyWindowStartState    = "window.start_state"
	settingKeyWindowWidth         = "window.width"
	settingKeyWindowHeight        = "window.height"
	settingKeyWindowRememberState = "window.remember_state"
)

type mainWindowStateOptions struct {
	Width      int
	Height     int
	StartState application.WindowState
	Remember   bool
}

func (a *AppService) loadMainWindowStateOptions() mainWindowStateOptions {
	options := mainWindowStateOptions{
		Width:      mainWindowWidth,
		Height:     mainWindowHeight,
		StartState: application.WindowStateNormal,
		Remember:   true,
	}
	if a == nil || a.Config == nil {
		return options
	}

	options.Remember = configBool(a.Config, settingKeyWindowRememberState, true)
	if !options.Remember {
		return options
	}

	options.Width = max(configInt(a.Config, settingKeyWindowWidth, mainWindowWidth), mainWindowMinWidth)
	options.Height = max(configInt(a.Config, settingKeyWindowHeight, mainWindowHeight), mainWindowMinHeight)
	if configString(a.Config, settingKeyWindowStartState, windowStartStateNormal) == windowStartStateMaximized {
		options.StartState = application.WindowStateMaximised
	}
	return options
}

func (a *AppService) registerMainWindowStatePersistence() {
	if a == nil || a.MainWindow == nil {
		return
	}

	a.MainWindow.OnWindowEvent(events.Common.WindowDidResize, func(_ *application.WindowEvent) {
		a.persistMainWindowNormalSize()
	})
	a.MainWindow.OnWindowEvent(events.Common.WindowMaximise, func(_ *application.WindowEvent) {
		a.persistMainWindowStartState(windowStartStateMaximized)
	})
	a.MainWindow.OnWindowEvent(events.Common.WindowRestore, func(_ *application.WindowEvent) {
		a.persistMainWindowState()
	})
	a.MainWindow.OnWindowEvent(events.Common.WindowUnMaximise, func(_ *application.WindowEvent) {
		a.persistMainWindowState()
	})
}

func (a *AppService) shouldRememberMainWindowState() bool {
	if a == nil || a.Config == nil {
		return false
	}
	return configBool(a.Config, settingKeyWindowRememberState, true)
}

func (a *AppService) persistMainWindowState() {
	if !a.shouldRememberMainWindowState() || a.MainWindow == nil {
		return
	}
	if a.MainWindow.IsMaximised() {
		a.persistMainWindowStartState(windowStartStateMaximized)
		return
	}
	if a.MainWindow.IsFullscreen() || a.MainWindow.IsMinimised() {
		return
	}
	a.persistMainWindowNormalSize()
}

func (a *AppService) persistMainWindowStartState(state string) {
	if !a.shouldRememberMainWindowState() || a.Config == nil {
		return
	}

	a.windowStateMu.Lock()
	defer a.windowStateMu.Unlock()

	if err := a.Config.SetAppConfig(settingKeyWindowStartState, state); err != nil {
		log.Printf("persist main window state failed: %v", err)
	}
}

func (a *AppService) persistMainWindowNormalSize() {
	if !a.shouldRememberMainWindowState() || a.MainWindow == nil || a.Config == nil {
		return
	}
	if a.MainWindow.IsMaximised() || a.MainWindow.IsFullscreen() || a.MainWindow.IsMinimised() {
		return
	}

	width, height := a.MainWindow.Size()
	if width < mainWindowMinWidth || height < mainWindowMinHeight {
		return
	}

	a.windowStateMu.Lock()
	defer a.windowStateMu.Unlock()

	if err := a.Config.SetAppConfig(settingKeyWindowStartState, windowStartStateNormal); err != nil {
		log.Printf("persist main window start state failed: %v", err)
	}
	if err := a.Config.SetAppConfig(settingKeyWindowWidth, strconv.Itoa(width)); err != nil {
		log.Printf("persist main window width failed: %v", err)
	}
	if err := a.Config.SetAppConfig(settingKeyWindowHeight, strconv.Itoa(height)); err != nil {
		log.Printf("persist main window height failed: %v", err)
	}
}

func configString(config *AppConfigService, key string, fallback string) string {
	if config == nil {
		return fallback
	}
	value, err := config.GetAppConfig(key)
	if err != nil || value == "" {
		return fallback
	}
	return value
}

func configBool(config *AppConfigService, key string, fallback bool) bool {
	value := configString(config, key, "")
	if value == "" {
		return fallback
	}
	parsed, err := strconv.ParseBool(value)
	if err != nil {
		return fallback
	}
	return parsed
}

func configInt(config *AppConfigService, key string, fallback int) int {
	value := configString(config, key, "")
	if value == "" {
		return fallback
	}
	parsed, err := strconv.Atoi(value)
	if err != nil {
		return fallback
	}
	return parsed
}