package translations

import (
	"errors"
	"fmt"
	"log/slog"
	"os"

	"bunker/client/internal/application"
	"bunker/client/internal/langfiles"
	"bunker/client/internal/services/core"

	"fyne.io/fyne/v2/lang"
)

var (
	_ = core.Translations(&translations{})

	errTranslations = errors.New("translations core service")
)

type translations struct {
	app        *application.Application
	logger     *slog.Logger
	mainWindow core.MainWindow
}

// Initialize initializes service.
func Initialize(app *application.Application) error {
	transl := &translations{
		app: app,
	}

	if err := app.RegisterService(transl); err != nil {
		return fmt.Errorf("%w: %w", errTranslations, err)
	}

	return nil
}

func (t *translations) Configure() error {
	if err := t.initializeSysInfoHandler(); err != nil {
		return fmt.Errorf("configure: %w", err)
	}

	return nil
}

func (t *translations) ConnectDependencies() error {
	mainWindowRaw := t.app.Service(core.ServiceNameMainWindow)
	if mainWindowRaw == nil {
		return fmt.Errorf("connect dependencies: get main window: %w", application.ErrServiceNotFound)
	}

	mainWindow, valid := mainWindowRaw.(core.MainWindow)
	if !valid {
		return fmt.Errorf("connect dependencies: type assert main window: %w", core.ErrMainWindowIsInvalid)
	}

	t.mainWindow = mainWindow

	return nil
}

func (t *translations) Initialize() error {
	t.logger = t.app.NewLogger("service", core.ServiceNameTranslations)

	t.logger.Info("Initializing...")

	langFromEnv, _ := os.LookupEnv("LANG")

	t.logger.Info("Current system locale.", "locale", lang.SystemLocale().String(), "LANG", langFromEnv)

	if err := lang.AddTranslationsFS(langfiles.LangFiles, "files"); err != nil {
		return fmt.Errorf("%w: load translations: %w", errTranslations, err)
	}

	return nil
}

func (t *translations) Name() string {
	return core.ServiceNameTranslations
}

func (t *translations) LaunchStartupTasks() error {
	return nil
}

func (t *translations) Shutdown() error {
	return nil
}