package mvg

import "encoding/hex"
import "fmt"
import "strconv"
import "strings"
import "golang.org/x/image/colornames"

/* LL(1) syntax.

COMMANDS -> COMMAND COMMANDS | .
COMMAND -> word PARAMS .
PARAMS -> ws PARAM PARAMS | PARAM.
PARAM -> LIST | ELEM | string | id | word | url.
LIST -> ELEM comma LIST | ELEM .
ELEM -> var | number.

*/

type Parser struct {
	Name   string
	Buffer []rune
	Index  int
	Line   int
}

func (p *Parser) Error(msg string, extra ...interface{}) Error {
	form := "%s:%d:" + msg
	args := []interface{}{}
	args = append(args, p.Name, p.Line)
	args = append(args, extra...)
	return Error{fmt.Errorf(form, args...)}
}

func (p *Parser) Peek() rune {
	if p.Index > len(p.Buffer) {
		return -1
	}
	ru := p.Buffer[p.Index]
	return ru
}

func (p *Parser) Next() rune {
	ru := p.Peek()
	if ru == -1 {
		return ru
	}
	if ru == '\n' {
		p.Line++
	}
	p.Index++
	return ru
}

func (p *Parser) ParseWhile(ok func(r rune, i int) bool, found func(string) Value) Value {
	var ru rune
	val := []rune{}
	start := p.Index
	ru = p.Next()
	if !ok(ru, p.Index-start) {
		return nil
	}
	val = append(val, ru)
	for ; ok(ru, p.Index-start); ru = p.Next() {
		val = append(val, ru)
	}

	if ru == -1 {
		return p.Error("Unexpected EOF")
	}
	return found(string(val))
}

func IsID(r rune, i int) bool {
	if (i == 0) && (r == '%') {
		return true
	}
	return IsWord(r, i)
}

func IsWord(r rune, i int) bool {
	return (r >= 'a' && r <= 'z') ||
		(r >= 'A' && r <= 'Z') ||
		r == '_' || r == '-'
}

func IsNumber(r rune, i int) bool {
	return (r >= '0' && r <= '9') ||
		r == '.'
}

type Value interface {
	Eval(gc *GraphicContext) Value
}

type Error struct {
	error
}

func (e Error) Eval(gc *GraphicContext) Value {
	return e
}

type Word string

func (w Word) Eval(gc *GraphicContext) Value {
	return w
}

type ID string

func (i ID) Eval(gc *GraphicContext) Value {
	return i
}

func (p *Parser) ParseID() Value {
	return p.ParseWhile(IsID, func(res string) Value {
		return ID(res[1:len(res)]) // chop off the %
	})
}

type Variable string

func IsVariable(r rune, i int) bool {
	if (i == 0) && (r == '$') {
		return true
	}
	return IsWord(r, i)
}

func (v Variable) Eval(gc *GraphicContext) Value {
	var ok bool
	var val Value
	for val, ok = gc.Variables[string(v)]; !ok; val, ok = gc.Variables[string(v)] {
		if gc.Parent == nil {
			return Error{fmt.Errorf("Could not evaluate variable: %s", string(v))}
		}
		gc = gc.Parent
	}
	return val
}

func (p *Parser) ParseVariable() Value {
	return p.ParseWhile(IsVariable, func(res string) Value {
		return Variable(res[1:len(res)]) // chop off the $
	})
}

type Number float32

func (n Number) Eval(gc *GraphicContext) Value {
	return n
}

func (p *Parser) ParseWord() Value {
	return p.ParseWhile(IsWord, func(res string) Value {
		return Word(res)
	})
}

func (p *Parser) ParseNumber() Value {
	return p.ParseWhile(IsNumber, func(res string) Value {
		f, err := strconv.ParseFloat(res, 32)
		if err != nil {
			return p.Error("Cannot convert to number: %s, %s", res, err)
		}
		return Number(f)
	})
}

type Ref string

