package giowrap

import (
	"image"

	"gioui.org/ui"
	"gioui.org/ui/f32"
	"gioui.org/ui/layout"
)

type Grid struct {
	Cols          int
	Height, Width int

	macro    ui.MacroOp
	ops      *ui.Ops
	cs       layout.Constraints
	mode     gridMode
	row, col int
}

type GridChild struct {
	dims  layout.Dimens
	macro ui.MacroOp
}

type gridMode uint8

const (
	modeNone gridMode = iota
	modeBegun
)

func (g *Grid) Init(ops *ui.Ops, cs layout.Constraints) layout.Constraints {
	g.mode = modeBegun
	g.ops = ops
	g.cs = cs
	g.row, g.col = 0, 0

	cs.Height.Min = 0

	if g.Height != 0 {
		g.cs.Height.Max = g.Height
	}
	if g.Width != 0 {
		g.cs.Width.Max = g.Width
	}

	cs.Width.Max = g.cs.Width.Max / g.Cols
	if g.Cols > 1 {
		cs.Width.Min = cs.Width.Max
	}
	return cs
}

func (g *Grid) Begin() {
	g.macro.Record(g.ops)
}

func (g *Grid) End(dims layout.Dimens) GridChild {
	if g.mode != modeBegun {
		panic("Must call Grid.Begin() before adding children.")
	}
	g.macro.Stop()
	return GridChild{dims: dims, macro: g.macro}
}

func (g *Grid) Layout(cs ...GridChild) layout.Dimens {
	rowheight := 0
	height := 0
	var width float32
	var maxwidth float32
	for _, c := range cs {
		var stack ui.StackOp
		stack.Push(g.ops)
		c.macro.Add(g.ops)
		stack.Pop()
		if c.dims.Size.Y > rowheight {
			rowheight = c.dims.Size.Y
		}
		g.col = g.col + 1
		var x float32
		if g.Cols == 1 {
			x = float32(c.dims.Size.X)
			if x > maxwidth {
				maxwidth = x
			}
		} else {
			x = float32(g.cs.Width.Max / g.Cols)
		}
		if g.col < g.Cols {
			ui.TransformOp{}.Offset(f32.Point{X: x}).Add(g.ops)
			width = width + x
		} else {
			g.col = 0
			ui.TransformOp{}.Offset(f32.Point{X: -width, Y: float32(rowheight)}).Add(g.ops)
			g.row = g.row + 1
			height = height + rowheight
			width = 0
			rowheight = 0
		}
	}
	if height == 0 {
		height = rowheight
	}
	g.mode = modeNone
	var dwidth int
	if g.Cols == 1 {
		dwidth = int(maxwidth)
	} else {
		dwidth = g.cs.Width.Max
	}
	return layout.Dimens{Size: image.Point{dwidth, height}}
}

func toPointF(p image.Point) f32.Point {
	return f32.Point{X: float32(p.X), Y: float32(p.Y)}
}

type GridOption interface{ DoGridOption(*Grid) }

type HeightOpt struct{ height int }

func Height(x int) HeightOpt             { return HeightOpt{x} }
func (x HeightOpt) DoGridOption(g *Grid) { g.Height = x.height }

func NewGrid(cols int, gops ...GridOption) WidgetCombinator {
	g := &Grid{Cols: cols}
	for _, gop := range gops {
		gop.DoGridOption(g)
	}
	gcs := make([]GridChild, 0)
	return func(ws ...Widget) Widget {
		return NewfWidget(func(ctx *Context) {
			cs := g.Init(ctx.ops, ctx.cs)
			ctx.cs = cs
			for _, w := range ws {
				g.Begin()
				w.Layout(ctx)
				ctx.cs = cs // widget layout can modify constraints...
				gcs = append(gcs, g.End(ctx.dims))
			}
			ctx.dims = g.Layout(gcs...)
			gcs = gcs[0:0]
		})
	}
}