package ui

import (
	"bytes"
	"embed"
	"image"
	"image/color"
	_ "image/png"

	"gioui.org/f32"
	"gioui.org/layout"
	"gioui.org/op"
	"gioui.org/op/clip"
	"gioui.org/op/paint"
	"gioui.org/text"
	"gioui.org/unit"
	"gioui.org/widget/material"
	"golang.org/x/image/math/fixed"
)

//go:embed icons/*.png
var iconFS embed.FS

// Renderer consumes a slice of elements and draws them.
type Renderer struct {
	theme Theme
	shp   *text.Shaper
	scale ScaleProvider
	icons map[string]image.Image
}

// ScaleProvider provides access to the current scale factor.
type ScaleProvider interface {
	Scale() float32
}

// New creates a new Renderer.
func New(th Theme, shp *text.Shaper, scale ScaleProvider) *Renderer {
	r := &Renderer{theme: th, shp: shp, scale: scale, icons: make(map[string]image.Image)}
	r.loadIcons()
	return r
}

// loadIcons loads PNG icons from the embedded filesystem.
func (r *Renderer) loadIcons() {
	data, err := iconFS.ReadFile("icons/cut.png")
	if err != nil {
		return
	}
	img, _, err := image.Decode(bytes.NewReader(data))
	if err != nil {
		return
	}
	r.icons["cut"] = img
}

// toPx converts Dp to physical pixels using State's scale.
func (r *Renderer) toPx(dp Dp) Px {
	return ToPx(dp, r.scale.Scale())
}

// toDp converts physical pixels to Dp using State's scale.
func (r *Renderer) toDp(px Px) Dp {
	return ToDp(px, r.scale.Scale())
}

// Draw iterates elements and draws each in slice order (back-to-front).
// It captures the initial constraints once at the start, then passes them
// to each render function for consistent positioning.
func (r *Renderer) Draw(gtx layout.Context, elems []Element) {
	// Capture initial constraints once — before any clips modify them.
	// These are in physical pixels and serve as the window bounds for all positioning.
	initialConstraints := WindowConstraints{
		Min: gtx.Constraints.Min,
		Max: gtx.Constraints.Max,
	}

	for _, e := range elems {
		if !e.Visible() {
			continue
		}
		switch v := e.(type) {
		case Label:
			r.drawLabel(gtx, v, initialConstraints)
		case ListView:
			r.drawListView(gtx, v, initialConstraints)
		case StatusBar:
			r.drawStatusBar(gtx, v, initialConstraints)
		case BottomBar:
			r.drawBottomBar(gtx, v, initialConstraints)
		case Button:
			r.drawButton(gtx, v, initialConstraints)
		default:
			// unknown element type, skip
		}
	}
}

func (r *Renderer) drawLabel(gtx layout.Context, l Label, _ WindowConstraints) {
	reg := l.Region()
	th := material.NewTheme()
	th.Shaper = r.shp
	size := l.FontSize
	if size == 0 {
		size = r.theme.FontSize
	}

	// Convert region to pixels for Gio interop
	gtx.Constraints.Min.X = int(r.toPx(reg.X))
	gtx.Constraints.Min.Y = int(r.toPx(reg.Y))
	material.Label(th, size, l.Text).Layout(gtx)
}

func (r *Renderer) drawListView(gtx layout.Context, lv ListView, _ WindowConstraints) {
	reg := lv.Region()
	th := material.NewTheme()
	th.Shaper = r.shp

	// Convert region to pixels for Gio interop
	gtx.Constraints.Min.X = int(r.toPx(reg.X))
	gtx.Constraints.Min.Y = int(r.toPx(reg.Y))
	for _, item := range lv.Items {
		material.Label(th, r.theme.FontSize, item.Text).Layout(gtx)
	}
}

