// Copyright 2025-2026 肖其顿 (XIAO QI DUN)
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package ofdgo

import (
	"fmt"
	"image/color"
	"math"
	"strconv"

	"github.com/tdewolff/canvas"
)

// shdPaint 渐变画刷
type shdPaint struct {
	gradient canvas.Gradient
	view     canvas.Matrix
	extend   int
	mapType  string
	period   float64
	sample   func(float64) color.RGBA
}

// repeatAxialGradient 轴向重复渐变
type repeatAxialGradient struct {
	*canvas.LinearGradient
	period float64
}

// At 获取重复区间内的渐变颜色
// 入参: x X坐标, y Y坐标
// 返回: color.RGBA 渐变颜色
func (g *repeatAxialGradient) At(x, y float64) color.RGBA {
	d := g.End.Sub(g.Start)
	t := (canvas.Point{X: x, Y: y}).Sub(g.Start).Dot(d) / d.Dot(d) / g.period
	return g.Grad.At(t - math.Floor(t))
}

// SetColorSpace 转换重复渐变颜色空间
// 入参: space 颜色空间
// 返回: canvas.Gradient 渐变对象
func (g *repeatAxialGradient) SetColorSpace(space canvas.ColorSpace) canvas.Gradient {
	return &repeatAxialGradient{LinearGradient: g.LinearGradient.SetColorSpace(space).(*canvas.LinearGradient), period: g.period}
}

// drawSampledShading 按输出精度采样后端不能原生表达的局部渐变，不改写OFD对象
// 入参: ctx 绘制上下文, path 已裁剪轮廓, view 渐变变换, gradient 渐变采样器
func (r *Renderer) drawSampledShading(ctx *canvas.Context, path *canvas.Path, view canvas.Matrix, gradient rasterGradientCanvas) {
	if path.Empty() {
		return
	}
	bounds := path.Bounds().And(shdCanvasBounds(ctx))
	if bounds.W() <= 0 || bounds.H() <= 0 {
		return
	}
	scale := r.DPI / 25.4
	w, h := math.Ceil(bounds.W()*scale), math.Ceil(bounds.H()*scale)
	page := &RasterPage{Width: w / scale, Height: h / scale, DPI: r.DPI}
	if _, _, err := page.PixelSize(); err != nil {
		r.renderError = err
		return
	}
	compiler := &canvasPageCompiler{page: page, geometry: r.backends.Geometry}
	style := ctx.Style
	style.Fill = canvas.Paint{Gradient: gradient}
	compiler.RenderPath(path.Copy().Transform(view.Inv()), style, canvas.Identity.Translate(-bounds.X0, -bounds.Y0).Mul(view))
	if compiler.err != nil {
		r.renderError = compiler.err
		return
	}
	if r.backends.Raster == nil {
		r.renderError = fmt.Errorf("shading raster: %w", ErrBackendUnavailable)
		return
	}
	img, err := r.backends.Raster.Render(page)
	if err != nil {
		r.renderError = err
		return
	}
	ctx.DrawImage(bounds.X0, bounds.Y0, img, canvas.DPMM(scale))
}

// newShdPaint 创建渐变画刷
// 入参: gradient 渐变对象, extend 延伸方向, mapType 绘制方式, mapUnit 渐变区间长度
// 返回: *shdPaint 渐变画刷
func newShdPaint(gradient canvas.Gradient, extend, mapType string, mapUnit float64) *shdPaint {
	flags, _ := strconv.Atoi(extend)
	length := 0.0
	switch g := gradient.(type) {
	case *canvas.LinearGradient:
		length = g.End.Sub(g.Start).Length()
	case *canvas.RadialGradient:
		length = g.C1.Sub(g.C0).Length()
	}
	period := 1.0
	if mapUnit > 0 && length > 0 {
		period = mapUnit / length
	}
	return &shdPaint{gradient: gradient, view: canvas.Identity, extend: flags, mapType: mapType, period: period}
}

