// 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 "github.com/tdewolff/canvas"

// renderAnnotations 渲染页面注释外观
// 入参: ctx 画布上下文, pageID 页面ID, pageH 页面高度
func (r *Renderer) renderAnnotations(ctx *canvas.Context, pageID string, pageH float64) {
	for _, annot := range r.Reader.Annots[pageID] {
		if annot.Visible != nil && !*annot.Visible {
			continue
		}
		box, _ := ParseBox(annot.Appearance.Boundary)
		ctm := Matrix{a: 1, d: 1, e: box.X, f: box.Y}
		for i := range annot.Appearance.Objects {
			r.renderObject(ctx, &annot.Appearance.Objects[i], pageH, nil, &ctm, false, nil)
		}
	}
}

// renderTemplate 渲染模板
// 入参: ctx 画布上下文, templateID 模板ID, pageH 页面高度
func (r *Renderer) renderTemplate(ctx *canvas.Context, templateID string, pageH float64) {
	tplContent := r.loadTemplate(templateID)
	if tplContent == nil {
		return
	}
	for order := range 3 {
		r.renderLayers(ctx, tplContent.Content.Layer, pageH, order)
	}
}

// loadTemplate 加载模板页面并复用解析结果
// 入参: templateID 模板ID
// 返回: *PageContent 模板页面
func (r *Renderer) loadTemplate(templateID string) *PageContent {
	if page := r.templatePageCache[templateID]; page != nil {
		return page
	}
	for _, tpl := range r.Reader.doc.CommonData.TemplatePage {
		if tpl.ID != templateID {
			continue
		}
		page, err := r.Reader.PageContent(Page{BaseLoc: tpl.BaseLoc})
		if err != nil {
			return nil
		}
		r.templatePageCache[templateID] = page
		return page
	}
	return nil
}

// layerOrder 获取图层类型的绘制顺序
// 入参: kind 图层类型
// 返回: int 绘制顺序
func layerOrder(kind string) int {
	switch kind {
	case "Background":
		return 0
	case "Foreground":
		return 2
	}
	return 1
}

// renderLayers 按原顺序渲染指定类型的图层
// 入参: ctx 画布上下文, layers 图层列表, pageH 页面高度, order 图层类型顺序
func (r *Renderer) renderLayers(ctx *canvas.Context, layers []Layer, pageH float64, order int) {
	for _, layer := range layers {
		if layerOrder(layer.Type) == order {
			r.renderLayer(ctx, layer, pageH, nil, nil)
		}
	}
}

// renderLayer 渲染图层
// 入参: ctx 画布上下文, layer 图层对象, pageH 页面高度, defaults 默认绘制参数, parentCTM 父级CTM
func (r *Renderer) renderLayer(ctx *canvas.Context, layer Layer, pageH float64, defaults *DrawParam, parentCTM *Matrix) {
	defaults = r.drawParamDefaults(layer.DrawParam, defaults)
	if len(layer.Objects) > 0 {
		for i := range layer.Objects {
			r.renderObject(ctx, &layer.Objects[i], pageH, defaults, parentCTM, false, nil)
		}
		return
	}
	for _, textObj := range layer.TextObject {
		r.renderText(ctx, textObj, pageH, defaults, parentCTM, false, nil)
	}
	for _, pathObj := range layer.PathObject {
		r.renderPath(ctx, pathObj, pageH, defaults, parentCTM, false, nil)
	}
	for _, imgObj := range layer.ImageObject {
		r.renderImage(ctx, imgObj, pageH, parentCTM, false, nil)
	}
	for _, cgu := range layer.CompositeGraphicUnit {
		r.renderCompositeGraphicUnit(ctx, cgu, pageH, defaults, parentCTM, false, nil)
	}
}