func (r *Renderer) drawStatusBar(gtx layout.Context, sb StatusBar, _ WindowConstraints) {
	reg := sb.Region()

	// ── Draw background (outside clip) ──
	bgColor := color.NRGBA{R: 230, G: 230, B: 230, A: 255}
	bgClip := clip.Rect{
		Min: image.Point{X: int(r.toPx(reg.X)), Y: int(r.toPx(reg.Y))},
		Max: image.Point{X: int(r.toPx(reg.X + reg.W)), Y: int(r.toPx(reg.Y + reg.H))},
	}.Push(gtx.Ops)
	paint.ColorOp{Color: bgColor}.Add(gtx.Ops)
	paint.PaintOp{}.Add(gtx.Ops)
	bgClip.Pop()

	// ── Layout: shape all items ──
	marginDp := Dp(8)
	iconSpacingDp := Dp(12)
	lineHeight := r.theme.FontSize

	// Shape filename
	shapedFilename := r.ShapeText(gtx, sb.Filename, lineHeight)

	// Measure left icons (PNG, fixed size)
	var leftIconWidthPx int
	for range sb.IconLeft {
		leftIconWidthPx += int(r.toPx(Dp(16))) + int(r.toPx(iconSpacingDp))
	}

	// Measure right icons (text-based)
	var rightIconWidthPx int
	for _, name := range sb.IconRow {
		w := r.ShapeText(gtx, name, lineHeight).Width
		rightIconWidthPx += w + int(r.toPx(iconSpacingDp))
	}
	if sb.ConflictIcon {
		w := r.ShapeText(gtx, "⚠", lineHeight).Width
		rightIconWidthPx += w + int(r.toPx(iconSpacingDp))
	}

	// Available width for filename
	totalRightPx := leftIconWidthPx + rightIconWidthPx + int(r.toPx(marginDp)*2)
	availableWidthPx := int(r.toPx(reg.W)) - totalRightPx
	if availableWidthPx < 0 {
		availableWidthPx = 0
	}

	// Truncate filename if needed
	displayFilename := sb.Filename
	spaceForTextPx := availableWidthPx - int(r.toPx(Dp(30)))
	if shapedFilename.Width > availableWidthPx && spaceForTextPx > 0 {
		// Find truncation point
		r.shp.LayoutString(text.Parameters{
			PxPerEm:  fixed.I(gtx.Sp(lineHeight)),
			MinWidth: 0,
			MaxWidth: availableWidthPx,
			MaxLines: 1,
		}, sb.Filename)
		var widths []int
		var cumWidth fixed.Int26_6
		for {
			g, ok := r.shp.NextGlyph()
			if !ok {
				break
			}
			cumWidth += g.Advance
			widths = append(widths, int(cumWidth>>6))
		}
		for i := len(widths) - 1; i >= 0; i-- {
			if widths[i] <= spaceForTextPx {
				displayFilename = sb.Filename[:i] + "..."
				break
			}
		}
	}

	// ── Render ──

	// Clip to status bar region
	c := clip.Rect{
		Min: image.Point{X: int(r.toPx(reg.X)), Y: int(r.toPx(reg.Y))},
		Max: image.Point{X: int(r.toPx(reg.X + reg.W)), Y: int(r.toPx(reg.Y + reg.H))},
	}.Push(gtx.Ops)

	// Line 1: Left icons + filename
	filenameLineY := reg.Y + Dp(2)
	leftX := reg.X + marginDp

	// Draw left icons
	for _, name := range sb.IconLeft {
		if img, ok := r.icons[name]; ok {
			iconSize := Dp(16)
			r.drawPng(gtx, img, leftX, filenameLineY, iconSize, iconSize, color.NRGBA{R: 0, G: 0, B: 0, A: 255})
			leftX += Dp(16) + iconSpacingDp
		}
	}

	// Draw filename
	r.drawTruncatedText(gtx, r.shp, displayFilename, lineHeight, leftX, filenameLineY, availableWidthPx, spaceForTextPx, color.NRGBA{R: 0, G: 0, B: 0, A: 255})

	// Line 2: Icons
	iconsLineY := reg.Y + Dp(26)

	// Left side: Cut icon
	leftX = reg.X + Dp(8)
	r.drawPng(gtx, r.icons["cut"], leftX, iconsLineY, Dp(16), Dp(16), color.NRGBA{R: 0, G: 0, B: 0, A: 255})
	leftX += Dp(36)
	r.drawText(gtx, r.shp, "⎘", r.theme.FontSize, leftX, iconsLineY, color.NRGBA{R: 0, G: 0, B: 0, A: 255})
	leftX += Dp(36)
	r.drawText(gtx, r.shp, "⎘", r.theme.FontSize, leftX, iconsLineY, color.NRGBA{R: 0, G: 0, B: 0, A: 255})
	leftX += Dp(12)

	// Right side: Conflict (conditional), Search (always visible)
	rightX := reg.X + reg.W - Dp(8)
	if sb.ConflictIcon {
		rightX -= Dp(36)
		r.drawText(gtx, r.shp, "⚠", r.theme.FontSize, rightX, iconsLineY, color.NRGBA{R: 0, G: 0, B: 0, A: 255})
	}
	rightX -= Dp(36)
	r.drawText(gtx, r.shp, "🔍", r.theme.FontSize, rightX, iconsLineY, color.NRGBA{R: 0, G: 0, B: 0, A: 255})

	c.Pop()
}

