package ci

import (
	"regexp"
	"strings"
	"unicode"

	"gitlab.com/Timfa/bluegit/internal/i18n"
)

// ruleParser leest een GitLab-achtige rules:if.
// && bindt sterker dan ||. Haakjes groeperen. Een lege waarde is null.
type ruleParser struct {
	s      string
	i      int
	env    map[string]string
	syntax bool
}

func (p *ruleParser) parseOr() (bool, error) {
	left, err := p.parseAnd()
	if err != nil {
		return false, err
	}
	for {
		p.skip()
		if !p.take("||") {
			return left, nil
		}
		right, err := p.parseAnd()
		if err != nil {
			return false, err
		}
		left = left || right
	}
}

func (p *ruleParser) parseAnd() (bool, error) {
	left, err := p.parseCmp()
	if err != nil {
		return false, err
	}
	for {
		p.skip()
		if !p.take("&&") {
			return left, nil
		}
		right, err := p.parseCmp()
		if err != nil {
			return false, err
		}
		left = left && right
	}
}

func (p *ruleParser) parseCmp() (bool, error) {
	p.skip()
	if p.peek() == '(' {
		p.i++
		inner, err := p.parseOr()
		if err != nil {
			return false, err
		}
		p.skip()
		if p.peek() != ')' {
			return false, i18n.E("ci.err.ruleExpr", strings.TrimSpace(p.s))
		}
		p.i++
		return inner, nil
	}
	left, err := p.value()
	if err != nil {
		return false, err
	}
	p.skip()
	op := p.operator()
	if op == "" {
		return false, i18n.E("ci.err.ruleExpr", strings.TrimSpace(p.s))
	}
	right, err := p.value()
	if err != nil {
		return false, err
	}
	return compare(op, left, right, p.syntax)
}

type ruleValue struct {
	text string
	null bool
	re   *regexp.Regexp
}

func (p *ruleParser) value() (ruleValue, error) {
	p.skip()
	if p.i >= len(p.s) {
		return ruleValue{}, i18n.E("ci.err.ruleExpr", strings.TrimSpace(p.s))
	}
	switch p.s[p.i] {
	case '$':
		name, err := p.variable()
		if err != nil {
			return ruleValue{}, err
		}
		text := p.env[name]
		return ruleValue{text: text, null: text == ""}, nil
	case '"', '\'':
		text, err := p.quoted()
		if err != nil {
			return ruleValue{}, err
		}
		return ruleValue{text: text, null: text == ""}, nil
	case '/':
		re, err := p.regex()
		if err != nil {
			return ruleValue{}, err
		}
		return ruleValue{re: re}, nil
	default:
		if p.takeWord("null") {
			return ruleValue{null: true}, nil
		}
		return ruleValue{}, i18n.E("ci.err.ruleExpr", strings.TrimSpace(p.s))
	}
}

func (p *ruleParser) variable() (string, error) {
	p.i++
	if p.i < len(p.s) && p.s[p.i] == '{' {
		p.i++
		start := p.i
		for p.i < len(p.s) && p.s[p.i] != '}' {
			p.i++
		}
		if p.i >= len(p.s) || start == p.i {
			return "", i18n.E("ci.err.ruleExpr", strings.TrimSpace(p.s))
		}
		name := p.s[start:p.i]
		p.i++
		if !ident(name) {
			return "", i18n.E("ci.err.ruleExpr", strings.TrimSpace(p.s))
		}
		return name, nil
	}
	start := p.i
	for p.i < len(p.s) && (isIdent(p.s[p.i])) {
		p.i++
	}
	if start == p.i {
		return "", i18n.E("ci.err.ruleExpr", strings.TrimSpace(p.s))
	}
	return p.s[start:p.i], nil
}

func (p *ruleParser) quoted() (string, error) {
	quote := p.s[p.i]
	p.i++
	var b strings.Builder
	for p.i < len(p.s) {
		c := p.s[p.i]
		if c == quote {
			p.i++
			return b.String(), nil
		}
		if c == '\\' && quote == '"' && p.i+1 < len(p.s) {
			p.i++
			b.WriteByte(p.s[p.i])
			p.i++
			continue
		}
		if c == '$' && quote == '"' {
			name, err := p.variable()
			if err != nil {
				return "", err
			}
			b.WriteString(p.env[name])
			continue
		}
		b.WriteByte(c)
		p.i++
	}
	return "", i18n.E("ci.err.ruleExpr", strings.TrimSpace(p.s))
}

