package main

import (
	"strings"

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

func placeBox(n *tree.Node, startW int, startH int) {
	var tk *guiWidget
	tk = n.TK.(*guiWidget)

	if n.WidgetType != widget.Box {
		return
	}
	showWidgetPlacement(n, true, "boxS()")

	newW := startW
	newH := startH
	for _, child := range tk.children {
		placeWidgets(child.node, newW, newH)
		// n.showWidgetPlacement(logNow, "boxS()")
		newR := realGocuiSize(child.node)
		w := newR.w1 - newR.w0
		h := newR.h1 - newR.h0
		if child.direction == widget.Horizontal {
			log.Log(NOW, "BOX IS HORIZONTAL", n.String(), "newWH()", newW, newH, "child()", w, h, child.String())
			// expand based on the child width
			newW += w
		} else {
			log.Log(NOW, "BOX IS VERTICAL  ", n.String(), "newWH()", newW, newH, "child()", w, h, child.String())
			// expand based on the child height
			newH += h
		}
	}

	// just compute this every time?
	// newR := n.realGocuiSize()

	showWidgetPlacement(n, true, "boxE()")
}

func placeWidgets(n *tree.Node, startW int, startH int) {
	if n == nil {
		return
	}
	if me.treeRoot == nil {
		return
	}

	var tk *guiWidget
	tk = n.TK.(*guiWidget)

	switch n.WidgetType {
	case widget.Window:
		for _, child := range tk.children {
			placeWidgets(child.node, me.RawW, me.RawH)
			return
		}
	case widget.Tab:
		for _, child := range tk.children {
			placeWidgets(child.node, me.RawW, me.RawH)
			return
		}
	case widget.Grid:
		placeGrid(n, startW, startH)
	case widget.Box:
		placeBox(n, startW, startH)
	case widget.Group:
		// move the group to the parent's next location
		tk.gocuiSetWH(startW, startH)
		showWidgetPlacement(n, true, "group()")

		newW := startW + me.GroupPadW
		newH := startH + 3 // normal hight of the group label
		// now move all the children aka: run place() on them
		for _, child := range tk.children {
			placeWidgets(child.node, newW, newH)
			newR := realGocuiSize(child.node)
			// w := newR.w1 - newR.w0
			h := newR.h1 - newR.h0

			// increment straight down
			newH += h
		}
	default:
		tk.gocuiSetWH(startW, startH)
		// n.moveTo(startW, startH)
	}
}

func placeGrid(n *tree.Node, startW int, startH int) {
	var w *guiWidget
	w = n.TK.(*guiWidget)
	showWidgetPlacement(n, true, "grid0:")
	if n.WidgetType != widget.Grid {
		return
	}

	// first compute the max sizes of the rows and columns
	for _, child := range w.children {
		newR := realGocuiSize(child.node)
		childW := newR.w1 - newR.w0
		childH := newR.h1 - newR.h0

		// set the child's realWidth, and grid offset
		if w.widths[child.AtW] < childW {
			w.widths[child.AtW] = childW
		}
		if w.heights[child.AtH] < childH {
			w.heights[child.AtH] = childH
		}
		// child.showWidgetPlacement(logInfo, "grid: ")
		log.Log(INFO, "placeGrid:", child.String(), "child()", childW, childH, "At()", child.AtW, child.AtH)
	}

	// find the width and height offset of the grid for AtW,AtH
	for _, child := range w.children {
		showWidgetPlacement(w.node, true, "grid1:")

		var totalW, totalH int
		for i, w := range w.widths {
			if i < child.AtW {
				totalW += w
			}
		}
		for i, h := range w.heights {
			if i < child.AtH {
				totalH += h
			}
		}

		// the new corner to move the child to
		newW := startW + totalW
		newH := startH + totalH

		log.Log(INFO, "placeGrid:", child.String(), "new()", newW, newH, "At()", child.AtW, child.AtH)
		placeWidgets(child.node, newW, newH)
		showWidgetPlacement(child.node, true, "grid2:")
	}
	showWidgetPlacement(n, true, "grid3:")
}

// computes the real, actual size of all the gocli objects in a widget
func realGocuiSize(n *tree.Node) *rectType {
	var f func(n *tree.Node, r *rectType)
	newR := new(rectType)
	// initialize the values to opposite
	newR.w0 = 80
	newR.h0 = 24
	if me.baseGui != nil {
		maxW, maxH := me.baseGui.Size()
		newR.w0 = maxW
		newR.h0 = maxH
	}
	newR.w1 = 0
	newR.h1 = 0

	// expand the rectangle to the biggest thing displayed
	f = func(n *tree.Node, r *rectType) {
		var tk *guiWidget
		tk = n.TK.(*guiWidget)
		newR := tk.gocuiSize
		if !tk.isFake {
			if r.w0 > newR.w0 {
				r.w0 = newR.w0
			}
			if r.h0 > newR.h0 {
				r.h0 = newR.h0
			}
			if r.w1 < newR.w1 {
				r.w1 = newR.w1
			}
			if r.h1 < newR.h1 {
				r.h1 = newR.h1
			}
		}
		for _, child := range tk.children {
			f(child.node, r)
		}
	}
	f(n, newR)
	return newR
}

func textSize(n *tree.Node) (int, int) {
	var tk *guiWidget
	tk = n.TK.(*guiWidget)
	var width, height int

	for _, s := range strings.Split(widget.GetString(tk.value), "\n") {
		if width < len(s) {
			width = len(s)
		}
		height += 1
	}
	return width, height
}