// SPDX-License-Identifier: Unlicense OR MIT

// Command svg2gio converts SVG files to Gio functions. Only a limited subset of
// SVG files are supported.
package main

import (
	"bytes"
	"encoding/xml"
	"errors"
	"flag"
	"fmt"
	"go/format"
	"io"
	"os"
	"path/filepath"
	"strconv"
	"strings"
	"unicode"

	"gioui.org/f32"
)

var (
	pkg    = flag.String("pkg", "", "Go package")
	output = flag.String("o", "svg.go", "Output Go file")
)

func main() {
	flag.Parse()
	if *pkg == "" {
		fmt.Fprintf(os.Stderr, "specify a package name (-pkg)\n")
		os.Exit(1)
	}
	args := flag.Args()
	if err := convertAll(args); err != nil {
		fmt.Fprintf(os.Stderr, "%v\n", err)
		os.Exit(2)
	}
}

type Points []float32

func (p *Points) UnmarshalText(text []byte) error {
	for {
		text = bytes.TrimLeft(text, "\t\n")
		if len(text) == 0 {
			break
		}
		var num []byte
		end := bytes.IndexAny(text, " ,")
		if end != -1 {
			num = text[:end]
			text = text[end+1:]
		} else {
			num = text
			text = nil
		}
		f, err := strconv.ParseFloat(string(num), 32)
		if err != nil {
			return err
		}
		*p = append(*p, float32(f))
	}
	return nil
}

type Transform f32.Affine2D

func (t *Transform) UnmarshalText(text []byte) error {
	switch {
	case bytes.HasPrefix(text, []byte("matrix(")) && bytes.HasSuffix(text, []byte(")")):
		trans := text[7 : len(text)-1]
		var p Points
		if err := p.UnmarshalText(trans); err != nil {
			return err
		}
		if len(p) != 6 {
			return fmt.Errorf("malformed transform matrix: %q", text)
		}
		*t = Transform(f32.NewAffine2D(p[0], p[2], p[4], p[1], p[3], p[5]))
		return nil
	default:
		return fmt.Errorf("unsupported transform: %q", text)
	}
}

type Fill struct {
	Transform      Transform `xml:"transform,attr"`
	Fill           Color     `xml:"fill,attr"`
	Stroke         Color     `xml:"stroke,attr"`
	StrokeLinejoin string    `xml:"stroke-linejoin,attr"`
	StrokeLinecap  string    `xml:"stroke-linecap,attr"`
	StrokeWidth    float32   `xml:"stroke-width,attr"`
}

type Color struct {
	Set   bool
	Value int
}

func (c *Color) UnmarshalText(text []byte) error {
	if string(text) == "none" {
		*c = Color{}
		return nil
	}
	if !bytes.HasPrefix(text, []byte("#")) {
		return fmt.Errorf("invalid color: %q", text)
	}
	text = text[1:]
	i, err := strconv.ParseInt(string(text), 16, 32)
	// Implied alpha.
	if len(text) == 6 {
		i |= 0xff000000
	}
	*c = Color{
		Set:   true,
		Value: int(i),
	}
	return err
}

func convertAll(files []string) error {
	w := new(bytes.Buffer)
	fmt.Fprintf(w, "// Code generated by gioui.org/cmd/svg2gio; DO NOT EDIT.\n\n")
	fmt.Fprintf(w, "package %s\n\n", *pkg)
	fmt.Fprintf(w, "import \"image/color\"\n")
	fmt.Fprintf(w, "import \"math\"\n")
	fmt.Fprintf(w, "import \"gioui.org/op\"\n")
	fmt.Fprintf(w, "import \"gioui.org/op/clip\"\n")
	fmt.Fprintf(w, "import \"gioui.org/op/paint\"\n")
	fmt.Fprintf(w, "import \"gioui.org/f32\"\n\n")
	fmt.Fprintf(w, "var ops op.Ops\n\n")
	fmt.Fprintf(w, funcs)
	for _, filename := range files {
		if err := convert(w, filename); err != nil {
			return err
		}
	}
	src, err := format.Source(w.Bytes())
	if err != nil {
		return err
	}
	return os.WriteFile(*output, src, 0o660)
}

