package web_filter

import (
	"gitee.com/kristas/booting-go/framework/common/util/lang"
	"gitee.com/kristas/booting-go/framework/web"
	"net/http"
	"regexp"
	"sort"
)

var (
	filters []web.Filter
)

func AddFilters(filter web.Filter) {
	filters = append(filters, filter)
}

type FilterChain struct {
	filter  web.Filter
	next    web.FilterChain
	service web.Service
}

func (f *FilterChain) GetFilter() web.Filter {
	return f.filter
}

func (f *FilterChain) SetNext(chain web.FilterChain) {
	f.next = chain
}

func (f *FilterChain) GetNext() web.FilterChain {
	return f.next
}

func (f *FilterChain) SetService(service web.Service) {
	f.service = service
}

func (f *FilterChain) DoService(w http.ResponseWriter, r *http.Request) error {
	return f.service(w, r)
}

func (f *FilterChain) DoFilter(w http.ResponseWriter, r *http.Request) error {
	next := findNextFilter(r.RequestURI, f.next)
	if next == nil {
		return f.DoService(w, r)
	}
	return next.GetFilter().DoFilter(w, r, next)
}

func newFilterChain(filter web.Filter, service web.Service) web.FilterChain {
	return &FilterChain{
		filter:  filter,
		service: service,
	}
}

func NewFilterChainWithMapper(mapper web.ParamMapper, service web.Service) error {
	w, _ := mapper.GetResponseWriter()
	r, _ := mapper.GetRequest()
	return NewFilterChain(w, r, service)
}

func NewFilterChain(w http.ResponseWriter, r *http.Request, service web.Service) error {
	var headFilter, currentFilter web.FilterChain
	if len(filters) == 0 {
		AddFilters(new(defaultFilter))
	}
	for i := range filters {
		filter := filters[i]
		if headFilter == nil {
			headFilter = newFilterChain(filter, service)
			currentFilter = headFilter
		} else {
			next := newFilterChain(filter, service)
			currentFilter.SetNext(next)
			currentFilter = next
		}
	}
	entryFilter := findNextFilter(r.RequestURI, headFilter)
	if entryFilter == nil {
		return nil
	}
	return entryFilter.GetFilter().DoFilter(w, r, entryFilter)
}

func findNextFilter(uri string, curr web.FilterChain) web.FilterChain {
	var nextFilter = curr
	for nextFilter != nil {
		patterns := nextFilter.GetFilter().UrlPatterns()
		for _, pattern := range patterns {
			pattern = lang.NewString("^").Concat(pattern).String()
			matched, _ := regexp.MatchString(pattern, uri)
			if matched {
				return nextFilter
			}
		}
		nextFilter = nextFilter.GetNext()
	}
	return nil
}

func sortFilters() {
	sort.Slice(filters, func(i, j int) bool {
		return filters[i].Order() < filters[j].Order()
	})
}

func InitFilters(trace func(order int, filter web.Filter)) {
	sortFilters()
	for i := range filters {
		trace(i+1, filters[i])
	}
}