package main

import (
	"errors"

	"go.wit.com/log"
	"go.wit.com/toolkits/tree"
	"go.wit.com/widget"
)

// this will check to make sure that the node
// is valid for making a New TK andlabs widget
// Basically, it makes sure there is a parent ID
// and that there already a widget created
func notNew(n *tree.Node) bool {
	if n == nil {
		log.Warn("ready() n = nil")
		return true
	}
	if n.TK != nil {
		log.Warn("ready() n.TK = nil", n.WidgetId, n.GetProgName())
		return true
	}
	if n.Parent == nil {
		log.Warn("ready() n.Parent = nil", n.WidgetId, n.GetProgName())
		return true
	}
	if n.Parent.TK == nil {
		log.Warn("ready() n.Parent.TK = nil", n.WidgetId, n.GetProgName())
		log.Warn("ready() n.Parent.TK = nil", n.Parent.WidgetId, n.Parent.GetProgName())
		return true
	}
	// this means you can add a new widgets
	return false
}

func ready(n *tree.Node) bool {
	if n == nil {
		log.Warn("ready() n = nil")
		return false
	}
	if n.TK == nil {
		log.Warn("ready() n.TK = nil", n.WidgetId, n.GetProgName())
		return false
	}
	if n.Parent == nil {
		log.Warn("ready() n.Parent = nil", n.WidgetId, n.GetProgName())
		return false
	}
	if n.Parent.TK == nil {
		log.Warn("ready() n.Parent.TK = nil", n.WidgetId, n.GetProgName())
		log.Warn("ready() n.Parent.TK = nil", n.Parent.WidgetId, n.Parent.GetProgName())
		return false
	}
	return true
}
func (n *node) ready() bool {
	if n == nil {
		return false
	}
	if n.tk == nil {
		return false
	}
	return true
}

func show(n *tree.Node, b bool) {
	var tk *guiWidget
	tk = n.TK.(*guiWidget)
	// tk = getTK(n)

	if tk == nil {
		return
	}
	if tk.uiControl == nil {
		return
	}
	if b {
		tk.uiControl.Show()
	} else {
		tk.uiControl.Hide()
	}
}

func enable(n *tree.Node, b bool) {
	var tk *guiWidget
	tk = n.TK.(*guiWidget)
	if n == nil {
		panic("WHAT? enable was passed nil. How does this even happen?")
	}
	if tk == nil {
		return
	}
	if tk.uiControl == nil {
		return
	}
	if b {
		tk.uiControl.Enable()
	} else {
		tk.uiControl.Disable()
	}
}

func (n *node) pad(b bool) {
	log.Warn("pad() on WidgetId =", n.WidgetId)

	t := n.tk
	if t == nil {
		log.Log(ERROR, "pad() toolkit struct == nil. for", n.WidgetId)
		return
	}

	switch n.WidgetType {
	case widget.Window:
		t.uiWindow.SetMargined(b)
		t.uiWindow.SetBorderless(b)
	case widget.Tab:
		tabSetMargined(t.uiTab, b)
	case widget.Group:
		t.uiGroup.SetMargined(b)
	case widget.Grid:
		t.uiGrid.SetPadded(b)
	case widget.Box:
		t.uiBox.SetPadded(b)
	default:
		log.Log(ERROR, "TODO: implement pad() for", n.WidgetType, n.progname)
	}
}

func (n *node) move(newParent *node) {
	p := n.parent

	switch p.WidgetType {
	case widget.Group:
	case widget.Tab:
		// tabSetMargined(tParent.uiTab, true)
	case widget.Window:
		// t.uiWindow.SetBorderless(false)
	case widget.Grid:
		// t.uiGrid.SetPadded(true)
	case widget.Box:
		log.Log(INFO, "TODO: move() where =", p.ParentId)
		log.Log(INFO, "TODO: move() for widget =", n.WidgetId)

		stretchy = true
		if p.tk.uiBox != nil {
			p.tk.uiBox.Append(n.tk.uiControl, stretchy)
		}
	default:
		log.Log(ERROR, "TODO: need to implement move() for type =", n.WidgetType)
		log.Log(ERROR, "TODO: need to implement move() for where =", p.ParentId)
		log.Log(ERROR, "TODO: need to implement move() for widget =", n.WidgetId)
	}
}

func widgetDelete(n *tree.Node) {
	log.Log(NOW, "widgetDelete()", n.WidgetId)
	var tk *guiWidget
	tk = n.TK.(*guiWidget)

	if n.WidgetType == widget.Window {
		log.Warn("DESTROY uiWindow here")
		log.Warn("NEED TO REMOVE n from parent.Children")
		tk.uiWindow.Destroy()
		tk.uiWindow = nil
		n.DeleteNode()
	}
}

func processAction(a *widget.Action) {
	log.Log(INFO, "processAction() START a.ActionType =", a.ActionType, "a.Value", a.Value)

	if a.ActionType == widget.ToolkitInit {
		Init()
		return
	}
	switch a.WidgetType {
	case widget.Root:
		if me.treeRoot == nil {
			log.Log(INFO, "processAction() found the treeRoot")
			me.treeRoot = me.myTree.AddNode(a)
		} else {
			log.Warn("processAction() Something terrible has happened")
			log.Warn("processAction() treeNode was sent an action", a.ActionType, a)
		}
		return
	}

	log.Warn("andlabs processAction() START a.WidgetId =", a.WidgetId, "a.ParentId =", a.ParentId, a.ActionType)
	switch a.WidgetType {
	case widget.Flag:
		log.Log(ERROR, "processAction() RE-IMPLEMENT LOG FLAGS")
		return
	}

	if me.treeRoot == nil {
		panic("me.treeRoot == nil")
	}


	if a.ActionType == widget.Add {
		add(a)
		return
	}

	n := me.treeRoot.FindWidgetId(a.WidgetId)
	if n == nil {
		log.Error(errors.New("andlabs processAction() ERROR findWidgetId found nil"), a.ActionType, a.WidgetType)
		log.Log(NOW, "processAction() ERROR findWidgetId found nil for id =", a.WidgetId)
		log.Log(NOW, "processAction() ERROR findWidgetId found nil", a.ActionType, a.WidgetType)
		log.Log(NOW, "processAction() ERROR findWidgetId found nil for id =", a.WidgetId)
		me.treeRoot.ListWidgets()
		return
		panic("findWidgetId found nil for id = " + string(a.WidgetId))
	}

	if a.ActionType == widget.Dump {
		log.Log(NOW, "processAction() Dump =", a.ActionType, a.WidgetType, n.State.ProgName)
		return
	}


	switch a.ActionType {
	case widget.Delete:
		widgetDelete(n)
	case widget.Show:
		show(n, true)
	case widget.Hide:
		show(n, false)
	case widget.Enable:
		enable(n, true)
	case widget.Disable:
		log.Warn("andlabs got disable for", n.WidgetId, n.State.ProgName)
		enable(n, false)
	case widget.Get:
		setText(n, a)
	case widget.GetText:
		switch a.WidgetType {
		case widget.Textbox:
			a.Value = n.State.Value
		}
	case widget.Set:
		setText(n, a)
	case widget.SetText:
		setText(n, a)
	case widget.AddText:
		addText(n, a)
	default:
		log.Log(ERROR, "processAction() Unknown =", a.ActionType, a.WidgetType)
	}
	log.Log(INFO, "processAction() END =", a.ActionType, a.WidgetType)
}