func convert(w io.Writer, filename string) error {
	base := filepath.Base(filename)
	ext := filepath.Ext(base)
	name := "Image_" + base[:len(base)-len(ext)]

	fmt.Fprintf(w, "var %s struct {\n", name)
	fmt.Fprintf(w, "ViewBox struct { Min, Max f32.Point }\n")
	fmt.Fprintf(w, "Call op.CallOp\n\n")
	fmt.Fprintf(w, "}\n")
	fmt.Fprintf(w, "func init() {\n")
	defer fmt.Fprintf(w, "}\n")
	f, err := os.Open(filename)
	if err != nil {
		return err
	}
	defer f.Close()
	d := xml.NewDecoder(f)
	if err := parse(w, d, name); err != nil {
		line, col := d.InputPos()
		return fmt.Errorf("%s:%d:%d: %w", filename, line, col, err)
	}
	return nil
}

func parse(w io.Writer, d *xml.Decoder, name string) error {
	for {
		tok, err := d.Token()
		if err != nil {
			if err == io.EOF {
				return errors.New("unexpected end of file")
			}
			return err
		}
		switch tok := tok.(type) {
		case xml.StartElement:
			if n := tok.Name.Local; n != "svg" {
				return fmt.Errorf("invalid SVG root: <%s>", n)
			}
			if n := tok.Name.Space; n != "http://www.w3.org/2000/svg" {
				return fmt.Errorf("unsupported SVG namespace: %s", n)
			}
			fmt.Fprintf(w, "m := op.Record(&ops)\n")
			defer fmt.Fprintf(w, "%s.Call = m.Stop()\n", name)
			for _, a := range tok.Attr {
				if a.Name.Local == "viewBox" {
					var p Points
					if err := p.UnmarshalText([]byte(a.Value)); err != nil {
						return fmt.Errorf("invalid viewBox attribute: %s", a.Value)
					}
					if len(p) != 4 {
						return fmt.Errorf("invalid viewBox attribute: %s", a.Value)
					}
					fmt.Fprintf(w, "%s.ViewBox.Min = %s\n", name, point(f32.Pt(p[0], p[1])))
					fmt.Fprintf(w, "%s.ViewBox.Max = %s\n", name, point(f32.Pt(p[2], p[3])))
				}
			}
			return parseSVG(w, d)
		}
	}
}

func point(p f32.Point) string {
	return fmt.Sprintf("f32.Pt(%g, %g)", p.X, p.Y)
}

type Poly struct {
	XMLName xml.Name
	Points  Points `xml:"points,attr"`
	Fill
}

func (p *Poly) Path(w io.Writer) error {
	if len(p.Points) <= 1 {
		return nil
	}
	pen := f32.Pt(p.Points[0], p.Points[1])
	fmt.Fprintf(w, "p.MoveTo(%s)\n", point(pen))
	last := pen
	for i := 2; i < len(p.Points); i += 2 {
		last = f32.Pt(p.Points[i], p.Points[i+1])
		fmt.Fprintf(w, "p.LineTo(%s)\n", point(last))
	}
	if p.XMLName.Local == "polygon" && last != pen {
		fmt.Fprintf(w, "p.LineTo(%s)\n", point(pen))
	}
	return nil
}

type Path struct {
	D string `xml:"d,attr"`
	Fill
}

func (p *Path) Path(w io.Writer) error {
	return printPathCommands(w, p.D)
}

type Line struct {
	X1 float32 `xml:"x1,attr"`
	Y1 float32 `xml:"y1,attr"`
	X2 float32 `xml:"x2,attr"`
	Y2 float32 `xml:"y2,attr"`
	Fill
}

func (l *Line) Path(w io.Writer) error {
	fmt.Fprintf(w, "p.MoveTo(%s)\n", point(f32.Pt(l.X1, l.Y1)))
	fmt.Fprintf(w, "p.LineTo(%s)\n", point(f32.Pt(l.X2, l.Y2)))
	return nil
}

type Ellipse struct {
	Cx float32 `xml:"cx,attr"`
	Cy float32 `xml:"cy,attr"`
	Rx float32 `xml:"rx,attr"`
	Ry float32 `xml:"ry,attr"`
	Fill
}

func (e *Ellipse) Path(w io.Writer) error {
	c := f32.Pt(e.Cx, e.Cy)
	r := f32.Pt(e.Rx, e.Ry)
	fmt.Fprintf(w, "ellipse(&p, %s, %s)\n", point(c), point(r))
	return nil
}

type Rect struct {
	X      float32 `xml:"x,attr"`
	Y      float32 `xml:"y,attr"`
	Width  float32 `xml:"width,attr"`
	Height float32 `xml:"height,attr"`
	Fill
}

func (r *Rect) Path(w io.Writer) error {
	o := f32.Pt(r.X, r.Y)
	sz := f32.Pt(r.Width, r.Height)
	fmt.Fprintf(w, "rect(&p, %s, %s)\n", point(o), point(sz))
	return nil
}

