package main

import "log"
import "os"
// import "time"
import "fmt"

import "github.com/andlabs/ui"
import _ "github.com/andlabs/ui/winmanifest"

import "github.com/davecgh/go-spew/spew"

var mainwin *ui.Window
var maintab *ui.Tab
var tabcount int

func makeGroupEntries() ui.Control {
	group := ui.NewGroup("Entries")
	group.SetMargined(true)

	group.SetChild(ui.NewNonWrappingMultilineEntry())

	entryForm := ui.NewForm()
	entryForm.SetPadded(true)
	group.SetChild(entryForm)

	entryForm.Append("Entry", ui.NewEntry(), false)
	entryForm.Append("Password Entry", ui.NewPasswordEntry(), false)
	entryForm.Append("Search Entry", ui.NewSearchEntry(), false)
	entryForm.Append("Multiline Entry", ui.NewMultilineEntry(), true)
	entryForm.Append("Multiline Entry No Wrap", ui.NewNonWrappingMultilineEntry(), true)

	return group
}

func makeNumbersPage() ui.Control {
	hbox := ui.NewHorizontalBox()
	hbox.SetPadded(true)

	group := ui.NewGroup("Numbers")
	group.SetMargined(true)
	hbox.Append(group, true)

	vbox := ui.NewVerticalBox()
	vbox.SetPadded(true)
	group.SetChild(vbox)

	spinbox := ui.NewSpinbox(47, 100)
	slider  := ui.NewSlider(21, 100)
	pbar    := ui.NewProgressBar()

	spinbox.OnChanged(func(*ui.Spinbox) {
		slider.SetValue(spinbox.Value())
		pbar.SetValue(spinbox.Value())
	})
	slider.OnChanged(func(*ui.Slider) {
		spinbox.SetValue(slider.Value())
		pbar.SetValue(slider.Value())
	})
	vbox.Append(spinbox, false)
	vbox.Append(slider, false)
	vbox.Append(pbar, false)

	ip := ui.NewProgressBar()
	ip.SetValue(-1)
	vbox.Append(ip, false)

	group = ui.NewGroup("Lists")
	group.SetMargined(true)
	hbox.Append(group, true)

	vbox = ui.NewVerticalBox()
	vbox.SetPadded(true)
	group.SetChild(vbox)

	cbox := ui.NewCombobox()
	cbox.Append("Combobox Item 1")
	cbox.Append("Combobox Item 2")
	cbox.Append("Combobox Item 3")
	vbox.Append(cbox, false)

	ecbox := ui.NewEditableCombobox()
	ecbox.Append("Editable Item 1")
	ecbox.Append("Editable Item 2")
	ecbox.Append("Editable Item 3")
	vbox.Append(ecbox, false)

	rb := ui.NewRadioButtons()
	rb.Append("Radio Button 1")
	rb.Append("Radio Button 2")
	rb.Append("Radio Button 3")
	vbox.Append(rb, false)

	return hbox
}

func makeDataChoosersPage() ui.Control {
	hbox := ui.NewHorizontalBox()
	hbox.SetPadded(true)

	vbox := ui.NewVerticalBox()
	vbox.SetPadded(true)
	hbox.Append(vbox, false)

	vbox.Append(ui.NewDatePicker(), false)
	vbox.Append(ui.NewTimePicker(), false)
	vbox.Append(ui.NewDateTimePicker(), false)
	vbox.Append(ui.NewFontButton(), false)
	vbox.Append(ui.NewColorButton(), false)

	hbox.Append(ui.NewVerticalSeparator(), false)

	vbox = ui.NewVerticalBox()
	vbox.SetPadded(true)
	hbox.Append(vbox, true)

	grid := ui.NewGrid()
	grid.SetPadded(true)
	vbox.Append(grid, false)

	button := ui.NewButton("Open File")
	entry := ui.NewEntry()
	entry.SetReadOnly(true)
	button.OnClicked(func(*ui.Button) {
		filename := ui.OpenFile(mainwin)
		if filename == "" {
			filename = "(cancelled)"
		}
		entry.SetText(filename)
	})
	grid.Append(button,
		0, 0, 1, 1,
		false, ui.AlignFill, false, ui.AlignFill)
	grid.Append(entry,
		1, 0, 1, 1,
		true, ui.AlignFill, false, ui.AlignFill)

	button = ui.NewButton("Save File")
	entry2 := ui.NewEntry()
	entry2.SetReadOnly(true)
	button.OnClicked(func(*ui.Button) {
		filename := ui.SaveFile(mainwin)
		if filename == "" {
			filename = "(cancelled)"
		}
		entry2.SetText(filename)
	})
	grid.Append(button,
		0, 1, 1, 1,
		false, ui.AlignFill, false, ui.AlignFill)
	grid.Append(entry2,
		1, 1, 1, 1,
		true, ui.AlignFill, false, ui.AlignFill)

	msggrid := ui.NewGrid()
	msggrid.SetPadded(true)
	grid.Append(msggrid,
		0, 2, 2, 1,
		false, ui.AlignCenter, false, ui.AlignStart)

	button = ui.NewButton("Message Box")
	button.OnClicked(func(*ui.Button) {
		ui.MsgBox(mainwin,
			"This is a normal message box.",
			"More detailed information can be shown here.")
	})
	msggrid.Append(button,
		0, 0, 1, 1,
		false, ui.AlignFill, false, ui.AlignFill)
	button = ui.NewButton("Error Box")
	button.OnClicked(func(*ui.Button) {
		ui.MsgBoxError(mainwin,
			"This message box describes an error.",
			"More detailed information can be shown here.")
	})
	msggrid.Append(button,
		1, 0, 1, 1,
		false, ui.AlignFill, false, ui.AlignFill)

	return hbox
}