// resolveShdPaint 解析渐变画刷和裁剪区域
// 入参: ctx 画布上下文, paint 画刷
// 返回: any 画刷, *canvas.Path 裁剪区域, canvas.Matrix 渐变变换
func resolveShdPaint(ctx *canvas.Context, paint any) (any, *canvas.Path, canvas.Matrix) {
	s, ok := paint.(*shdPaint)
	if !ok {
		return paint, nil, canvas.Identity
	}
	if canvas.Equal(s.view.Det(), 0) {
		return nil, &canvas.Path{}, canvas.Identity
	}
	switch g := s.gradient.(type) {
	case rasterGradientCanvas:
		if g.gradient.Mesh != nil && g.gradient.Mesh.Background.A == 0 {
			outline := g.gradient.Mesh.outline()
			clip, _ := canvasObjectPath(outline)
			return g, clip.Settle(canvas.NonZero).Transform(s.view), s.view
		}
		return g, nil, s.view
	case *canvas.LinearGradient:
		bounds := shdCanvasBounds(ctx).Transform(s.view.Inv())
		clip := axialShdClip(g, s.extend, bounds)
		if clip != nil && s.view != canvas.Identity {
			clip = clip.Transform(s.view)
		}
		if s.sample != nil {
			return s.sampledRaster(), clip, s.view
		}
		if s.mapType == "Repeat" {
			return &repeatAxialGradient{LinearGradient: g, period: s.period}, clip, s.view
		}
		if s.mapType != "Reflect" {
			return g, clip, s.view
		}
		d := g.End.Sub(g.Start)
		axis := canvas.Matrix{{d.X, -d.Y, g.Start.X}, {d.Y, d.X, g.Start.Y}}
		area := bounds.Transform(axis.Inv())
		lo, hi := s.rangeLimits(area.X0, area.X1)
		if hi <= lo {
			return g, &canvas.Path{}, s.view
		}
		gradient := reflectShdGrad(g.Grad, s.period, lo, hi)
		return gradient.ToLinear(g.Start.Add(d.Mul(lo)), g.Start.Add(d.Mul(hi))), clip, s.view
	case *canvas.RadialGradient:
		d, dr := g.C1.Sub(g.C0), g.R1-g.R0
		length := d.Length()
		if length >= math.Abs(dr) || s.mapType == "Repeat" {
			return s.sampledRaster(), nil, s.view
		}
		bounds := shdCanvasBounds(ctx).Transform(s.view.Inv())
		clip := radialShdClip(g, s.extend, bounds)
		if clip != nil && s.view != canvas.Identity {
			clip = clip.Transform(s.view)
		}
		if s.sample != nil {
			return s.sampledRaster(), clip, s.view
		}
		if s.mapType != "Reflect" {
			return g, clip, s.view
		}
		lo, hi := 0.0, 1.0
		if s.extend != 0 {
			distance := 0.0
			for _, point := range []canvas.Point{{X: bounds.X0, Y: bounds.Y0}, {X: bounds.X1, Y: bounds.Y0}, {X: bounds.X1, Y: bounds.Y1}, {X: bounds.X0, Y: bounds.Y1}} {
				distance = math.Max(distance, point.Sub(g.C0).Length())
			}
			limit := (distance + g.R0) / (math.Abs(dr) - length)
			lo, hi = s.rangeLimits(-limit, limit)
		}
		if dr > 0 {
			lo = math.Max(lo, -g.R0/dr)
		} else {
			hi = math.Min(hi, -g.R0/dr)
		}
		if hi <= lo {
			return g, &canvas.Path{}, s.view
		}
		gradient := reflectShdGrad(g.Grad, s.period, lo, hi)
		return gradient.ToRadial(g.C0.Add(d.Mul(lo)), math.Max(0, g.R0+dr*lo), g.C0.Add(d.Mul(hi)), math.Max(0, g.R0+dr*hi)), clip, s.view
	}
	return s.gradient, nil, s.view
}

