layout.go

package main

import (
	"github.com/charmbracelet/lipgloss"
)

type Selection struct {
	ID     int
	StartX int
	StartY int
	EndX   int
	EndY   int
}

type Node interface {
	Resize(w, h int)
	View(activePaneID int, sel Selection, x, y int) string
	Width() int
	Height() int
	HitTest(x, y int) int // Returns PaneID or -1
}

type SplitType int

const (
	SplitVertical SplitType = iota
	SplitHorizontal
)

type Split struct {
	Type     SplitType
	Children []Node
	Ratios   []float64
	width    int
	height   int
}

func (s *Split) Resize(w, h int) {
	s.width = w
	s.height = h

	n := len(s.Children)
	if n == 0 {
		return
	}

	if len(s.Ratios) != n {
		s.Ratios = make([]float64, n)
		for i := range s.Ratios {
			s.Ratios[i] = 1.0 / float64(n)
		}
	}

	totalSize := w
	if s.Type == SplitHorizontal {
		totalSize = h
	}

	currentSize := 0
	for i, child := range s.Children {
		var size int
		if i == n-1 {
			size = totalSize - currentSize
		} else {
			size = int(float64(totalSize) * s.Ratios[i])
		}
		
		if size < 1 { size = 1 } // Min size
		
		if s.Type == SplitVertical {
			child.Resize(size, h)
		} else {
			child.Resize(w, size)
		}
		currentSize += size
	}
}

func (s *Split) View(activePaneID int, sel Selection, x, y int) string {
	var views []string
	curX, curY := x, y
	for _, c := range s.Children {
		views = append(views, c.View(activePaneID, sel, curX, curY))
		if s.Type == SplitVertical {
			curX += c.Width()
		} else {
			curY += c.Height()
		}
	}
	if s.Type == SplitVertical {
		return lipgloss.JoinHorizontal(lipgloss.Top, views...)
	} else {
		return lipgloss.JoinVertical(lipgloss.Left, views...)
	}
}

func (s *Split) Width() int  { return s.width }
func (s *Split) Height() int { return s.height }

func (s *Split) HitTest(x, y int) int {
	if x < 0 || y < 0 || x >= s.width || y >= s.height {
		return -1
	}

	curX, curY := 0, 0
	for _, child := range s.Children {
		// Pass relative coordinates
		res := child.HitTest(x-curX, y-curY)
		if res != -1 {
			return res
		}
		if s.Type == SplitVertical {
			curX += child.Width()
		} else {
			curY += child.Height()
		}
	}
	return -1
}

// PaneNode wraps a Pane to implement Node
type PaneNode struct {
	Pane *Pane
}

func (pn *PaneNode) Resize(w, h int) {
	innerW := w - 2
	innerH := h - 2
	if innerW < 1 { innerW = 1 }
	if innerH < 1 { innerH = 1 }
	pn.Pane.Resize(innerW, innerH)
}

func (pn *PaneNode) View(activePaneID int, sel Selection, x, y int) string {
	isActive := pn.Pane.id == activePaneID
	borderColor := lipgloss.Color("241")
	if isActive {
		borderColor = lipgloss.Color("63")
	}

	content := pn.Pane.View(sel)
	
	return lipgloss.NewStyle().
		Border(lipgloss.NormalBorder()).
		BorderForeground(borderColor).
		Width(pn.Pane.width).
		Height(pn.Pane.height).
		Render(content)
}

func (pn *PaneNode) Width() int { return pn.Pane.width + 2 }
func (pn *PaneNode) Height() int { return pn.Pane.height + 2 }

func (pn *PaneNode) HitTest(x, y int) int {
	if x >= 0 && x < pn.Width() && y >= 0 && y < pn.Height() {
		return pn.Pane.id
	}
	return -1
}