package gui

import (
	"go.wit.com/lib/protobuf/guipb"
	"go.wit.com/log"
	"go.wit.com/widget"
)

// Why have NewWindow() when there isn't just Window()
// That's how smalltalk did things in 1972. Keep it Simple.
// todo: remove 'New' from every function name
// will that work? Are there problems with that?
// Button() Grid() Box(), Label()
// 2024/01/04 Naw, having NewWindow is more readable
/*
func (parent *Node) Window(title string) *Node {
	return parent.NewWindow(title)
}
*/

// This routine creates a blank window with a Title

func (parent *Node) NewWindow(title string) *Node {
	var newNode *Node

	// Windows are created off of the master node of the Binary Tree
	newNode = parent.newNode(title, widget.Window)
	newNode.Custom = StandardExit

	log.Log(INFO, "NewWindow()", title)
	newNode.progname = title
	newNode.label = title
	newNode.margin = true
	newNode.visable = true
	newNode.hidden = false

	// inform the toolkits
	sendAction(newNode, widget.Add)
	return newNode
}

// This creates a window off the root of the binary tree
func NewWindow(title string) *Node {
	return me.rootNode.NewWindow(title)
}

func RawWindow(title string) *Node {
	return me.rootNode.RawWindow(title)
}

// allow window create without actually sending it to the toolkit
func (parent *Node) RawWindow(title string) *Node {
	var newNode *Node

	// Windows are created off of the master node of the Binary Tree
	newNode = parent.newNode(title, widget.Window)
	newNode.hidden = true
	newNode.visable = false

	log.Log(INFO, "RawWindow()", title)
	return newNode
}

// TODO: send protobuf
func (n *Node) Draw() *Node {
	if !n.Ready() {
		return n
	}

	n.hidden = false
	n.changed = true

	// inform the toolkits
	sendAction(n, widget.Add)
	return n
}

func (n *Node) TestDrawPB(pb bool) {
	n.visable = true
	n.hidden = false
	n.changed = true

	if !pb {
		log.Log(NOW, "TestDrawPB() using TestDraw()")
		n.TestDraw()
		return
	}

	widgets := guipb.NewWidgets()
	widgets.Tree = new(guipb.Widget)
	n.makePB(widgets.Tree)

	a := getNewAction(me.rootNode, widget.Show)

	a.WidgetPB, err = widgets.Marshal()
	if err != nil {
		log.Log(WARN, "unmarshal error", err)
		return
	}
	log.Log(NOW, "TestDrawPB() setting WidgetPB len() =", len(a.WidgetPB))

	log.Log(NOW, "TestDrawPB() start")
	sendActionToPlugin(a)
	log.Log(NOW, "TestDrawPB() end")
	return
}

// TODO: remove this after switching to protobuf
// when a window is redrawn, every widget in the window
// needs to be sent to the toolkit
func (n *Node) TestDraw() {
	if n == nil {
		return
	}

	n.changed = true
	n.visable = true
	log.Log(INFO, "TestDraw() sending widget.Add", n.id, n.WidgetType, n.progname)
	sendAction(n, widget.Add)

	for _, child := range n.children {
		child.TestDraw()
	}
	return
}

func (n *Node) makePB(parent *guipb.Widget) *guipb.Widget {
	w := new(guipb.Widget)
	w.Id = int64(n.id)
	w.Name = n.label

	parent.Children = append(parent.Children, w)

	for _, child := range n.children {
		w.Children = append(w.Children, child.makePB(w))
	}

	return w
}

func (n *Node) TestPB() {
	if n == nil {
		return
	}

	a := getNewAction(me.rootNode, widget.Show)

	log.Info("gui.UpdateTable() TODO: move the widget update val logic here instead of tree")

	a.WidgetPB, err = me.widgets.Marshal()
	if err != nil {
		log.Info("unmarshal error", err)
		return
	}
	sendActionToPlugin(a)
	return
}