type Circle struct {
	Cx float32 `xml:"cx,attr"`
	Cy float32 `xml:"cy,attr"`
	R  float32 `xml:"r,attr"`
	Fill
}

func (c *Circle) Path(w io.Writer) error {
	center := f32.Pt(c.Cx, c.Cy)
	r := f32.Pt(c.R, c.R)
	fmt.Fprintf(w, "ellipse(&p, %s, %s)\n", point(center), point(r))
	return nil
}

func parseSVG(w io.Writer, d *xml.Decoder) error {
	for {
		tok, err := d.Token()
		if err != nil {
			if err == io.EOF {
				return errors.New("unexpected end of <svg> element")
			}
			return err
		}
		var start xml.StartElement
		switch tok := tok.(type) {
		case xml.EndElement:
			return nil
		case xml.StartElement:
			start = tok
		default:
			continue
		}
		var elem interface {
			Path(w io.Writer) error
		}
		var fill *Fill
		switch n := start.Name.Local; n {
		case "g":
			// Flatten groups.
			if err := parseSVG(w, d); err != nil {
				return err
			}
			continue
		case "title":
			d.Skip()
			continue
		case "polygon", "polyline":
			p := new(Poly)
			elem = p
			fill = &p.Fill
		case "path":
			p := new(Path)
			elem = p
			fill = &p.Fill
		case "line":
			l := new(Line)
			elem = l
			fill = &l.Fill
		case "ellipse":
			e := new(Ellipse)
			elem = e
			fill = &e.Fill
		case "rect":
			r := new(Rect)
			elem = r
			fill = &r.Fill
		case "circle":
			c := new(Circle)
			elem = c
			fill = &c.Fill
		default:
			return fmt.Errorf("unsupported tag: <%s>", n)
		}
		if err := d.DecodeElement(elem, &start); err != nil {
			return err
		}
		if !fill.Fill.Set && !fill.Stroke.Set {
			continue
		}
		fmt.Fprintf(w, "{\n")
		trans := f32.Affine2D(fill.Transform)
		if trans != (f32.Affine2D{}) {
			sx, hx, ox, sy, hy, oy := trans.Elems()
			fmt.Fprintf(w, "t := op.Affine(f32.NewAffine2D(%g, %g, %g, %g, %g, %g)).Push(&ops)\n", sx, hx, ox, sy, hy, oy)
		}
		fmt.Fprintf(w, "var p clip.Path\n")
		fmt.Fprintf(w, "p.Begin(&ops)\n")
		if err := elem.Path(w); err != nil {
			return err
		}
		fmt.Fprintf(w, "spec := p.End()\n")
		if fill.Fill.Set {
			fmt.Fprintf(w, "paint.FillShape(&ops, argb(%#.8x), clip.Outline{Path: spec}.Op())\n", fill.Fill.Value)
		}
		if fill.Stroke.Set {
			fmt.Fprintf(w, "paint.FillShape(&ops, argb(%#.8x), clip.Stroke{Width: %g, Path: spec}.Op())\n", fill.Stroke.Value, fill.StrokeWidth)
		}
		if trans != (f32.Affine2D{}) {
			fmt.Fprintf(w, "t.Pop()\n")
		}
		fmt.Fprintf(w, "}\n")
	}
}

