package rules

import (
	"errors"
	"fmt"
	"net"
	"net/http"
	"reflect"
	"sort"
	"strings"

	"github.com/BurntSushi/ty/fun"
	"github.com/containous/mux"
	"github.com/containous/traefik/types"
)

// Rules holds rule parsing and configuration
type Rules struct {
	Route *types.ServerRoute
	err   error
}

func (r *Rules) host(hosts ...string) *mux.Route {
	return r.Route.Route.MatcherFunc(func(req *http.Request, route *mux.RouteMatch) bool {
		reqHost, _, err := net.SplitHostPort(req.Host)
		if err != nil {
			reqHost = req.Host
		}
		for _, host := range hosts {
			if types.CanonicalDomain(reqHost) == types.CanonicalDomain(host) {
				return true
			}
		}
		return false
	})
}

func (r *Rules) hostRegexp(hosts ...string) *mux.Route {
	router := r.Route.Route.Subrouter()
	for _, host := range hosts {
		router.Host(types.CanonicalDomain(host))
	}
	return r.Route.Route
}

func (r *Rules) path(paths ...string) *mux.Route {
	router := r.Route.Route.Subrouter()
	for _, path := range paths {
		router.Path(strings.TrimSpace(path))
	}
	return r.Route.Route
}

func (r *Rules) pathPrefix(paths ...string) *mux.Route {
	router := r.Route.Route.Subrouter()
	for _, path := range paths {
		buildPath(path, router)
	}
	return r.Route.Route
}

func buildPath(path string, router *mux.Router) {
	cleanPath := strings.TrimSpace(path)
	// {} are used to define a regex pattern in http://www.gorillatoolkit.org/pkg/mux.
	// if we find a { in the path, that means we use regex, then the gorilla/mux implementation is chosen
	// otherwise, we use a lightweight implementation
	if strings.Contains(cleanPath, "{") {
		router.PathPrefix(cleanPath)
	} else {
		m := &prefixMatcher{prefix: cleanPath}
		router.NewRoute().MatcherFunc(m.Match)
	}
}

type prefixMatcher struct {
	prefix string
}

func (m *prefixMatcher) Match(r *http.Request, _ *mux.RouteMatch) bool {
	return strings.HasPrefix(r.URL.Path, m.prefix) || strings.HasPrefix(r.URL.Path, m.prefix+"/")
}

type bySize []string

func (a bySize) Len() int           { return len(a) }
func (a bySize) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a bySize) Less(i, j int) bool { return len(a[i]) > len(a[j]) }

func (r *Rules) pathStrip(paths ...string) *mux.Route {
	sort.Sort(bySize(paths))
	r.Route.StripPrefixes = paths
	router := r.Route.Route.Subrouter()
	for _, path := range paths {
		router.Path(strings.TrimSpace(path))
	}
	return r.Route.Route
}

func (r *Rules) pathStripRegex(paths ...string) *mux.Route {
	sort.Sort(bySize(paths))
	r.Route.StripPrefixesRegex = paths
	router := r.Route.Route.Subrouter()
	for _, path := range paths {
		router.Path(strings.TrimSpace(path))
	}
	return r.Route.Route
}

func (r *Rules) replacePath(paths ...string) *mux.Route {
	for _, path := range paths {
		r.Route.ReplacePath = path
	}
	return r.Route.Route
}

func (r *Rules) replacePathRegex(paths ...string) *mux.Route {
	for _, path := range paths {
		r.Route.ReplacePathRegex = path
	}
	return r.Route.Route
}

func (r *Rules) addPrefix(paths ...string) *mux.Route {
	for _, path := range paths {
		r.Route.AddPrefix = path
	}
	return r.Route.Route
}

func (r *Rules) pathPrefixStrip(paths ...string) *mux.Route {
	sort.Sort(bySize(paths))
	r.Route.StripPrefixes = paths
	router := r.Route.Route.Subrouter()
	for _, path := range paths {
		buildPath(path, router)
	}
	return r.Route.Route
}

func (r *Rules) pathPrefixStripRegex(paths ...string) *mux.Route {
	sort.Sort(bySize(paths))
	r.Route.StripPrefixesRegex = paths
	router := r.Route.Route.Subrouter()
	for _, path := range paths {
		router.PathPrefix(strings.TrimSpace(path))
	}
	return r.Route.Route
}

