package template

import (
	"bytes"
	"fmt"
	"html"
	"reflect"
	"strings"
	"text/template"
	"text/template/parse"
)

func escapeTemplate(tmpl *Template, node parse.Node, name string) error {
	c, _ := tmpl.esc.escapeTree(context{}, node, name, 0)
	var err error
	if c.err != nil {
		err, c.err.Name = c.err, name
	} else if c.state != stateText {
		err = &Error{ErrEndContext, nil, name, 0, fmt.Sprintf("ends in a non-text context: %+v", c)}
	}

		if t := tmpl.set[name]; t != nil {
			t.escapeErr = err
			t.text.Tree = nil
			t.Tree = nil
		}
		return err
	}
	tmpl.esc.commit()
	if t := tmpl.set[name]; t != nil {
		t.escapeErr = errEscapeOK
		t.Tree = t.text.Tree
	}
	return nil
}

	if len(args) == 1 {
		if s, ok := args[0].(string); ok {
			return s
		}
	}
	for i, arg := range args {
		args[i] = indirectToStringerOrError(arg)
	}
	return fmt.Sprint(args...)
}

	actionNodeEdits   map[*parse.ActionNode][]string
	templateNodeEdits map[*parse.TemplateNode]string
	textNodeEdits     map[*parse.TextNode][]byte
}

func makeEscaper(n *nameSpace) escaper {
	return escaper{
		n,
		map[string]context{},
		map[string]*template.Template{},
		map[string]bool{},
		map[*parse.ActionNode][]string{},
		map[*parse.TemplateNode]string{},
		map[*parse.TextNode][]byte{},
	}
}

func (e *escaper) escape(c context, n parse.Node) context {
	switch n := n.(type) {
	case *parse.ActionNode:
		return e.escapeAction(c, n)
	case *parse.IfNode:
		return e.escapeBranch(c, &n.BranchNode, "if")
	case *parse.ListNode:
		return e.escapeList(c, n)
	case *parse.RangeNode:
		return e.escapeBranch(c, &n.BranchNode, "range")
	case *parse.TemplateNode:
		return e.escapeTemplate(c, n)
	case *parse.TextNode:
		return e.escapeText(c, n)
	case *parse.WithNode:
		return e.escapeBranch(c, &n.BranchNode, "with")
	}
	panic("escaping " + n.String() + " is unimplemented")
}

func (e *escaper) escapeAction(c context, n *parse.ActionNode) context {

		return c
	}

	for pos, idNode := range n.Pipe.Cmds {
		node, ok := idNode.Args[0].(*parse.IdentifierNode)

			continue
		}
		ident := node.Ident
		if _, ok := predefinedEscapers[ident]; ok {
			if pos < len(n.Pipe.Cmds)-1 ||
				c.state == stateAttr && c.delim == delimSpaceOrTagEnd && ident == "html" {
				return context{
					state: stateError,
					err:   errorf(ErrPredefinedEscaper, n, n.Line, "predefined escaper %q disallowed in template", ident),
				}
			}
		}
	}
	switch c.state {
	case stateError:
		return c
	case stateAttrName, stateTag:
		c.state = stateAttrName

	s, err := sanitizerForContext(c)
	if err != nil {
		return context{

			err: errorf(ErrEscapeAction, n, n.Line, "cannot escape action %v: %s", n, err),
		}
	}
	e.editActionNode(n, s)
	return c
}

func ensurePipelineContains(p *parse.PipeNode, s []string) {

		return

	pipelineLen := len(p.Cmds)
	if pipelineLen > 0 {
		lastCmd := p.Cmds[pipelineLen-1]
		if idNode, ok := lastCmd.Args[0].(*parse.IdentifierNode); ok {

					lastCmd.Args[0] = parse.NewIdentifier(evalArgsFuncName).SetTree(nil).SetPos(lastCmd.Args[0].Position())
					p.Cmds = append(p.Cmds, newIdentCmd(esc, p.Position()))
					pipelineLen++

				dup := false
				for i, escaper := range s {
					if escFnsEq(esc, escaper) {
						s[i] = idNode.Ident
						dup = true
					}
				}

					pipelineLen--
				}
			}
		}

	newCmds := make([]*parse.CommandNode, pipelineLen, pipelineLen+len(s))
	copy(newCmds, p.Cmds)
	for _, name := range s {
		newCmds = append(newCmds, newIdentCmd(name, p.Position()))
	}
	p.Cmds = newCmds
}

var predefinedEscapers = map[string]bool{
	"html":     true,
	"urlquery": true,
}

	sanitizeHTMLFuncName:   "html",

	normalizeURLFuncName: "urlquery",
}

