// a table is a grid with X columns and 1 row of header names
// that means that the toolkits might be able to sort the table
// pushing traditional application development to the display
// is that a good idea?

package gui

import (
	"go.wit.com/lib/protobuf/guipb"
	"go.wit.com/log"
	"go.wit.com/widget"
	"google.golang.org/protobuf/types/known/anypb"
)

// should this be a gadget or in here with the widget primatives?
// a table is a group of widgets. Then again, Grid & Box 'widgets' are
// really groups of widgets also

/*
mytable := NewTable(5) // make a table with 5 things

type mytable struct {
	first TableRow(1, Widget.TextBox, "First Name")
	song	TableRow(2, Widget.Label, "Favorite Song")

func (t *Table) NewRow() *TableRow {
	r := new(myRow)
	r.first =
	r.Cell1 = whatever widget type first is
	r.Cell2 = whatever widget type song is


type songTable TableDef {
	first TableCell `default:string`
	song TableCell
	GuiPlugin  string `arg:"Label" header:"Favorite Song"`
}

func makeSongTable() {
	tb := NewTable(5)

func Show() {
	for each row {
		for loop all strings()
		is string button?
		for loop all ints()
		for loop all times()
		for loop all bools()

	}s

func RefreshTime(t *time.Duration) {
}
*/

// shortcut. makes a window with just a grid in it
func NewTableWindow(title string) *NodeTable {
	t := new(NodeTable)
	/*
		t.pb = new(guipb.Table)
		t.pb.Title = title
	*/
	t.tb = me.rootNode.newNode(title, widget.Table)
	t.tb.label = title

	return t
}

// makes a grid inside an existing Widget
func (n *Node) NewTable(title string) *NodeTable {
	t := new(NodeTable)

	t.grid = n.RawGrid()

	t.tb = t.grid.newNode(title, widget.Table)
	t.tb.label = title

	return t
}

type NodeColumn struct {
	Title string
	Vals  []string
}

type NodeTable struct {
	grid   *Node
	tb     *Node
	Custom func()
}

func ShowTable(pb *guipb.Table) {
	// make a new action and populate the current node state
	a := getNewAction(me.rootNode, widget.Show)

	makeTableWidgets(pb)

	nt := guipb.NewTables()
	nt.Append(pb)
	a.TablePB, err = nt.Marshal()
	if err != nil {
		log.Info("unmarshal error", err)
		return
	}
	log.Info("send action to plugin", "pb len =", len(a.TablePB))
	sendActionToPlugin(a)

}

func makeTableWidgets(pb *guipb.Table) {
	if pb == nil {
		log.Info("pb was nil")
		return
	}
	if me.rootNode == nil {
		log.Info("me.rootNode was nil")
		return
	}
	win := addNode()
	pb.Window = new(guipb.Widget)
	pb.Window.Id = int64(win.id)
	pb.Window.Name = pb.Title

	grid := addNode()
	pb.Grid = new(guipb.Widget)
	pb.Grid.Id = int64(grid.id)
	pb.Grid.Name = "gridtablePB"

	/*
		// get unique widget ID numbers for the headers
		for i, r := range pb.Order {
			n := addNode()
			r.Id = int64(n.id)
		}
	*/

	for i, r := range pb.StringRows {
		log.Info("gui: got string row:", pb.Title, i, r.Header, r.Vals)
		header := addNode()
		r.Header.Id = int64(header.id)
		for _, v := range r.Vals {
			label := addNode()
			pbwidget := new(guipb.Widget)
			pbwidget.Id = int64(label.id)
			pbwidget.Name = v
			r.Widgets = append(r.Widgets, pbwidget)
			// log.Info("gui: added new string", pbwidget)
		}
	}

	for i, r := range pb.IntRows {
		log.Info("gui: got int row:", i, r.Header, r.Vals)
		header := addNode()
		r.Header.Id = int64(header.id)
		for _, v := range r.Vals {
			label := addNode()
			pbwidget := new(guipb.Widget)
			pbwidget.Id = int64(label.id)
			pbwidget.Size = v
			r.Widgets = append(r.Widgets, pbwidget)
			// log.Info("gui: added new int", pbwidget)
		}
	}

	for i, r := range pb.TimeRows {
		log.Info("gui: got time row:", i, r.Header, r.Vals)
		header := addNode()
		r.Header.Id = int64(header.id)
		for _, v := range r.Vals {
			label := addNode()
			pbwidget := new(guipb.Widget)
			pbwidget.Id = int64(label.id)
			anyValue, err := anypb.New(v)
			if err != nil {
				log.Info("gui: failed to add time", err)
				continue
			}
			pbwidget.Val = anyValue
			r.Widgets = append(r.Widgets, pbwidget)
			// log.Info("gui: added new val", pbwidget)
		}
	}
}