func setupUI() {
	mainwin = ui.NewWindow("Test Panel", 640, 480, false)
	mainwin.OnClosing(func(*ui.Window) bool {
		ui.Quit()
		return true
	})
	ui.OnShouldQuit(func() bool {
		mainwin.Destroy()
		return true
	})

	maintab = ui.NewTab()
	mainwin.SetChild(maintab)
	mainwin.SetMargined(true)

	name := "libUIdemo"
	maintab.Append(name, makeDemotable(name))
	tabcount = 0
	maintab.SetMargined(tabcount, true)

	mainwin.Show()
}

func addTableTab(name string, rows int, row1name string) {
	table, mh, model := makeTable(name, rows, row1name)
	log.Println(table, mh, model)

	tabcount += 1
	maintab.Append(name, table)
	maintab.SetMargined(tabcount, true)
}

func main() {
	ui.Main(setupUI)
}

type vmRowData struct {
	hostname	string
	size		int
	IPv6		string
	IPv4		string
	memory		int
	disk		int
}

type modelHandler struct {
	name		string
	rows		int
	bgcolorColumn	int
	yellowRow	int
	checkStates	[]int
	vms		[]vmRowData
	columnTypes	string
	funcColumnTypes	func() []ui.TableValue
	scanCellValue  	func(*modelHandler, int, int) ui.TableValue
	setCellValue  	func(*modelHandler, *ui.TableModel, int, int, ui.TableValue)
}

func newModelHandler(rows int) *modelHandler {
	mh := new(modelHandler)

	mh.rows            = rows
	mh.columnTypes     = "standard"
	mh.funcColumnTypes = standardColumnTypes
	mh.scanCellValue   = defaultCellValue
	mh.setCellValue    = defaultSetCellValue
	mh.bgcolorColumn   = 0
	mh.checkStates     = make([]int, mh.rows)
	mh.vms             = make([]vmRowData, mh.rows)
	mh.vms[1].hostname = "jcarr"
	mh.yellowRow       = -1

	log.Println("Called newModelhandler() with mh=", mh)
	spew.Dump(mh)
	return mh
}

func standardColumnTypes() []ui.TableValue {
	return []ui.TableValue{
		ui.TableColor{},		// row background color
		ui.TableString(""),		// column 0 text
		ui.TableColor{},		// column 0 text color
		ui.TableString("test"),		// column 1 button text
	}
}

func makeTable(name string, rows int, row1Name string) (*ui.Table, *modelHandler, *ui.TableModel) {
	mh := newModelHandler(rows)
	mh.name = name
	model := ui.NewTableModel(mh)

	table := ui.NewTable(
		&ui.TableParams{
			Model:	model,
			RowBackgroundColorModelColumn:	mh.bgcolorColumn,
	})

	table.AppendTextColumn(row1Name, 1, ui.TableModelColumnAlwaysEditable, nil)
	table.AppendButtonColumn("Details", 3, ui.TableModelColumnAlwaysEditable)

	return table, mh, model
}

func defaultCellValue(mh *modelHandler, row, column int) ui.TableValue {
	switch column {
	case 0:
		if (row % 2) == 1 {
			return ui.TableColor{0.5, 0.5, 0.5, .1}
		}
		return nil
	case 1:
		return ui.TableString(fmt.Sprintf("jcarrgood %d", row))
	}
	return ui.TableString(fmt.Sprintf("jcarrbad %d", row))
}

func defaultSetCellValue(mh *modelHandler, m *ui.TableModel, row, column int, value ui.TableValue) {
	if column == 3 {		// button row (?)
		log.Println("Button was pressed START", row, column)
	}
	return
}

func newDemoModelHandler() *modelHandler {
	mh := new(modelHandler)
	mh.rows = 20
	mh.funcColumnTypes = demoColumnTypes
	mh.scanCellValue   = demoCellValue
	mh.setCellValue    = demoSetCellValue
	mh.checkStates = make([]int, mh.rows)
	mh.vms         = make([]vmRowData, mh.rows)
	mh.vms[8].hostname = "host1"
	mh.vms[9].hostname = "host3test"
	mh.yellowRow = -1
	log.Println("Called newDemoModelhandler() with mh=", mh)
	spew.Dump(mh)
	return mh
}