func (p *ruleParser) regex() (*regexp.Regexp, error) {
	p.i++
	var b strings.Builder
	for p.i < len(p.s) {
		c := p.s[p.i]
		if c == '\\' && p.i+1 < len(p.s) {
			next := p.s[p.i+1]
			if next == '/' {
				b.WriteByte('/')
			} else {
				b.WriteByte('\\')
				b.WriteByte(next)
			}
			p.i += 2
			continue
		}
		if c == '/' {
			p.i++
			pat := b.String()
			if p.i < len(p.s) && (p.s[p.i] == 'i' || p.s[p.i] == 'I') {
				pat = "(?i)" + pat
				p.i++
			}
			re, err := regexp.Compile(pat)
			if err != nil {
				return nil, i18n.E("ci.err.regex", strings.TrimSpace(p.s), err.Error())
			}
			return re, nil
		}
		b.WriteByte(c)
		p.i++
	}
	return nil, i18n.E("ci.err.ruleExpr", strings.TrimSpace(p.s))
}

func (p *ruleParser) operator() string {
	p.skip()
	for _, op := range []string{"=~", "!~", "==", "!="} {
		if p.take(op) {
			return op
		}
	}
	return ""
}

func (p *ruleParser) take(lit string) bool {
	if strings.HasPrefix(p.s[p.i:], lit) {
		p.i += len(lit)
		return true
	}
	return false
}

func (p *ruleParser) takeWord(word string) bool {
	if !strings.HasPrefix(p.s[p.i:], word) {
		return false
	}
	end := p.i + len(word)
	if end < len(p.s) && isIdent(p.s[end]) {
		return false
	}
	p.i = end
	return true
}

func (p *ruleParser) peek() byte {
	p.skip()
	if p.i >= len(p.s) {
		return 0
	}
	return p.s[p.i]
}

func (p *ruleParser) skip() {
	for p.i < len(p.s) && unicode.IsSpace(rune(p.s[p.i])) {
		p.i++
	}
}

func compare(op string, left, right ruleValue, syntax bool) (bool, error) {
	switch op {
	case "==":
		if left.re != nil || right.re != nil {
			return false, i18n.E("ci.err.ruleExpr", op)
		}
		if left.null || right.null {
			return left.null && right.null, nil
		}
		return left.text == right.text, nil
	case "!=":
		if left.re != nil || right.re != nil {
			return false, i18n.E("ci.err.ruleExpr", op)
		}
		if left.null || right.null {
			return left.null != right.null, nil
		}
		return left.text != right.text, nil
	case "=~", "!~":
		if left.re != nil {
			return false, i18n.E("ci.err.ruleExpr", op)
		}
		re := right.re
		if re == nil && !right.null {
			compiled, err := regexp.Compile(right.text)
			if err != nil {
				return false, i18n.E("ci.err.regex", right.text, err.Error())
			}
			re = compiled
		}
		if re == nil {
			if syntax && right.null && right.text == "" && right.re == nil {
				return false, nil
			}
			return false, i18n.E("ci.err.ruleExpr", op)
		}
		ok := re.MatchString(left.text)
		if op == "!~" {
			ok = !ok
		}
		return ok, nil
	default:
		return false, i18n.E("ci.err.ruleExpr", op)
	}
}

// checkRule keurt de vorm goed zonder variabelen. Een patroon in een
// variabele wordt pas bij het draaien gecompileerd.
func checkRule(expr string) error {
	p := &ruleParser{s: expr, env: map[string]string{}, syntax: true}
	if _, err := p.parseOr(); err != nil {
		return err
	}
	p.skip()
	if p.i < len(p.s) {
		return i18n.E("ci.err.ruleExpr", strings.TrimSpace(expr))
	}
	return nil
}

func ident(s string) bool {
	if s == "" {
		return false
	}
	for i := 0; i < len(s); i++ {
		if !isIdent(s[i]) {
			return false
		}
	}
	return true
}

func isIdent(c byte) bool {
	return c == '_' || (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9')
}