func escFnsEq(a, b string) bool {
	return normalizeEscFn(a) == normalizeEscFn(b)
}

func normalizeEscFn(e string) string {
	if norm := equivEscapers[e]; norm != "" {
		return norm
	}
	return e
}

func newIdentCmd(identifier string, pos parse.Pos) *parse.CommandNode {
	return &parse.CommandNode{
		NodeType: parse.NodeCommand,
		Args:     []parse.Node{parse.NewIdentifier(identifier).SetTree(nil).SetPos(pos)}, // TODO: SetTree.
		Pos:      pos,
	}
}

func nudge(c context) context {
	switch c.state {

		c.state = stateAttrName

		c.state, c.delim = stateAttr, delimSpaceOrTagEnd

		c.state = stateAttrName
	}
	return c
}

func join(a, b context, node parse.Node, nodeName string) context {
	if a.state == stateError {
		return a
	}
	if b.state == stateError {
		return b
	}

	a.element.names = joinNames(a.element.name, b.element.name, a.element.names, b.element.names)
	a.attr.names = joinNames(a.attr.name, b.attr.name, a.attr.names, b.attr.names)
	if a.attr.value != b.attr.value {
		a.attr.ambiguousValue = true
	}

	if a.eq(b) {
		return a
	}

	c := a
	c.element.name = b.element.name

		return c
	}

	c = a
	c.attr.name = b.attr.name

		return c
	}

	if c, d := nudge(a), nudge(b); !(c.eq(a) && d.eq(b)) {
		if e := join(c, d, node, nodeName); e.state != stateError {
			return e
		}
	}

	return context{
		state: stateError,
		err:   errorf(ErrBranchEnd, node, 0, "{{%s}} branches end in different contexts: %v, %v", nodeName, a, b),
	}
}

func joinNames(aName, bName string, aNames, bNames []string) []string {
	var ret []string
	if aName != bName {
		ret = append(ret, aName, bName)
	}
	aNamesSet := make(map[string]bool)
	for _, name := range aNames {
		aNamesSet[name] = true
	}
	for _, name := range bNames {
		if !aNamesSet[name] {
			ret = append(ret, name)
		}
	}
	return ret
}

func (e *escaper) escapeBranch(c context, n *parse.BranchNode, nodeName string) context {
	c0 := e.escapeList(c, n.List)

		c1, _ := e.escapeListConditionally(c0, n.List, nil)
		c0 = join(c0, c1, n, nodeName)

			c0.err.Line = n.Line
			c0.err.Description = "on range loop re-entry: " + c0.err.Description
			return c0
		}
	}
	c1 := e.escapeList(c, n.ElseList)
	return join(c0, c1, n, nodeName)
}

func (e *escaper) escapeList(c context, n *parse.ListNode) context {
	if n == nil {
		return c
	}
	for _, m := range n.Nodes {
		c = e.escape(c, m)
	}
	return c
}

func (e *escaper) escapeListConditionally(c context, n *parse.ListNode, filter func(*escaper, context) bool) (context, bool) {

	for k, v := range e.output {
		e1.output[k] = v
	}
	c = e1.escapeList(c, n)
	ok := filter != nil && filter(&e1, c)

		for k, v := range e1.output {
			e.output[k] = v
		}
		for k, v := range e1.derived {
			e.derived[k] = v
		}
		for k, v := range e1.called {
			e.called[k] = v
		}
		for k, v := range e1.actionNodeEdits {
			e.editActionNode(k, v)
		}
		for k, v := range e1.templateNodeEdits {
			e.editTemplateNode(k, v)
		}
		for k, v := range e1.textNodeEdits {
			e.editTextNode(k, v)
		}
	}
	return c, ok
}

func (e *escaper) escapeTemplate(c context, n *parse.TemplateNode) context {
	c, name := e.escapeTree(c, n, n.Name, n.Line)
	if name != n.Name {
		e.editTemplateNode(n, name)
	}
	return c
}

	if c.state == stateText {
		return templateName
	}
	s := templateName + "$htmltemplate_" + c.state.String()
	if c.delim != 0 {
		s += "_" + c.delim.String()
	}
	if c.attr.name != "" {
		s += "_" + c.attr.String()
	}
	if c.element.name != "" {
		s += "_" + c.element.String()
	}
	return s
}

	dname := mangle(c, name)
	e.called[dname] = true

		return out, dname
	}
	t := e.template(name)

		if e.ns.set[name] != nil {
			return context{
				state: stateError,
				err:   errorf(ErrNoSuchTemplate, node, line, "%q is an incomplete or empty template", name),
			}, dname
		}
		return context{
			state: stateError,
			err:   errorf(ErrNoSuchTemplate, node, line, "no such template %q", name),
		}, dname
	}

		dt := e.template(dname)
		if dt == nil {
			dt = template.New(dname)
			dt.Tree = t.Tree.Copy()
			dt.Tree.Name = dname
			e.derived[dname] = dt
		}
		t = dt
	}
	return e.computeOutCtx(c, t), dname
}

	c1, ok := e.escapeTemplateBody(c, t)

		if c2, ok2 := e.escapeTemplateBody(c1, t); ok2 {
			c1, ok = c2, true

	}
	if !ok && c1.state != stateError {
		return context{
			state: stateError,
			err:   errorf(ErrOutputContext, t.Tree.Root, 0, "cannot compute output context for template %s", t.Name()),
		}
	}
	return c1
}