func demoColumnTypes() []ui.TableValue {
	return []ui.TableValue{
		ui.TableString(""),		// column 0 text
		ui.TableString(""),		// column 1 text
		ui.TableString(""),		// column 2 text
		ui.TableColor{},		// row background color
		ui.TableColor{},		// column 1 text color
		ui.TableImage{},		// column 1 image
		ui.TableString(""),		// column 4 button text
		ui.TableInt(0),			// column 3 checkbox state
		ui.TableInt(0),			// column 5 progress
	}
}

var img [2]*ui.Image

func demoCellValue(mh *modelHandler, row, column int) ui.TableValue {
	switch column {
	case 0:
		return ui.TableString(fmt.Sprintf("Row %d", row))
	case 1:
		return ui.TableString("Colors!")
	case 7:
		return ui.TableInt(mh.checkStates[row])
	case 8:
		if row == 0 {
			return ui.TableInt(0)
		}
		if row == 13 {
			return ui.TableInt(100)
		}
		if row == 14 {
			return ui.TableInt(-1)
		}
		return ui.TableInt(50)
	case 5:
		if row < 8 {
			return ui.TableImage{img[0]}
		}
		return ui.TableImage{img[1]}
	case 4:
		if (row % 2) == 1 {
			return ui.TableColor{0.5, 0, 0.75, 1}
		}
		return nil
	case 3:
		if row == mh.yellowRow {
			return ui.TableColor{1, 1, 0, .1}
		}
		if row == 3 {
			// Red with .1 transparency
			// R G B Trans
			return ui.TableColor{1, 0, 0, .1}
		}
		if row == 11 {
			return ui.TableColor{0, 0.5, 1, 0.5}
		}
		return nil
	case 2:
		return ui.TableString(mh.vms[row].hostname)
	case 6:
		return ui.TableString("Make Yellow")
	}
	panic("unreachable in demoCellValue()")
}

func makeDemotable(name string) *ui.Table {
	img[0] = ui.NewImage(16, 16)
	img[1] = ui.NewImage(16, 16)

	mh := newDemoModelHandler()
	mh.name = name
	model := ui.NewTableModel(mh)

	table := ui.NewTable(
		&ui.TableParams{
			Model:	model,
			RowBackgroundColorModelColumn:	3,
	})

	table.AppendTextColumn("Column 1", 0, ui.TableModelColumnNeverEditable, nil)

	table.AppendImageTextColumn("Column 2", 5,
		1, ui.TableModelColumnNeverEditable, &ui.TableTextColumnOptionalParams{
			ColorModelColumn:		4,
		});

	table.AppendTextColumn("hostname", 2, ui.TableModelColumnAlwaysEditable, nil)
	table.AppendCheckboxColumn("Checkboxes", 7, ui.TableModelColumnAlwaysEditable)
	table.AppendButtonColumn("Buttons", 6, ui.TableModelColumnAlwaysEditable)
	table.AppendProgressBarColumn("Progress Bar", 8)

	return table
}

func demoSetCellValue(mh *modelHandler, m *ui.TableModel, row, column int, value ui.TableValue) {
	if column == 2 {
		mh.vms[row].hostname = string(value.(ui.TableString))
	}
	if column == 6 {		// row background color
		prevYellowRow := mh.yellowRow
		mh.yellowRow = row
		if prevYellowRow != -1 {
			m.RowChanged(prevYellowRow)
		}
		m.RowChanged(mh.yellowRow)
	}
	if column == 7 {		// checkboxes
		mh.checkStates[row] = int(value.(ui.TableInt))
	}
}

func (mh *modelHandler) NumRows(m *ui.TableModel) int {
	// log.Println("NumRows() with m=", m)
	return mh.rows
}

// FYI: this routine seems to be called around 10 to 100 times a second for each table
func (mh *modelHandler) ColumnTypes(m *ui.TableModel) []ui.TableValue {
	if (mh.funcColumnTypes == nil) {
		log.Println("ColumnTypes NOT DEFINED. This table wasn't setup correctly! mh.funcColmnTypes == nil")
		os.Exit(-1)
	}
	return mh.funcColumnTypes()
}

// TODO: Figure out why this is being called 1000 times a second (10 times for each row & column)
func (mh *modelHandler) CellValue(m *ui.TableModel, row, column int) ui.TableValue {
	if (mh.scanCellValue == nil) {
		log.Println("CellValue NOT DEFINED. This table wasn't setup correctly! mh.scanCellValue == nil")
		os.Exit(-1)
	}
	return mh.scanCellValue(mh, row, column)
}

func (mh *modelHandler) SetCellValue(m *ui.TableModel, row, column int, value ui.TableValue) {
	log.Println("SetCallValue() START row=", row, "column=", column, "value=", value)
	// spew.Dump(m)
	// spew.Dump(mh)
	if (mh.setCellValue == nil) {
		log.Println("CellValue NOT DEFINED. This table wasn't setup correctly! mh.scanCellValue == nil")
		os.Exit(-1)
	}
	// spew.Dump(m)
	mh.setCellValue(mh, m, row, column, value)
	log.Println("SetCallValue() END")
}