func (r *Renderer) drawBottomBar(gtx layout.Context, bb BottomBar, constraints WindowConstraints) {
	reg := bb.Region()

	// Draw light gray background
	bgColor := color.NRGBA{R: 230, G: 230, B: 230, A: 255}
	bgClip := clip.Rect{
		Min: image.Point{X: int(r.toPx(reg.X)), Y: int(r.toPx(reg.Y))},
		Max: image.Point{X: int(r.toPx(reg.X + reg.W)), Y: int(r.toPx(reg.Y + reg.H))},
	}.Push(gtx.Ops)
	paint.ColorOp{Color: bgColor}.Add(gtx.Ops)
	paint.PaintOp{}.Add(gtx.Ops)
	bgClip.Pop()

	// Use captured constraints for positioning
	windowW := constraints.Max.X

	regXPx := r.toPx(reg.X)
	regWPx := r.toPx(reg.W)

	rightXPx := regXPx + regWPx
	if rightXPx > Px(windowW) {
		rightXPx = Px(windowW)
	}
	barW := rightXPx - regXPx

	bottomBarHeightPx := r.toPx(Dp(24))
	marginPx := r.toPx(Dp(10))
	drawYPx := Px(constraints.Max.Y) - bottomBarHeightPx - marginPx
	drawY := r.toDp(drawYPx)

	col := color.NRGBA{R: 0, G: 0, B: 0, A: 255}

	// Item 1: cursor position (left-aligned) — shape, position, draw
	cursorShaped := r.ShapeText(gtx, bb.CursorPos, r.theme.FontSize)
	cursorXDp := r.toDp(regXPx + r.toPx(Dp(8)))
	r.DrawShapedText(gtx, cursorShaped, cursorXDp, drawY, col)

	// Item 2: byte position (centered) — shape, position, draw
	bytePosShaped := r.ShapeText(gtx, bb.BytePos, r.theme.FontSize)
	byteXDp := r.toDp(regXPx + barW/2 - Px(bytePosShaped.Width/2))
	r.DrawShapedText(gtx, bytePosShaped, byteXDp, drawY, col)

	// Item 3: wrap (right-aligned) — shape, position, draw
	wrapText := "Wrap:" + boolToString(bb.WordWrap)
	wrapShaped := r.ShapeText(gtx, wrapText, r.theme.FontSize)
	wrapXDp := r.toDp(regXPx + barW - r.toPx(Dp(8)) - Px(wrapShaped.Width))
	r.DrawShapedText(gtx, wrapShaped, wrapXDp, drawY, col)
}

func (r *Renderer) drawButton(gtx layout.Context, btn Button, _ WindowConstraints) {
	reg := btn.Region()
	th := material.NewTheme()
	th.Shaper = r.shp

	gtx.Constraints.Min.X = int(r.toPx(reg.X))
	gtx.Constraints.Min.Y = int(r.toPx(reg.Y))
	material.Label(th, r.theme.FontSize, btn.Text).Layout(gtx)
}

func boolToString(b bool) string {
	if b {
		return "On"
	}
	return "Off"
}