// sampledRaster 保留原双圆或轴向几何与周期，不把ICC采样器降为端点渐变
// 返回: rasterGradientCanvas 局部坐标采样器
func (s *shdPaint) sampledRaster() rasterGradientCanvas {
	gradient := &RasterGradient{Sample: s.sample, Spread: &RasterSpread{Extend: s.extend, MapType: s.mapType, Period: s.period}}
	var stops canvas.Grad
	switch g := s.gradient.(type) {
	case *canvas.LinearGradient:
		gradient.Start, gradient.End, stops = rasterPoint(g.Start), rasterPoint(g.End), g.Grad
	case *canvas.RadialGradient:
		gradient.Kind = RasterRadial
		gradient.Start, gradient.End, gradient.R0, gradient.R1, stops = rasterPoint(g.C0), rasterPoint(g.C1), g.R0, g.R1, g.Grad
	}
	gradient.Stops = make([]ColorStop, len(stops))
	for i, stop := range stops {
		gradient.Stops[i] = ColorStop{Offset: stop.Offset, Color: stop.Color}
	}
	return rasterGradientCanvas{gradient: gradient}
}

// transformShdPaint 应用渐变的父级坐标变换
// 入参: paint 画刷, parentCTM 父级变换矩阵, bx 边界X坐标, by 边界Y坐标, pageH 页面高度, boundaryInCTM 边界是否参与父级变换
func transformShdPaint(paint any, parentCTM *Matrix, bx, by, pageH float64, boundaryInCTM bool) {
	s, ok := paint.(*shdPaint)
	if !ok || parentCTM == nil {
		return
	}
	ctm := *parentCTM
	if !boundaryInCTM {
		ctm = TranslationMatrix(bx, by).Multiply(ctm).Multiply(TranslationMatrix(-bx, -by))
	}
	s.view = canvas.Matrix{
		{ctm.a, -ctm.c, ctm.c*pageH + ctm.e},
		{-ctm.b, ctm.d, pageH*(1-ctm.d) - ctm.f},
	}.Mul(s.view)
}

// drawShdPath 绘制渐变路径并保持图形轮廓不变
// 入参: ctx 画布上下文, path 填充路径, view 渐变变换
func (r *Renderer) drawShdPath(ctx *canvas.Context, path *canvas.Path, view canvas.Matrix) {
	if gradient, ok := ctx.Style.Fill.Gradient.(rasterGradientCanvas); ok {
		if _, compiling := ctx.Renderer.(*canvasPageCompiler); !compiling {
			if _, measuring := ctx.Renderer.(*boundsRenderer); !measuring {
				r.drawSampledShading(ctx, path, view, gradient)
				return
			}
		}
	}
	if gradient, ok := ctx.Style.Fill.Gradient.(*repeatAxialGradient); ok {
		drawRepeatAxialPath(ctx, path, gradient, view)
		return
	}
	if view == canvas.Identity {
		ctx.DrawPath(0, 0, path)
		return
	}
	origin := ctx.CoordView().Dot(canvas.Point{})
	m := ctx.CoordSystemView().Mul(ctx.View()).Translate(origin.X, origin.Y).Mul(view)
	ctx.RenderPath(path.Copy().Transform(view.Inv()), ctx.Style, m)
}

// drawRepeatAxialPath 按周期裁剪并绘制轴向重复渐变
// 入参: ctx 画布上下文, path 填充路径, gradient 重复渐变, view 渐变变换
func drawRepeatAxialPath(ctx *canvas.Context, path *canvas.Path, gradient *repeatAxialGradient, view canvas.Matrix) {
	p := path.Copy()
	if ctx.FillRule == canvas.EvenOdd {
		p = p.Settle(canvas.EvenOdd)
	}
	p = p.Transform(view.Inv())
	d := gradient.End.Sub(gradient.Start).Mul(gradient.period)
	axis := canvas.Matrix{{d.X, -d.Y, gradient.Start.X}, {d.Y, d.X, gradient.Start.Y}}
	bounds := p.Bounds().And(shdCanvasBounds(ctx).Transform(view.Inv()))
	area := bounds.Transform(axis.Inv())
	origin := ctx.CoordView().Dot(canvas.Point{})
	m := ctx.CoordSystemView().Mul(ctx.View()).Translate(origin.X, origin.Y).Mul(view)
	style := ctx.Style
	style.FillRule = canvas.NonZero
	stops := gradient.Grad
	if stops[0].Offset > 0 {
		stops = append(canvas.Grad{{Offset: 0, Color: stops[0].Color}}, stops...)
	}
	if last := stops[len(stops)-1]; last.Offset < 1 {
		stops = append(append(canvas.Grad(nil), stops...), canvas.Stop{Offset: 1, Color: last.Color})
	}
	for i, end := math.Floor(area.X0), math.Ceil(area.X1); i < end; i++ {
		clip := (canvas.Rect{X0: i, Y0: area.Y0, X1: i + 1, Y1: area.Y1}).ToPath().Transform(axis)
		part := applyClipPath(p, clip)
		if part.Empty() {
			continue
		}
		start := gradient.Start.Add(d.Mul(i))
		style.Fill = canvas.Paint{Gradient: stops.ToLinear(start, start.Add(d))}
		ctx.RenderPath(part, style, m)
	}
}