func printPathCommands(w io.Writer, cmds string) error {
	moveTo := func(p f32.Point) {
		fmt.Fprintf(w, "p.MoveTo(%s)\n", point(p))
	}
	lineTo := func(p f32.Point) {
		fmt.Fprintf(w, "p.LineTo(%s)\n", point(p))
	}
	cubeTo := func(p0, p1, p2 f32.Point) {
		fmt.Fprintf(w, "p.CubeTo(%s, %s, %s)\n", point(p0), point(p1), point(p2))
	}
	cmds = strings.TrimSpace(cmds)
	var pen f32.Point
	initPoint := pen
	ctrl2 := pen
	for {
		cmds = strings.TrimLeft(cmds, " ,\t\n")
		if len(cmds) == 0 {
			break
		}
		orig := cmds
		op := rune(cmds[0])
		cmds = cmds[1:]
		switch op {
		case 'M', 'm', 'V', 'v', 'L', 'l', 'H', 'h', 'C', 'c', 'S', 's':
		case 'Z', 'z':
			if pen != initPoint {
				lineTo(initPoint)
				pen = initPoint
			}
			ctrl2 = initPoint
			continue
		default:
			return fmt.Errorf("unknown <path> command %s in %q", string(op), orig)
		}
		var coords []float64
		for {
			cmds = strings.TrimLeft(cmds, " ,\t\n")
			if len(cmds) == 0 {
				break
			}
			n, x, ok := parseFloat(cmds)
			if !ok {
				break
			}
			cmds = cmds[n:]
			coords = append(coords, x)
		}
		rel := unicode.IsLower(op)
		newPen := pen
		switch unicode.ToLower(op) {
		case 'h':
			for _, x := range coords {
				p := f32.Pt(float32(x), pen.Y)
				if rel {
					p.X += pen.X
				}
				lineTo(p)
				newPen = p
			}
			pen = newPen
			ctrl2 = newPen
			continue
		case 'v':
			for _, y := range coords {
				p := f32.Pt(pen.X, float32(y))
				if rel {
					p.Y += pen.Y
				}
				lineTo(p)
				newPen = p
			}
			pen = newPen
			ctrl2 = newPen
			continue
		}
		if len(coords)%2 != 0 {
			return fmt.Errorf("odd number of coordinates in <path> data: %q", orig)
		}
		var off f32.Point
		if rel {
			// Relative command.
			off = pen
		} else {
			off = f32.Pt(0, 0)
		}
		var points []f32.Point
		for i := 0; i < len(coords); i += 2 {
			p := f32.Pt(float32(coords[i]), float32(coords[i+1]))
			p = p.Add(off)
			points = append(points, p)
		}
		newCtrl2 := ctrl2
		switch op := unicode.ToLower(op); op {
		case 'm', 'l':
			sop := moveTo
			if op == 'l' {
				sop = lineTo
			}
			for _, p := range points {
				sop(p)
				newPen = p
			}
			if op == 'm' {
				initPoint = newPen
			}
		case 'c':
			for i := 0; i < len(points); i += 3 {
				p1, p2, p3 := points[i], points[i+1], points[i+2]
				cubeTo(p1, p2, p3)
				newPen = p3
				newCtrl2 = p2
			}
		case 's':
			for i := 0; i < len(points); i += 2 {
				p2, p3 := points[i], points[i+1]
				// Compute p1 by reflecting p2 on to the line that contains pen and p2.
				p1 := pen.Mul(2).Sub(ctrl2)
				cubeTo(p1, p2, p3)
				newPen = p3
				newCtrl2 = p2
			}
		}
		pen = newPen
		ctrl2 = newCtrl2
	}
	return nil
}

func parseFloat(s string) (int, float64, bool) {
	n := 0
	if len(s) > 0 && s[0] == '-' {
		n++
	}
	for ; n < len(s); n++ {
		if !(unicode.IsDigit(rune(s[n])) || s[n] == '.') {
			break
		}
	}
	f, err := strconv.ParseFloat(s[:n], 64)
	return n, f, err == nil
}

const funcs = `
func argb(c uint32) color.NRGBA {
	return color.NRGBA{A: uint8(c >> 24), R: uint8(c >> 16), G: uint8(c >> 8), B: uint8(c)}
}

func rect(p *clip.Path, origin, size f32.Point) {
	p.MoveTo(origin)
	p.LineTo(origin.Add(f32.Pt(size.X, 0)))
	p.LineTo(origin.Add(size))
	p.LineTo(origin.Add(f32.Pt(0, size.Y)))
	p.Close()
}

func ellipse(p *clip.Path, center, radius f32.Point) {
	r := radius.X
	// We'll model the ellipse as a circle scaled in the Y
	// direction.
	scale := radius.Y / r

	// https://pomax.github.io/bezierinfo/#circles_cubic.
	const q = 4 * (math.Sqrt2 - 1) / 3

	curve := r * q
	top := f32.Point{X: center.X, Y: center.Y - r*scale}

	p.MoveTo(top)
	p.CubeTo(
		f32.Point{X: center.X + curve, Y: center.Y - r*scale},
		f32.Point{X: center.X + r, Y: center.Y - curve*scale},
		f32.Point{X: center.X + r, Y: center.Y},
	)
	p.CubeTo(
		f32.Point{X: center.X + r, Y: center.Y + curve*scale},
		f32.Point{X: center.X + curve, Y: center.Y + r*scale},
		f32.Point{X: center.X, Y: center.Y + r*scale},
	)
	p.CubeTo(
		f32.Point{X: center.X - curve, Y: center.Y + r*scale},
		f32.Point{X: center.X - r, Y: center.Y + curve*scale},
		f32.Point{X: center.X - r, Y: center.Y},
	)
	p.CubeTo(
		f32.Point{X: center.X - r, Y: center.Y - curve*scale},
		f32.Point{X: center.X - curve, Y: center.Y - r*scale},
		top,
	)
}
`