// drawTruncatedText layouts text, measures widths, truncates if needed, and draws.
func (r *Renderer) drawTruncatedText(gtx layout.Context, shp *text.Shaper, str string, size unit.Sp, x, y Dp, availableWidth, spaceForText int, col color.NRGBA) {
	shp.LayoutString(text.Parameters{
		PxPerEm:  fixed.I(gtx.Sp(size)),
		MinWidth: 0,
		MaxWidth: availableWidth,
		MaxLines: 1,
	}, str)

	var widths []int
	var cumWidth fixed.Int26_6
	fullStr := str
	for {
		g, ok := shp.NextGlyph()
		if !ok {
			break
		}
		cumWidth += g.Advance
		w := int(cumWidth >> 6)
		widths = append(widths, w)
	}

	if len(widths) > 0 && widths[len(widths)-1] > availableWidth {
		for i := len(widths) - 1; i >= 0; i-- {
			if widths[i] <= spaceForText {
				fullStr = str[:i] + "..."
				break
			}
		}
	}

	shp.LayoutString(text.Parameters{
		PxPerEm:  fixed.I(gtx.Sp(size)),
		MinWidth: 0,
		MaxWidth: availableWidth,
		MaxLines: 1,
	}, fullStr)
	r.drawLineText(gtx, shp, x, y, col)
}

// drawText draws text using Gio's textView approach.
func (r *Renderer) drawText(gtx layout.Context, shp *text.Shaper, str string, size unit.Sp, x, y Dp, col color.NRGBA) {
	shp.LayoutString(text.Parameters{
		PxPerEm:  fixed.I(gtx.Sp(size)),
		MinWidth: 0,
		MaxWidth: 1000,
		MaxLines: 1,
	}, str)
	r.drawLineText(gtx, shp, x, y, col)
}

// drawLineText draws already-laid-out glyphs using shaper.Shape() and shaper.Bitmaps().
func (r *Renderer) drawLineText(gtx layout.Context, shp *text.Shaper, x, y Dp, col color.NRGBA) {
	xPx := r.toPx(x)
	yPx := r.toPx(y)

	m := op.Record(gtx.Ops)
	var glyphs [32]text.Glyph
	line := glyphs[:0]
	for g, ok := shp.NextGlyph(); ok; g, ok = shp.NextGlyph() {
		line = append(line, g)
		if g.Flags&text.FlagLineBreak != 0 || cap(line)-len(line) == 0 {
			r.drawLine(gtx, shp, line, xPx, yPx, col)
			line = line[:0]
		}
	}
	if len(line) > 0 {
		r.drawLine(gtx, shp, line, xPx, yPx, col)
	}
	call := m.Stop()
	call.Add(gtx.Ops)
}

// drawLine draws a line of glyphs using shaper.Shape() and shaper.Bitmaps().
func (r *Renderer) drawLine(gtx layout.Context, shp *text.Shaper, line []text.Glyph, x, y Px, col color.NRGBA) {
	if len(line) == 0 {
		return
	}
	first := line[0]
	offX := float32(x) + float32(first.X)/64.0
	offY := float32(y) + float32(first.Y)
	t := op.Affine(f32.Affine2D{}.Offset(f32.Pt(offX, offY))).Push(gtx.Ops)

	path := shp.Shape(line)
	outline := clip.Outline{Path: path}.Op().Push(gtx.Ops)
	paint.ColorOp{Color: col}.Add(gtx.Ops)
	paint.PaintOp{}.Add(gtx.Ops)
	outline.Pop()

	if call := shp.Bitmaps(line); call != (op.CallOp{}) {
		call.Add(gtx.Ops)
	}

	t.Pop()
}

// WindowConstraints tracks the initial window constraints captured at the start of Draw.
type WindowConstraints struct {
	Min image.Point
	Max image.Point
}

// drawPng draws a PNG image at the given position and size.
func (r *Renderer) drawPng(gtx layout.Context, img image.Image, x, y Dp, width, height Dp, col color.NRGBA) {
	if img == nil {
		return
	}

	xPx := int(r.toPx(x))
	yPx := int(r.toPx(y))
	wPx := int(r.toPx(width))
	hPx := int(r.toPx(height))

	dst := image.Rect(xPx, yPx, xPx+wPx, yPx+hPx)

	if col.A < 255 {
		bgClip := clip.Rect(dst).Push(gtx.Ops)
		paint.ColorOp{Color: col}.Add(gtx.Ops)
		paint.PaintOp{}.Add(gtx.Ops)
		bgClip.Pop()
	}

	stack := op.Offset(image.Pt(xPx, yPx)).Push(gtx.Ops)
	paint.NewImageOp(img).Add(gtx.Ops)
	paint.PaintOp{}.Add(gtx.Ops)
	stack.Pop()
}