func IsRef(r rune, i int) bool {
	if (i == 0) && (r == 'u') {
		return true
	} else if (i == 1) && (r == 'r') {
		return true
	} else if (i == 2) && (r == 'l') {
		return true
	} else if (i == 3) && (r == '(') {
		return true
	} else if (i == 4) && (r == '#') {
		return true
	} else if (i > 5) && (r == ')') {
		return true
	}
	return IsWord(r, i)
}

func (p *Parser) ParseRef() Value {
	prefix := string(p.Buffer[p.Index : p.Index+4])
	if prefix != "url(#" {
		return nil
	}
	return p.ParseWhile(IsRef, func(res string) Value {
		return Variable(res[5 : len(res)-1]) // chop off the url(#)
	})
}

func (r Ref) Eval(gc *GraphicContext) Value {
	var ok bool
	var val DefValue
	for val, ok = gc.Defs[string(r)]; !ok; val, ok = gc.Defs[string(r)] {
		if gc.Parent == nil {
			return Error{fmt.Errorf("Could not evaluate reference: %s", string(r))}
		}
		gc = gc.Parent
	}
	return val
}

type String string

func IsStringFor(p Parser, between rune) func(r rune, i int) bool {
	return func(r rune, i int) bool {
		if (i == 0) && (r == between) {
			return true
		} else if r == between {
			return p.Buffer[p.Index+i-1] != '\\'
		} else {
			return true
		}
	}
}

var StringEscaper = strings.NewReplacer(
	"\\\\", "\\",
	"\\n", "\n",
	"\\r", "\r",
	"\\t", "\t",
)

func (s String) Eval(gc *GraphicContext) Value {
	return s
}

func (p *Parser) ParseString() Value {
	between := p.Peek()
	if between != '\'' && between != '"' && between != '`' {
		return nil
	}
	return p.ParseWhile(IsStringFor(*p, between), func(res string) Value {
		mid := res[1:(len(res) - 2)]
		return String(StringEscaper.Replace(mid))
	})
}

func IsColor(r rune, i int) bool {
	if (i == 0) && (r == '#') {
		return true
	}
	return (r >= '0' && r <= '9') ||
		(r >= 'a' && r <= 'f') ||
		(r >= 'A' && r <= 'F')
}

func StringToColor(str string) (Color, error) {
	if str[0] == '#' {
		sub := str[1:len(str)]
		switch len(sub) {
		case 3:
			sub = sub[0:0] + sub[0:0] + sub[1:1] + sub[1:1] + sub[2:2] + sub[2:2] + "00"
		case 4:
			sub = sub[0:0] + sub[0:0] + sub[1:1] + sub[1:1] + sub[2:2] + sub[2:2] + sub[3:3] + sub[3:3]
		case 6:
			sub = sub + "00"
		case 8:
			sub = sub
		default:
			return Color{}, fmt.Errorf("Length of color hex must be 3,4, 6, or 8")
		}
		b, err := hex.DecodeString(sub)
		if err != nil {
			return Color{}, err
		}
		return Color{b[0], b[1], b[2], b[3]}, nil
	} else {
		col, ok := colornames.Map[str]
		var err error = nil
		if !ok {
			err = fmt.Errorf("Unknown color name: %s", col)
		}
		return Color(col), err
	}
}

func (p *Parser) ParseColor() Value {
	return p.ParseWhile(IsColor, func(res string) Value {
		col, err := StringToColor(res)
		if err != nil {
			return p.Error("Could not parse color: %s: %s", res, err)
		}
		return col
	})
}

type ParserFunc func() Value
type ParserList []ParserFunc

func (pl ParserList) OneOf() Value {
	for _, parser := range pl {
		val := parser()
		if val != nil {
			return val
		}
	}
	return nil
}

func (p Parser) ParseSeparatedList(parseElem, parseSep ParserFunc) Value {
	list := List{}
	for elem := parseElem(); elem != nil; elem = parseElem() {
		list = append(list, elem)
		sep := parseSep()
		if sep == nil {
			break
		}
	}
	return list
}

type List []Value

func (l List) Eval(gc *GraphicContext) Value {
	return l
}

func (p *Parser) ParseElem() Value {
	l := ParserList{p.ParseVariable, p.ParseNumber}
	return l.OneOf()
}

