package main

import (
	"errors"
	"github.com/gorilla/mux"
	"net"
	"net/http"
	"reflect"
	"sort"
	"strings"
)

// Rules holds rule parsing and configuration
type Rules struct {
	route *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 reqHost == strings.TrimSpace(host) {
				return true
			}
		}
		return false
	})
}

func (r *Rules) hostRegexp(hosts ...string) *mux.Route {
	router := r.route.route.Subrouter()
	for _, host := range hosts {
		router.Host(strings.TrimSpace(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 {
		router.PathPrefix(strings.TrimSpace(path))
	}
	return r.route.route
}

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) pathPrefixStrip(paths ...string) *mux.Route {
	sort.Sort(bySize(paths))
	r.route.stripPrefixes = 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...)
}

// Parse parses rules expressions
func (r *Rules) Parse(expression string) (*mux.Route, error) {
	functions := map[string]interface{}{
		"Host":            r.host,
		"HostRegexp":      r.hostRegexp,
		"Path":            r.path,
		"PathStrip":       r.pathStrip,
		"PathPrefix":      r.pathPrefix,
		"PathPrefixStrip": r.pathPrefixStrip,
		"Method":          r.methods,
		"Headers":         r.headers,
		"HeadersRegexp":   r.headersRegexp,
	}
	f := func(c rune) bool {
		return c == ':'
	}
	// get function
	parsedFunctions := strings.FieldsFunc(expression, f)
	if len(parsedFunctions) == 0 {
		return nil, errors.New("Error parsing rule: " + expression)
	}
	parsedFunction, ok := functions[parsedFunctions[0]]
	if !ok {
		return nil, errors.New("Error parsing rule: " + expression + ". Unknown function: " + parsedFunctions[0])
	}
	parsedFunctions = append(parsedFunctions[:0], parsedFunctions[1:]...)
	fargs := func(c rune) bool {
		return c == ',' || c == ';'
	}
	// get function
	parsedArgs := strings.FieldsFunc(strings.Join(parsedFunctions, ":"), fargs)
	if len(parsedArgs) == 0 {
		return nil, errors.New("Error parsing args from rule: " + expression)
	}

	inputs := make([]reflect.Value, len(parsedArgs))
	for i := range parsedArgs {
		inputs[i] = reflect.ValueOf(parsedArgs[i])
	}
	method := reflect.ValueOf(parsedFunction)
	if method.IsValid() {
		resultRoute := method.Call(inputs)[0].Interface().(*mux.Route)
		if r.err != nil {
			return nil, r.err
		}
		if resultRoute.GetError() != nil {
			return nil, resultRoute.GetError()
		}
		return resultRoute, nil
	}
	return nil, errors.New("Method not found: " + parsedFunctions[0])
}
