package parser

import (
	"fmt"
	"strings"
)

// Build builds an URI scheme from a pattern string
func Build(s string) (*Scheme, error){

	/* (1) Manage '/' at the start */
	if len(s) < 1 || s[0] != '/' {
		return nil, fmt.Errorf("URI must begin with '/'")
	}

	/* (2) Split by '/' */
	parts := strings.Split(s, "/")

	/* (3) Max exceeded */
	if len(parts)-2 > maxMatch {
		for i, p := range parts {
			fmt.Printf("%d: '%s'\n", i, p);
		}
		return nil, fmt.Errorf("URI must not exceed %d slash-separated components, got %d", maxMatch, len(parts))
	}

	/* (4) Build for each part */
	sch, err := buildScheme(parts)
	if err != nil {
		return nil, err
	}

	/* (5) Optimise structure */
	opti, err := sch.optimise()
	if err != nil {
		return nil, err
	}

	return &opti, nil

}


// Match returns if the given URI is matched by the scheme
func (s Scheme) Match(str string) bool {

	/* (1) Nothing -> match all */
	if len(s) == 0 { return true }

	/* (2) Check for string match */
	clearURI, match := s.matchString(str)
	if !match {
		return false
	}

	/* (3) Check for non-string match (wildcards) */
	match = s.matchWildcards(clearURI)
	if !match {
		return false
	}

	return true
}


// GetMatch returns the indexed match (excluding string matchers)
func (s Scheme) GetMatch(n uint8) ([]string, error) {

	/* (1) Index out of range */
	if n > uint8(len(s)) {
		return nil, fmt.Errorf("Index out of range")
	}

	/* (2) Iterate to find index (exclude strings) */
	ni := -1
	for i, l := 0, len(s) ; i < l ; i++ {

		// ignore strings
		if len(s[i].pat) > 0 { continue }

		// increment match counter : ni
		ni++

		// if expected index -> return matches
		if uint8(ni) == n {
			return s[i].buf, nil
		}

	}

	/* (3) If nothing found -> return empty set */
	return nil, fmt.Errorf("Index out of range (max: %d)", ni)

}