// rangeLimits 限制渐变延伸区间
// 入参: lo 区间起点, hi 区间终点
// 返回: float64 起点, float64 终点
func (s *shdPaint) rangeLimits(lo, hi float64) (float64, float64) {
	if s.extend&1 == 0 {
		lo = math.Max(lo, 0)
	}
	if s.extend&2 == 0 {
		hi = math.Min(hi, 1)
	}
	return lo, hi
}

// shdCanvasBounds 获取渐变坐标系下的画布边界
// 入参: ctx 画布上下文
// 返回: canvas.Rect 画布边界
func shdCanvasBounds(ctx *canvas.Context) canvas.Rect {
	origin := ctx.CoordView().Dot(canvas.Point{})
	view := ctx.CoordSystemView().Mul(ctx.View()).Translate(origin.X, origin.Y)
	if view.Det() == 0 {
		return canvas.Rect{}
	}
	width, height := ctx.Size()
	return (canvas.Rect{X1: width, Y1: height}).Transform(view.Inv())
}

// radialShdClip 获取包含双圆的径向渐变裁剪区域
// 入参: g 径向渐变, extend 延伸方向, bounds 渐变坐标系下的画布边界
// 返回: *canvas.Path 裁剪区域
func radialShdClip(g *canvas.RadialGradient, extend int, bounds canvas.Rect) *canvas.Path {
	inner, outer := g.C0, g.C1
	r0, r1 := g.R0, g.R1
	if r1 < r0 {
		inner, outer, r0, r1 = outer, inner, r1, r0
		extend = (extend&1)<<1 | (extend&2)>>1
	}
	if extend == 3 {
		return nil
	}
	var clip *canvas.Path
	if extend&2 == 0 {
		clip = canvas.Circle(r1).Translate(outer.X, outer.Y)
	} else {
		clip = bounds.ToPath()
	}
	if extend&1 == 0 && r0 > 0 {
		clip = clip.Not(canvas.Circle(r0).Translate(inner.X, inner.Y))
	}
	return clip
}

// reflectShdGrad 构造镜像渐变颜色分段
// 入参: gradient 颜色分段, period 周期长度, lo 起点, hi 终点
// 返回: canvas.Grad 镜像颜色分段
func reflectShdGrad(gradient canvas.Grad, period, lo, hi float64) canvas.Grad {
	base := append(canvas.Grad{{Offset: 0, Color: gradient.At(0)}}, gradient...)
	base = append(base, canvas.Stop{Offset: 1, Color: gradient.At(1)})
	reversed := make(canvas.Grad, len(base))
	for i, stop := range base {
		reversed[len(base)-1-i] = canvas.Stop{Offset: 1 - stop.Offset, Color: stop.Color}
	}
	result := canvas.Grad{{Offset: 0, Color: gradient.At(reflectShdPosition(lo / period))}}
	for i, last := math.Floor(lo/period), math.Ceil(hi/period); i < last; i++ {
		stops := base
		if math.Mod(i, 2) != 0 {
			stops = reversed
		}
		for _, stop := range stops {
			position := (i + stop.Offset) * period
			offset := (position - lo) / (hi - lo)
			if lo < position && position < hi && result[len(result)-1].Offset < offset {
				result = append(result, canvas.Stop{Offset: offset, Color: stop.Color})
			}
		}
	}
	return append(result, canvas.Stop{Offset: 1, Color: gradient.At(reflectShdPosition(hi / period))})
}