// renderCompositeGraphicUnit 渲染复合图元
// 入参: ctx 画布上下文, cgu 复合图元对象, pageH 页面高度, defaults 默认绘制参数, parentCTM 父级CTM, boundaryInCTM 边界是否参与CTM变换, parentClip 父级裁剪路径
func (r *Renderer) renderCompositeGraphicUnit(ctx *canvas.Context, cgu CompositeGraphicUnit, pageH float64, defaults *DrawParam, parentCTM *Matrix, boundaryInCTM bool, parentClip *canvas.Path) {
	if cgu.Visible != nil && !*cgu.Visible {
		if groups, ok := ctx.Renderer.(interface{ skipObjects(int) }); ok {
			count, ref, seen := len(cgu.Objects), cgu.ResourceID, make(map[string]bool)
			for ref != "" && !seen[ref] {
				seen[ref] = true
				unit := r.CompositeGraphicUnits[ref]
				if unit == nil {
					break
				}
				count, ref = count+len(unit.Objects), unit.ResourceID
			}
			groups.skipObjects(count)
		}
		return
	}
	ctx.Push()
	box, _ := ParseBox(cgu.Boundary)
	boundaryCTM := TranslationMatrix(box.X, box.Y)
	if parentCTM != nil {
		boundaryCTM = parentCTM.Multiply(boundaryCTM)
	}
	currentCTM := boundaryCTM.Multiply(NewMatrix(cgu.CTM))
	clips, clipCTM := cgu.Clips, currentCTM
	if clips != nil && clips.TransFlag != nil && !*clips.TransFlag {
		clipCopy := *clips
		clipCopy.TransFlag = nil
		clips, clipCTM = &clipCopy, boundaryCTM
	}
	clipPath := intersectClipPath(parentClip, r.buildClipPath(clips, pageH, 0, 0, clipCTM))
	defaults = r.drawParamDefaults(cgu.DrawParam, defaults)
	if cgu.ResourceID != "" {
		if ref, ok := r.CompositeGraphicUnits[cgu.ResourceID]; ok {
			refCopy := *ref
			refCopy.Alpha = mergeAlpha(refCopy.Alpha, cgu.Alpha)
			r.renderCompositeGraphicUnit(ctx, refCopy, pageH, defaults, &currentCTM, true, clipPath)
		}
	}
	if len(cgu.Objects) > 0 {
		for _, obj := range cgu.Objects {
			obj = mergeGraphicObjectAlpha(obj, cgu.Alpha)
			r.renderObject(ctx, &obj, pageH, defaults, &currentCTM, boundaryInCTM, clipPath)
		}
		ctx.Pop()
		return
	}
	for _, imgObj := range cgu.ImageObject {
		imgObj.Alpha = mergeAlpha(imgObj.Alpha, cgu.Alpha)
		r.renderImage(ctx, imgObj, pageH, &currentCTM, boundaryInCTM, clipPath)
	}
	for _, pathObj := range cgu.PathObject {
		pathObj.Alpha = mergeAlpha(pathObj.Alpha, cgu.Alpha)
		r.renderPath(ctx, pathObj, pageH, defaults, &currentCTM, boundaryInCTM, clipPath)
	}
	for _, textObj := range cgu.TextObject {
		textObj.Alpha = mergeAlpha(textObj.Alpha, cgu.Alpha)
		r.renderText(ctx, textObj, pageH, defaults, &currentCTM, boundaryInCTM, clipPath)
	}
	for _, subCgu := range cgu.CompositeGraphicUnit {
		subCgu.Alpha = mergeAlpha(subCgu.Alpha, cgu.Alpha)
		r.renderCompositeGraphicUnit(ctx, subCgu, pageH, defaults, &currentCTM, boundaryInCTM, clipPath)
	}
	ctx.Pop()
}