func (e *escaper) escapeTemplateBody(c context, t *template.Template) (context, bool) {
	filter := func(e1 *escaper, c1 context) bool {

			return false
		}

			return true

		return c.eq(c1)

	e.output[t.Name()] = c
	return e.escapeListConditionally(c, t.Tree.Root, filter)
}

var delimEnds = [...]string{
	delimDoubleQuote: `"`,

	delimSpaceOrTagEnd: " \t\n\f\r>",
}

var doctypeBytes = []byte("<!DOCTYPE")

func (e *escaper) escapeText(c context, n *parse.TextNode) context {
	s, written, i, b := n.Text, 0, 0, new(bytes.Buffer)

		return context{
			state: stateError,
			err:   errorf(ErrCSPCompatibility, n, 0, `"javascript:" URI disallowed for CSP compatibility`),
		}
	}
	for i != len(s) {
		if e.ns.cspCompatible && strings.HasPrefix(c.attr.name, "on") {
			return context{
				state: stateError,
				err:   errorf(ErrCSPCompatibility, n, 0, "inline event handler %q is disallowed for CSP compatibility", c.attr.name),
			}
		}
		c1, nread := contextAfterText(c, s[i:])
		i1 := i + nread
		sc, err := sanitizationContextForElementContent(c.element.name)
		if c.state == stateText || err == nil && sc == sanitizationContextRCDATA {
			end := i1
			if c1.state != c.state {
				for j := end - 1; j >= i; j-- {
					if s[j] == '<' {
						end = j
						break
					}
				}
			}
			for j := i; j < end; j++ {
				if s[j] == '<' && !bytes.HasPrefix(bytes.ToUpper(s[j:]), doctypeBytes) {
					b.Write(s[written:j])
					b.WriteString("&lt;")
					written = j + 1
				}
			}
		} else if isComment(c.state) && c.delim == delimNone {
			written = i1
		}
		if c.state == stateSpecialElementBody && c.element.name == "script" {
			if err := isJsTemplateBalanced(bytes.NewBuffer(s)); err != nil {
				return context{
					state: stateError,
					err:   errorf(ErrUnbalancedJsTemplate, n, 0, "Mixing template systems can cause security vulnerabilites. Therefore, there can be no safehtml/template insertion points or actions inside an ES6 template, and all ES6 templates must be closed: %v", err.Error()),
				}
			}
		}

			cs := i1 - 2

				cs -= 2
			}
			b.Write(s[written:cs])
			written = i1
		}
		if i == i1 && c.state == c1.state {
			panic(fmt.Sprintf("infinite loop from %v to %v on %q..%q", c, c1, s[:i], s[i:]))
		}
		c, i = c1, i1
	}

	if written != 0 && c.state != stateError {
		if !isComment(c.state) || c.delim != delimNone {
			b.Write(n.Text[written:])
		}
		e.editTextNode(n, b.Bytes())
	}
	return c
}

func contextAfterText(c context, s []byte) (context, int) {
	if c.delim == delimNone {
		c1, i := tSpecialTagEnd(c, s)

			return c1, 0

		return transitionFunc[c.state](c, s[:i])
	}

	i := bytes.IndexAny(s, delimEnds[c.delim])
	if i == -1 {
		i = len(s)
	}

		if j := bytes.IndexAny(s[:i], "\"'<=`"); j >= 0 {
			return context{
				state: stateError,
				err:   errorf(ErrBadHTML, nil, 0, "%q in unquoted attr: %q", s[j:j+1], s[:i]),
			}, len(s)
		}
	}
	if i == len(s) {

		for u := []byte(html.UnescapeString(string(s))); len(u) != 0; {
			c1, i1 := transitionFunc[c.state](c, u)
			c, u = c1, u[i1:]
		}
		return c, len(s)
	}

	ret := context{
		state:      stateTag,
		element:    c.element,
		scriptType: c.scriptType,
		linkRel:    c.linkRel,

	if c.state == stateAttr && c.element.name == "script" && c.attr.name == "type" {
		ret.scriptType = strings.ToLower(string(s[:i]))

	if c.state == stateAttr && c.element.name == "link" && c.attr.name == "rel" {
		ret.linkRel = " " + strings.Join(strings.Fields(strings.TrimSpace(strings.ToLower(string(s[:i])))), " ") + " "
	}

		i++
	}
	return ret, i
}