func (p *Parser) ParseList() Value {

}

/*

COMMANDS -> COMMAND COMMANDS | .
COMMAND -> word PARAMS .
PARAMS -> ws PARAM PARAMS | PARAM.
PARAM -> LIST | ELEM | string | id | word | ref.
LIST -> ELEM comma LIST | ELEM .
ELEM -> var | number.



Drawing Primitives

Here is a complete description of the MVG drawing primitives:
Primitive 	Description

affine sx,rx,ry,sy,tx,ty

arc x0,y0 x1,y1 a0,a1

bezier x0,y0 ... xn,yn 	Bezier (spline) requires three or more x,y coordinates
to define its shape. The first and last points are the knots
(preserved coordinates) and any intermediate coordinates are the control points.
If two control points are specified, the line between each end knot and its
sequentially respective control point determines the tangent direction of the
curve at that end. If one control point is specified, the lines from the end
knots to the one control point determines the tangent directions of the curve
at each end. If more than two control points are specified, then the
additional control points act in combination to determine the intermediate
shape of the curve. In order to draw complex curves, it is highly recommended
either to use the Path primitive or to draw multiple four-point bezier segments
with the start and end knots of each successive segment repeated.

border-color color

circle originx,originy perimeterx,perimetery

clip-path url(name)

clip-rule rule 	Choose from these rule types:

    evenodd
    nonzero

clip-units units 	Choose from these unit types:

    userSpace
    userSpaceOnUse
    objectBoundingBox

color x,y method 	Choose from these method types:

    point
    replace
    floodfill
    filltoborder
    reset

compliance type 	Choose from these compliance types: MVG or SVG

decorate type 	Choose from these types of decorations:

    none
    line-through
    overline
    underline

ellipse centerx,centery radiusx,radiusy arcstart,arcstop

fill color 	Choose from any of these colors.

fill-opacity opacity 	The opacity ranges from 0.0 (fully transparent) to 1.0
(fully opaque) or as a percentage (e.g. 50%).

fill-rule rule 	Choose from these rule types:

    evenodd
    nonzero

font name

font-family family

font-size point-size

font-stretch type 	Choose from these stretch types:

    all
    normal
    ultra-condensed
    extra-condensed
    condensed
    semi-condensed
    semi-expanded
    expanded
    extra-expanded
    ultra-expanded

font-style style 	Choose from these styles:

    all
    normal
    italic
    oblique

font-weight weight 	Choose from these weights:

    all
    normal
    bold
    100
    200
    300
    400
    500
    600
    700
    800
    900

gradient-units units 	Choose from these units:

    userSpace
    userSpaceOnUse
    objectBoundingBox

gravity type 	Choose from these gravity types:

    NorthWest
    North
    NorthEast
    West
    Center
    East
    SouthWest
    South
    SouthEast

image compose x,y width,height 'filename' 	Choose from these compose operations:

Method 	Description
clear 	Both the color and the alpha of the destination are cleared. Neither the source nor the destination are used as input.
src 	The source is copied to the destination. The destination is not used as input.
dst 	The destination is left untouched.
src-over 	The source is composited over the destination.
dst-over 	The destination is composited over the source and the result replaces the destination.
src-in 	The part of the source lying inside of the destination replaces the destination.
dst-in 	The part of the destination lying inside of the source replaces the destination.
src-out 	The part of the source lying outside of the destination replaces the destination.
dst-out 	The part of the destination lying outside of the source replaces the destination.
src-atop 	The part of the source lying inside of the destination is composited onto the destination.
dst-atop 	The part of the destination lying inside of the source is composited over the source and replaces the destination.
multiply 	The source is multiplied by the destination and replaces the destination. The resultant color is always at least as dark as either of the two constituent colors. Multiplying any color with black produces black. Multiplying any color with white leaves the original color unchanged.
screen 	The source and destination are complemented and then multiplied and then replace the destination. The resultant color is always at least as light as either of the two constituent colors. Screening any color with white produces white. Screening any color with black leaves the original color unchanged.
overlay 	Multiplies or screens the colors, dependent on the destination color. Source colors overlay the destination whilst preserving its highlights and shadows. The destination color is not replaced, but is mixed with the source color to reflect the lightness or darkness of the destination.
darken 	Selects the darker of the destination and source colors. The destination is replaced with the source when the source is darker, otherwise it is left unchanged.
lighten 	Selects the lighter of the destination and source colors. The destination is replaced with the source when the source is lighter, otherwise it is left unchanged.
linear-light 	Increase contrast slightly with an impact on the foreground's tonal values.
color-dodge 	Brightens the destination color to reflect the source color. Painting with black produces no change.
color-burn 	Darkens the destination color to reflect the source color. Painting with white produces no change.
hard-light 	Multiplies or screens the colors, dependent on the source color value. If the source color is lighter than 0.5, the destination is lightened as if it were screened. If the source color is darker than 0.5, the destination is darkened, as if it were multiplied. The degree of lightening or darkening is proportional to the difference between the source color and 0.5. If it is equal to 0.5 the destination is unchanged. Painting with pure black or white produces black or white.
soft-light 	Darkens or lightens the colors, dependent on the source color value. If the source color is lighter than 0.5, the destination is lightened. If the source color is darker than 0.5, the destination is darkened, as if it were burned in. The degree of darkening or lightening is proportional to the difference between the source color and 0.5. If it is equal to 0.5, the destination is unchanged. Painting with pure black or white produces a distinctly darker or lighter area, but does not result in pure black or white.
plus 	The source is added to the destination and replaces the destination. This operator is useful for animating a dissolve between two images.
add 	As per 'plus' but transparency data is treated as matte values. As such any transparent areas in either image remain transparent.
minus 	Subtract the colors in the source image from the destination image. When transparency is involved, Opaque areas will be subtracted from any destination opaque areas.
subtract 	Subtract the colors in the source image from the destination image. When transparency is involved transparent areas are subtracted, so only the opaque areas in the source remain opaque in the destination image.
difference 	Subtracts the darker of the two constituent colors from the lighter. Painting with white inverts the destination color. Painting with black produces no change.
exclusion 	Produces an effect similar to that of 'difference', but appears as lower contrast. Painting with white inverts the destination color. Painting with black produces no change.
xor 	The part of the source that lies outside of the destination is combined with the part of the destination that lies outside of the source.
copy-* 	Copy the specified channel in the source image to the same channel in the destination image. If the channel specified in the source image does not exist, (which can only happen for methods, 'copy-opacity' or 'copy-black') then it is assumed that the source image is a special grayscale channel image of the values to be copied.
change-mask 	Replace any destination pixel that is the similar to the source images pixel (as defined by the current -fuzz factor), with transparency.

interline-spacing pixels

interword-spacing pixels

kerning pixels

line x,y x1,y1

matte x,y method 	Choose from these methods:

    point
    replace
    floodfill
    filltoborder
    reset

offset offset

opacity opacity 	Use percent (e.g. 50%).

path path

point x,y

polygon x,y x1,y1, ..., xn,yn

polyline x,y x1,y1, ..., xn,yn

pop clip-path

pop defs

pop gradient

pop graphic-context

pop pattern

push clip-path "name"

push defs

push gradient id linear x,y x1,y1

push gradient id radial xc,cy xf,yf radius

push graphic-context { "id" } 	the id is optional

push pattern id radial x,y width,height

rectangle x,y x1,y1

rotate angle

roundrectangle x,y x1,y1 width,height

scale x,y

skewX angle

skewX angle

stop-color color offset

stroke color

stroke-antialias 0 • 1

stroke-dasharray none • numeric-list

stroke-dashoffset offset

stroke-linecap type 	Choose from these cap types:

    butt
    round
    square

stroke-linejoin type 	Choose from these join types:

    bevel
    miter
    round

stroke-miterlimit limit

stroke-opacity opacity 	The opacity ranges from 0.0 (fully transparent) to 1.0 (fully opaque) or as a percentage (e.g. 50%).

stroke-width width

text "text"

text-antialias 0 • 1

text-undercolor color

translate x,y

use "url(#id)"

viewbox x,y x1,y1
*/