func (r *Rules) methods(methods ...string) *mux.Route {
	return r.Route.Route.Methods(methods...)
}

func (r *Rules) headers(headers ...string) *mux.Route {
	return r.Route.Route.Headers(headers...)
}

func (r *Rules) headersRegexp(headers ...string) *mux.Route {
	return r.Route.Route.HeadersRegexp(headers...)
}

func (r *Rules) query(query ...string) *mux.Route {
	var queries []string
	for _, elem := range query {
		queries = append(queries, strings.Split(elem, "=")...)
	}

	return r.Route.Route.Queries(queries...)
}

func (r *Rules) parseRules(expression string, onRule func(functionName string, function interface{}, arguments []string) error) error {
	functions := map[string]interface{}{
		"Host":                 r.host,
		"HostRegexp":           r.hostRegexp,
		"Path":                 r.path,
		"PathStrip":            r.pathStrip,
		"PathStripRegex":       r.pathStripRegex,
		"PathPrefix":           r.pathPrefix,
		"PathPrefixStrip":      r.pathPrefixStrip,
		"PathPrefixStripRegex": r.pathPrefixStripRegex,
		"Method":               r.methods,
		"Headers":              r.headers,
		"HeadersRegexp":        r.headersRegexp,
		"AddPrefix":            r.addPrefix,
		"ReplacePath":          r.replacePath,
		"ReplacePathRegex":     r.replacePathRegex,
		"Query":                r.query,
	}

	if len(expression) == 0 {
		return errors.New("empty rule")
	}

	f := func(c rune) bool {
		return c == ':'
	}

	// Allow multiple rules separated by ;
	splitRule := func(c rune) bool {
		return c == ';'
	}

	parsedRules := strings.FieldsFunc(expression, splitRule)

	for _, rule := range parsedRules {
		// get function
		parsedFunctions := strings.FieldsFunc(rule, f)
		if len(parsedFunctions) == 0 {
			return fmt.Errorf("error parsing rule: '%s'", rule)
		}

		functionName := strings.TrimSpace(parsedFunctions[0])
		parsedFunction, ok := functions[functionName]
		if !ok {
			return fmt.Errorf("error parsing rule: '%s'. Unknown function: '%s'", rule, parsedFunctions[0])
		}
		parsedFunctions = append(parsedFunctions[:0], parsedFunctions[1:]...)

		// get function
		fargs := func(c rune) bool {
			return c == ','
		}
		parsedArgs := strings.FieldsFunc(strings.Join(parsedFunctions, ":"), fargs)
		if len(parsedArgs) == 0 {
			return fmt.Errorf("error parsing args from rule: '%s'", rule)
		}

		for i := range parsedArgs {
			parsedArgs[i] = strings.TrimSpace(parsedArgs[i])
		}

		err := onRule(functionName, parsedFunction, parsedArgs)
		if err != nil {
			return fmt.Errorf("parsing error on rule: %v", err)
		}
	}
	return nil
}

// Parse parses rules expressions
func (r *Rules) Parse(expression string) (*mux.Route, error) {
	var resultRoute *mux.Route

	err := r.parseRules(expression, func(functionName string, function interface{}, arguments []string) error {
		inputs := make([]reflect.Value, len(arguments))
		for i := range arguments {
			inputs[i] = reflect.ValueOf(arguments[i])
		}
		method := reflect.ValueOf(function)
		if method.IsValid() {
			resultRoute = method.Call(inputs)[0].Interface().(*mux.Route)
			if r.err != nil {
				return r.err
			}
			if resultRoute.GetError() != nil {
				return resultRoute.GetError()
			}
		} else {
			return fmt.Errorf("method not found: '%s'", functionName)
		}
		return nil
	})
	if err != nil {
		return nil, fmt.Errorf("error parsing rule: %v", err)
	}

	return resultRoute, nil
}

// ParseDomains parses rules expressions and returns domains
func (r *Rules) ParseDomains(expression string) ([]string, error) {
	var domains []string

	err := r.parseRules(expression, func(functionName string, function interface{}, arguments []string) error {
		if functionName == "Host" {
			domains = append(domains, arguments...)
		}
		return nil
	})
	if err != nil {
		return nil, fmt.Errorf("error parsing domains: %v", err)
	}

	return fun.Map(types.CanonicalDomain, domains).([]string), nil
}