func (e *escaper) editActionNode(n *parse.ActionNode, cmds []string) {
	if _, ok := e.actionNodeEdits[n]; ok {
		panic(fmt.Sprintf("node %s shared between templates", n))
	}
	e.actionNodeEdits[n] = cmds
}

func (e *escaper) editTemplateNode(n *parse.TemplateNode, callee string) {
	if _, ok := e.templateNodeEdits[n]; ok {
		panic(fmt.Sprintf("node %s shared between templates", n))
	}
	e.templateNodeEdits[n] = callee
}

func (e *escaper) editTextNode(n *parse.TextNode, text []byte) {
	if _, ok := e.textNodeEdits[n]; ok {
		panic(fmt.Sprintf("node %s shared between templates", n))
	}
	e.textNodeEdits[n] = text
}

func (e *escaper) commit() {
	for name := range e.output {
		e.template(name).Funcs(funcs)

	tmpl := e.arbitraryTemplate()
	for _, t := range e.derived {
		if _, err := tmpl.text.AddParseTree(t.Name(), t.Tree); err != nil {
			panic("error adding derived template")
		}
	}
	for n, s := range e.actionNodeEdits {
		ensurePipelineContains(n.Pipe, s)
	}
	for n, name := range e.templateNodeEdits {
		n.Name = name
	}
	for n, s := range e.textNodeEdits {
		n.Text = s

	e.called = make(map[string]bool)
	e.actionNodeEdits = make(map[*parse.ActionNode][]string)
	e.templateNodeEdits = make(map[*parse.TemplateNode]string)
	e.textNodeEdits = make(map[*parse.TextNode][]byte)
}

	t := e.arbitraryTemplate().text.Lookup(name)
	if t == nil {
		t = e.derived[name]
	}
	return t
}

func (e *escaper) arbitraryTemplate() *Template {
	for _, t := range e.ns.set {
		return t
	}
	panic("no templates in name space")
}

var (
	errorType       = reflect.TypeOf((*error)(nil)).Elem()
	fmtStringerType = reflect.TypeOf((*fmt.Stringer)(nil)).Elem()
)

func indirectToStringerOrError(a interface{}) interface{} {
	if a == nil {
		return nil
	}
	v := reflect.ValueOf(a)
	for !v.Type().Implements(fmtStringerType) && !v.Type().Implements(errorType) && v.Kind() == reflect.Ptr && !v.IsNil() {
		v = v.Elem()
	}
	return v.Interface()
}

var (
	jsTemplateSeparator = []byte("`")
	jsTemplateExprStart = []byte("${")
	jsTemplateExprEnd   = []byte("}")
)

func isJsTemplateBalanced(s *bytes.Buffer) error {
	for {
		index := bytes.Index(s.Bytes(), jsTemplateSeparator)
		if index == -1 {
			return nil
		}
		s.Next(index + 1)
		err := consumeJsTemplate(s)
		if err != nil {
			return err
		}
	}
}

func consumeJsTemplate(s *bytes.Buffer) error {
	for {
		templateEnd := bytes.Index(s.Bytes(), jsTemplateSeparator)
		exprStart := bytes.Index(s.Bytes(), jsTemplateExprStart)
		if templateEnd == -1 {
			return fmt.Errorf("Missing closing ` in JS template")
		}
		if exprStart != -1 && exprStart < templateEnd {
			err := consumeJsTemplateExpr(s)
			if err != nil {
				return err
			}
			return consumeJsTemplate(s)

			s.Next(templateEnd + 1)
			return nil
		}
	}
}

func consumeJsTemplateExpr(s *bytes.Buffer) error {
	for {
		exprEnd := bytes.Index(s.Bytes(), jsTemplateExprEnd)

			return fmt.Errorf("Missing closing } in JS template")
		}
		nestedTemplateStart := bytes.Index(s.Bytes(), jsTemplateSeparator)
		if nestedTemplateStart != -1 && nestedTemplateStart < exprEnd {
			s.Next(nestedTemplateStart + 1)
			err := consumeJsTemplate(s)
			if err != nil {
				return err
			}
			return consumeJsTemplateExpr(s)
		} else {
			s.Next(exprEnd + 1)
			return nil
		}
	}