// parseFillPaint 将公共画刷转换为Canvas对象
// 入参: fillColor 填充颜色节点, x X坐标, y Y坐标, pageH 页面高度
// 返回: any 填充画刷
func (r *Renderer) parseFillPaint(fillColor *FillColor, x, y, pageH float64) any {
	paint, err := r.ResolvePaint(fillColor)
	if err != nil {
		r.renderError = err
		return nil
	}
	switch paint.Kind {
	case PaintNone, PaintPattern:
		return nil
	case PaintLinear, PaintRadial:
		return canvasShading(paint, x, y, pageH)
	case PaintMesh:
		return &shdPaint{gradient: newRasterGradientCanvas(&RasterGradient{Kind: RasterMesh, Mesh: paint.Mesh}), view: canvas.Matrix{{1, 0, x}, {0, -1, pageH - y}}}
	default:
		return paint.Color
	}
}

// parseStrokePaint 解析勾边画刷
// 入参: strokeColor 勾边颜色节点, x X坐标, y Y坐标, pageH 页面高度
// 返回: any 勾边画刷
func (r *Renderer) parseStrokePaint(strokeColor *StrokeColor, x, y, pageH float64) any {
	return r.parseFillPaint((*FillColor)(strokeColor), x, y, pageH)
}

// canvasGradient 将公共颜色节点转换为Canvas渐变
// 入参: stops 渐变色标
// 返回: canvas.Grad 渐变色标
func canvasGradient(stops []ColorStop) canvas.Grad {
	var gradient canvas.Grad
	for _, stop := range stops {
		gradient.Add(stop.Offset, stop.Color)
	}
	return gradient
}

// canvasShading 转换坐标与椭圆渐变变换，不重新解析OFD样式
// 入参: paint 公共渐变画刷, x X坐标, y Y坐标, pageH 页面高度
// 返回: *shdPaint Canvas渐变画刷
func canvasShading(paint Paint, x, y, pageH float64) *shdPaint {
	source := paint.Gradient
	gradient := canvasGradient(source.Stops)
	start := canvas.Point{X: x + source.Start.X, Y: pageH - y - source.Start.Y}
	end := canvas.Point{X: x + source.End.X, Y: pageH - y - source.End.Y}
	if paint.Kind == PaintLinear {
		result := newShdPaint(gradient.ToLinear(start, end), source.Extend, source.MapType, source.MapUnit)
		result.sample = source.Sample
		return result
	}
	result := newShdPaint(gradient.ToRadial(start, source.StartRadius, end, source.EndRadius), source.Extend, source.MapType, source.MapUnit)
	result.sample = source.Sample
	if e := source.Eccentricity; 0 < e && e < 1 {
		result.view = canvas.Identity.Translate(start.X, start.Y).Rotate(-source.Angle).Scale(1, math.Sqrt(1-e*e)).Translate(-start.X, -start.Y)
		result.gradient = gradient.ToRadial(start, source.StartRadius, result.view.Inv().Dot(end), source.EndRadius)
	}
	return result
}

// axialShdClip 获取轴向渐变的延伸裁剪区域
// 入参: gradient 轴向渐变, extend 延伸方向, bounds 可见区域
// 返回: *canvas.Path 裁剪区域
func axialShdClip(gradient *canvas.LinearGradient, extend int, bounds canvas.Rect) *canvas.Path {
	if extend == 3 {
		return nil
	}
	d := gradient.End.Sub(gradient.Start)
	axis := canvas.Matrix{{d.X, -d.Y, gradient.Start.X}, {d.Y, d.X, gradient.Start.Y}}
	area := bounds.Transform(axis.Inv())
	if extend&1 == 0 {
		area.X0 = math.Max(area.X0, 0)
	}
	if extend&2 == 0 {
		area.X1 = math.Min(area.X1, 1)
	}
	if area.X1 <= area.X0 {
		return &canvas.Path{}
	}
	return area.ToPath().Transform(axis)
}