// renderObject 渲染图形对象
// 入参: ctx 画布上下文, obj 图形对象, pageH 页面高度, defaults 默认绘制参数, parentCTM 父级CTM, boundaryInCTM 边界是否参与CTM变换, parentClip 父级裁剪路径
func (r *Renderer) renderObject(ctx *canvas.Context, obj *GraphicObject, pageH float64, defaults *DrawParam, parentCTM *Matrix, boundaryInCTM bool, parentClip *canvas.Path) {
	if groups, ok := ctx.Renderer.(interface {
		beginObject(*GraphicObject) bool
		endObject()
	}); ok && groups.beginObject(obj) {
		defer groups.endObject()
	}
	switch obj.Type {
	case "TextObject":
		r.renderText(ctx, obj.TextObject, pageH, defaults, parentCTM, boundaryInCTM, parentClip)
	case "PathObject":
		r.renderPath(ctx, obj.PathObject, pageH, defaults, parentCTM, boundaryInCTM, parentClip)
	case "ImageObject":
		r.renderImage(ctx, obj.ImageObject, pageH, parentCTM, boundaryInCTM, parentClip)
	case "CompositeGraphicUnit", "CompositeObject":
		r.renderCompositeGraphicUnit(ctx, obj.CompositeGraphicUnit, pageH, defaults, parentCTM, boundaryInCTM, parentClip)
	}
}

// mergeGraphicObjectAlpha 合并图形对象透明度
// 入参: obj 图形对象, alpha 父级透明度
// 返回: GraphicObject 合并后的图形对象
func mergeGraphicObjectAlpha(obj GraphicObject, alpha *int) GraphicObject {
	if alpha == nil {
		return obj
	}
	switch obj.Type {
	case "TextObject":
		obj.TextObject.Alpha = mergeAlpha(obj.TextObject.Alpha, alpha)
	case "PathObject":
		obj.PathObject.Alpha = mergeAlpha(obj.PathObject.Alpha, alpha)
	case "ImageObject":
		obj.ImageObject.Alpha = mergeAlpha(obj.ImageObject.Alpha, alpha)
	case "CompositeGraphicUnit", "CompositeObject":
		obj.CompositeGraphicUnit.Alpha = mergeAlpha(obj.CompositeGraphicUnit.Alpha, alpha)
	}
	return obj
}

// drawParamDefaults 合并绘制参数默认样式
// 入参: id 绘制参数ID, defaults 默认绘制参数
// 返回: *DrawParam 合并后的绘制参数
func (r *Renderer) drawParamDefaults(id string, defaults *DrawParam) *DrawParam {
	if id == "" {
		return defaults
	}
	dp := r.getDrawParam(id, nil)
	if dp == nil {
		return defaults
	}
	if defaults == nil {
		return dp
	}
	return mergeDrawParam(*defaults, dp)
}

// mergeDrawParam 合并绘制参数属性
// 入参: base 基础绘制参数, dp 覆盖绘制参数
// 返回: *DrawParam 合并后的绘制参数
func mergeDrawParam(base DrawParam, dp *DrawParam) *DrawParam {
	if dp.LineWidth > 0 {
		base.LineWidth = dp.LineWidth
	}
	if dp.Join != "" {
		base.Join = dp.Join
	}
	if dp.Cap != "" {
		base.Cap = dp.Cap
	}
	if dp.DashPattern != "" {
		base.DashPattern = dp.DashPattern
	}
	if dp.DashOffset != nil {
		base.DashOffset = dp.DashOffset
	}
	if dp.MiterLimit > 0 {
		base.MiterLimit = dp.MiterLimit
	}
	if dp.FillColor != nil {
		base.FillColor = dp.FillColor
	}
	if dp.StrokeColor != nil {
		base.StrokeColor = dp.StrokeColor
	}
	if dp.Font != "" {
		base.Font = dp.Font
	}
	if dp.Size > 0 {
		base.Size = dp.Size
	}
	if dp.Weight > 0 {
		base.Weight = dp.Weight
	}
	if dp.Italic {
		base.Italic = dp.Italic
	}
	return &base
}

// getDrawParam 获取绘制参数逻辑
// 入参: id 参数ID, visited 访问记录
// 返回: *DrawParam 绘制参数
func (r *Renderer) getDrawParam(id string, visited map[string]bool) *DrawParam {
	if visited == nil {
		visited = make(map[string]bool)
	}
	if visited[id] {
		return nil
	}
	visited[id] = true
	if dp, ok := r.DrawParams[id]; ok {
		if dp.Relative != "" {
			base := r.getDrawParam(dp.Relative, visited)
			if base == nil {
				return dp
			}
			return mergeDrawParam(*base, dp)
		}
		return dp
	}
	return nil
}