func (g *RadialGradientBrush) AddColorStop(offset float64, color gg.RGBA) *RadialGradientBrush {
	g.Stops = append(g.Stops, GradientStop{Offset: offset, Color: color})
	return g
}

func (g *LinearGradientBrush) AddColorStop(offset float64, color gg.RGBA) *LinearGradientBrush {
	g.Stops = append(g.Stops, GradientStop{Offset: offset, Color: color})
	return g
}

func (g *SweepGradientBrush) AddColorStop(offset float64, color gg.RGBA) *SweepGradientBrush {
	g.Stops = append(g.Stops, GradientStop{Offset: offset, Color: color})
	return g
}

func BrushFromGG(b gg.Brush) Brush {
	switch brush := b.(type) {
	case gg.SolidBrush:
		return SolidBrush{Color: brush.Color}
	case *gg.LinearGradientBrush:
		return linearGradientFromGG(brush)
	case *gg.RadialGradientBrush:
		return radialGradientFromGG(brush)
	case *gg.SweepGradientBrush:
		return sweepGradientFromGG(brush)
	default:
		// For unknown brush types, sample at origin and use as solid color
		// This is a fallback that preserves color but loses patterns
		color := b.ColorAt(0, 0)
		return SolidBrush{Color: color}
	}
}

func NewLinearGradientBrush(x0, y0, x1, y1 float64) *LinearGradientBrush {
	return &LinearGradientBrush{
		Start:	gg.Point{X: x0, Y: y0},
		End:	gg.Point{X: x1, Y: y1},
		Stops:	nil,
		Extend:	ExtendPad,
	}
}

func NewPatternBrush(imageRef ImageRef) *PatternBrush {
	return &PatternBrush{
		Image:		imageRef,
		Repeat:		RepeatBoth,
		Transform:	gg.Identity(),
	}
}

func NewRadialGradientBrush(cx, cy, startRadius, endRadius float64) *RadialGradientBrush {
	center := gg.Point{X: cx, Y: cy}
	return &RadialGradientBrush{
		Center:		center,
		Focus:		center,	// Default focus at center
		StartRadius:	startRadius,
		EndRadius:	endRadius,
		Stops:		nil,
		Extend:		ExtendPad,
	}
}

func NewSolidBrush(color gg.RGBA) SolidBrush {
	return SolidBrush{Color: color}
}

func NewSweepGradientBrush(cx, cy, startAngle float64) *SweepGradientBrush {
	const twoPi = 6.283185307179586	// 2 * math.Pi
	return &SweepGradientBrush{
		Center:		gg.Point{X: cx, Y: cy},
		StartAngle:	startAngle,
		EndAngle:	startAngle + twoPi,
		Stops:		nil,
		Extend:		ExtendPad,
	}
}

func (g *SweepGradientBrush) SetEndAngle(endAngle float64) *SweepGradientBrush {
	g.EndAngle = endAngle
	return g
}

func (g *RadialGradientBrush) SetExtend(mode ExtendMode) *RadialGradientBrush {
	g.Extend = mode
	return g
}

func (g *SweepGradientBrush) SetExtend(mode ExtendMode) *SweepGradientBrush {
	g.Extend = mode
	return g
}

func (g *LinearGradientBrush) SetExtend(mode ExtendMode) *LinearGradientBrush {
	g.Extend = mode
	return g
}

func (g *RadialGradientBrush) SetFocus(fx, fy float64) *RadialGradientBrush {
	g.Focus = gg.Point{X: fx, Y: fy}
	return g
}

func (b *PatternBrush) SetRepeat(mode RepeatMode) *PatternBrush {
	b.Repeat = mode
	return b
}

func (b *PatternBrush) SetTransform(m gg.Matrix) *PatternBrush {
	b.Transform = m
	return b
}

type SolidBrush struct {
	Color gg.RGBA
}

type LinearGradientBrush struct {
	Start	gg.Point	// Start point of the gradient
	End	gg.Point	// End point of the gradient
	Stops	[]GradientStop	// Color stops defining the gradient
	Extend	ExtendMode	// How gradient extends beyond bounds
}

type RadialGradientBrush struct {
	Center		gg.Point	// Center of the gradient circle
	Focus		gg.Point	// Focal point (can differ from center)
	StartRadius	float64		// Inner radius where gradient begins (t=0)
	EndRadius	float64		// Outer radius where gradient ends (t=1)
	Stops		[]GradientStop	// Color stops defining the gradient
	Extend		ExtendMode	// How gradient extends beyond bounds
}

type SweepGradientBrush struct {
	Center		gg.Point	// Center of the sweep
	StartAngle	float64		// Start angle in radians
	EndAngle	float64		// End angle in radians
	Stops		[]GradientStop	// Color stops defining the gradient
	Extend		ExtendMode	// How gradient extends beyond bounds
}

type PatternBrush struct {
	Image		ImageRef	// Reference to the pattern image in the pool
	Repeat		RepeatMode	// How the pattern repeats
	Transform	gg.Matrix	// Transform applied to the pattern
}

type GradientStop struct {
	Offset	float64	// Position in gradient, 0.0 to 1.0
	Color	gg.RGBA	// Color at this position
}

type Brush interface {
	// brushMarker is an unexported method that seals this interface.
	brushMarker()
}