package glob

import "strings"

// Glob represents compiled glob pattern.
type Glob interface {
	Match(string) bool
}

// New creates Glob for given pattern and uses other given (if any) strings as separators.
// The pattern syntax is:
//
//	pattern:
//	    { term }
//
//	term:
//		`*`         matches any sequence of non-separator characters
//		`**`        matches any sequence of characters
//		`?`         matches any single non-separator character
//      `[` [ `!` ] { character-range } `]`
//                  character class (must be non-empty)
//      `{` pattern-list `}`
//					pattern alternatives
//		c           matches character c (c != `*`, `**`, `?`, `\`, `[`, `{`, `}`)
//		`\` c       matches character c
//
//  character-range:
//      c           matches character c (c != `\\`, `-`, `]`)
//      `\` c       matches character c
//      lo `-` hi   matches character c for lo <= c <= hi
//
//  pattern-list:
//      pattern { `,` pattern }
//                  comma-separated (without spaces) patterns
func Compile(pattern string, separators ...string) (Glob, error) {
	ast, err := parse(newLexer(pattern))
	if err != nil {
		return nil, err
	}

	matcher, err := compile(ast, strings.Join(separators, ""))
	if err != nil {
		return nil, err
	}

	return matcher, nil
}

// MustCompile is the same as Compile, except that if Compile returns error, this will panic
func MustCompile(pattern string, separators ...string) Glob {
	g, err := Compile(pattern, separators...)
	if err != nil {
		panic(err)
	}

	return g
}