package ui

import (
	"embed"
	"io/fs"

	"fyne.io/fyne/v2"
	"fyne.io/fyne/v2/data/binding"
	"github.com/google/uuid"
	"github.com/nicksnyder/go-i18n/v2/i18n"
)

type ResizeCallbackFn func(fyne.Size)
type MoveCallbackFn func(fyne.Position)

// BaseView represents the base implementation of a view
// You can create new view types by composing a type around BaseView
type BaseView struct {
	// The concrete view (Wrapper Object)
	concreteView View

	// Id of view
	id string

	// The controller
	ViewModel ViewModel

	// Root CanvasObject of the view
	CanvasObject fyne.CanvasObject

	// ----------- ScreenHandler -------------//
	*ScreenHandler
}

// NewBaseView creates a new baseview
// Any wrapper view should call this function in it's own initialization
// function an pass itself.
//
// example:
//
//	func NewWrapperView(...) *WrapperView {
//		v := new(WrapperView)
//		v.BaseView = NewBaseView(v)
//		..
//		return v
//	}
func NewBaseView(
	concreteView View,
	viewModel ViewModel,
) *BaseView {
	v := new(BaseView)
	v.id = uuid.NewString()
	v.concreteView = concreteView
	v.ViewModel = viewModel
	return v
}

func NewBaseViewWithScreen(
	concreteView View,
	viewModel ViewModel,
	filesystem embed.FS,
	screenName string,
	localizer *i18n.Localizer,
	assetLoader func(string) (fs.File, error),
) *BaseView {
	v := NewBaseView(concreteView, viewModel)

	var err error
	v.ScreenHandler, err = NewScreenHandler(
		filesystem,
		screenName,
		viewModel,
		localizer,
		assetLoader)
	if err != nil {
		LogWindowError(v, LoadScreen, err)
		return nil
	}
	return v
}

// ID returns tie id of the view
func (v BaseView) ID() string {
	return v.id
}

// SetID allows the user to specify the ID of the view
func (v *BaseView) SetID(id string) {
	v.id = id
}

// Equals checks equality of two views by comparing their id
func (v BaseView) Equals(other View) bool {
	return v.id == other.ID()
}

// Title returns the title of the view
func (v BaseView) Title() string {
	return ""
}

// Initialize initializes the view
func (v *BaseView) Initialize() fyne.CanvasObject {
	//LogWindowEvent(v, Initialize)
	if err := v.ViewModel.Initialize(); err != nil {
		LogWindowError(v, Initialize, err)
	}
	if v.ScreenHandler != nil && v.ScreenDefinition() != nil {
		obj, err := v.ScreenDefinition().Initialize()
		if err != nil {
			LogWindowError(v, Initialize, err)
			return nil
		}
		v.CanvasObject = obj
	}
	return v.CanvasObject
}

// Refresh is called when the view needs a full update
func (v *BaseView) Refresh() {
	//LogWindowEvent(v, Refresh)
	if v.CanvasObject != nil {
		v.CanvasObject.Refresh()
	}
}

// OnShow is called when the view becomes visible on the screen
func (v *BaseView) OnShow() {
	//LogWindowEvent(v, OnShow)
}

func (v *BaseView) OnHide() {
	//LogWindowEvent(v, OnHide)
}

func (v *BaseView) GetBinding(bindingName string) binding.DataItem {
	return v.ViewModel.GetBinding(bindingName)
}

func (v *BaseView) GetCanvasObject() fyne.CanvasObject {
	return v.CanvasObject
}

func (v *BaseView) RegisterResizeCallback(cb ResizeCallbackFn) {
	v.ScreenHandler.RegisterResizeCallback(cb)
}

func (v *BaseView) RegisterMoveCallback(cb MoveCallbackFn) {
	v.ScreenHandler.RegisterMoveCallback(cb)
}

func (v BaseView) PreventClose() bool {
	return false
}