func (h *Host) ActivePanelIndex(zone Zone) int {
	if int(zone) >= zoneCount || h.zones[zone].isEmpty() {
		return -1
	}
	return h.zones[zone].activeIdx
}

func BottomRatio(r float32) HostOption {
	return func(c *hostConfig) { c.bottomRatio = clampRatio(r) }
}

func CenterContent(w widget.Widget) HostOption {
	return func(c *hostConfig) { c.centerContent = w }
}

func (h *Host) Children() []widget.Widget {
	var children []widget.Widget

	// Center content.
	if h.cfg.centerContent != nil {
		children = append(children, h.cfg.centerContent)
	}

	// Active panel content from each zone.
	for z := Zone(0); z < zoneCount; z++ {
		if z == Center {
			continue
		}
		panel := h.zones[z].activePanel()
		if panel != nil && panel.Content() != nil {
			children = append(children, panel.Content())
		}
	}

	if len(children) == 0 {
		return nil
	}
	return children
}

func ColorSchemeOpt(cs ZoneColorScheme) HostOption {
	return func(c *hostConfig) { c.colorScheme = cs }
}

func (h *Host) Dock(panel *Panel, zone Zone) {
	if panel == nil {
		return
	}
	if int(zone) >= zoneCount {
		return
	}

	// Remove from any existing zone first.
	h.undockFromAll(panel)

	h.zones[zone].addPanel(panel)

	// ADR-028: parent chain for upward dirty propagation.
	if content := panel.Content(); content != nil {
		type parentSetter interface{ SetParent(widget.Widget) }
		if ps, ok := content.(parentSetter); ok {
			ps.SetParent(h)
		}
	}
}

func (h *Host) Draw(ctx widget.Context, canvas widget.Canvas) {
	bounds := h.Bounds()
	if bounds.IsEmpty() {
		return
	}

	// Draw center content first (background).
	if h.cfg.centerContent != nil {
		h.cfg.centerContent.Draw(ctx, canvas)
	}

	// Draw edge zones on top of center.
	for z := Zone(0); z < zoneCount; z++ {
		if z == Center || h.zones[z].isEmpty() {
			continue
		}
		h.drawZone(ctx, canvas, z)
	}
}

func (h *Host) Event(ctx widget.Context, e event.Event) bool {
	// Check edge zone tab bars for click events.
	if consumed := h.handleZoneTabEvents(ctx, e); consumed {
		return true
	}

	// Forward to active panel content in edge zones.
	for z := Zone(0); z < zoneCount; z++ {
		if z == Center {
			continue
		}
		panel := h.zones[z].activePanel()
		if panel != nil && panel.Content() != nil {
			if panel.Content().Event(ctx, e) {
				return true
			}
		}
	}

	// Forward to center content.
	if h.cfg.centerContent != nil {
		if h.cfg.centerContent.Event(ctx, e) {
			return true
		}
	}

	return false
}

func (h *Host) Layout(ctx widget.Context, constraints geometry.Constraints) geometry.Size {
	totalSize := constraints.Constrain(geometry.Sz(constraints.MaxWidth, constraints.MaxHeight))
	if totalSize.Width <= 0 || totalSize.Height <= 0 {
		totalSize = geometry.Sz(defaultHostWidth, defaultHostHeight)
	}

	origin := h.Bounds().Min
	rects := h.computeZoneRects(totalSize, origin)

	// Layout zone contents.
	for z := Zone(0); z < zoneCount; z++ {
		h.zones[z].bounds = rects[z]
		h.layoutZone(ctx, z, rects[z])
	}

	// Layout center content.
	if h.cfg.centerContent != nil {
		centerRect := rects[Center]
		cc := geometry.Tight(centerRect.Size())
		h.cfg.centerContent.Layout(ctx, cc)
		if setter, ok := h.cfg.centerContent.(interface{ SetBounds(geometry.Rect) }); ok {
			setter.SetBounds(centerRect)
		}
	}

	return totalSize
}

func LeftRatio(r float32) HostOption {
	return func(c *hostConfig) { c.leftRatio = clampRatio(r) }
}

func (h *Host) MovePanel(panel *Panel, targetZone Zone) bool {
	if panel == nil || int(targetZone) >= zoneCount {
		return false
	}

	// Find current zone.
	found := false
	for z := Zone(0); z < zoneCount; z++ {
		if h.zones[z].containsPanel(panel) {
			found = true
			break
		}
	}
	if !found {
		return false
	}

	h.undockFromAll(panel)
	h.zones[targetZone].addPanel(panel)
	return true
}

func NewHost(opts ...HostOption) *Host {
	h := &Host{
		painter: DefaultPainter{},
	}
	h.SetVisible(true)
	h.SetEnabled(true)

	h.cfg.leftRatio = defaultEdgeRatio
	h.cfg.rightRatio = defaultEdgeRatio
	h.cfg.topRatio = defaultEdgeRatio
	h.cfg.bottomRatio = defaultEdgeRatio

	for _, opt := range opts {
		opt(&h.cfg)
	}

	if h.cfg.painter != nil {
		h.painter = h.cfg.painter
	}

	// ADR-028: parent chain for upward dirty propagation.
	// Flutter: RenderObject.adoptChild sets parent on each child.
	if h.cfg.centerContent != nil {
		type parentSetter interface{ SetParent(widget.Widget) }
		if ps, ok := h.cfg.centerContent.(parentSetter); ok {
			ps.SetParent(h)
		}
	}

	return h
}

func OnPanelClose(fn func(panel *Panel, zone Zone)) HostOption {
	return func(c *hostConfig) { c.onPanelClose = fn }
}

func PainterOpt(p Painter) HostOption {
	return func(c *hostConfig) { c.painter = p }
}

func (h *Host) PanelCount(zone Zone) int {
	if int(zone) >= zoneCount {
		return 0
	}
	return len(h.zones[zone].panels)
}

func (h *Host) PanelZone(panel *Panel) (Zone, bool) {
	if panel == nil {
		return 0, false
	}
	for z := Zone(0); z < zoneCount; z++ {
		if h.zones[z].containsPanel(panel) {
			return z, true
		}
	}
	return 0, false
}

func RightRatio(r float32) HostOption {
	return func(c *hostConfig) { c.rightRatio = clampRatio(r) }
}

func (h *Host) SetActivePanelIndex(zone Zone, idx int) {
	if int(zone) >= zoneCount {
		return
	}
	g := &h.zones[zone]
	if idx < 0 || idx >= len(g.panels) {
		return
	}
	g.activeIdx = idx
}

func TopRatio(r float32) HostOption {
	return func(c *hostConfig) { c.topRatio = clampRatio(r) }
}

func (h *Host) Undock(panel *Panel) bool {
	if panel == nil {
		return false
	}
	removed := h.undockFromAll(panel)

	// ADR-028: clear parent on removal.
	if removed {
		if content := panel.Content(); content != nil {
			type parentSetter interface{ SetParent(widget.Widget) }
			if ps, ok := content.(parentSetter); ok {
				ps.SetParent(nil)
			}
		}
	}

	return removed
}

type Host struct {
	widget.WidgetBase
	cfg	hostConfig
	painter	Painter

	// Zone groups, indexed by Zone constant.
	zones	[zoneCount]group

	// Tab interaction state per zone.
	tabStates	[zoneCount][]ZoneTabState
}