package webutility
  
  import (

  	"net/http"

  	"net/url"

  	"strings"
  )

  // Filter ...

  type Filter map[string][]string

  // Get ...

  func (f Filter) Get(key string) (values []string, ok bool) {
  	values, ok = f[key]
  	return values, ok

  }

  // Count ...

  func (f Filter) Count() int {

  	return len(f)
  }

  // Add ...

  func (f Filter) Add(key, val string) {
  	f[key] = append(f[key], val)

  }

  // ValueAt ...

  func (f Filter) ValueAt(val string, index int) string {
  	if filter, ok := f[val]; ok {
  		if len(filter) > index {
  			return filter[index]
  		}
  	}
  
  	return ""
  }

  func (f Filter) Validate(validFilters []string) (Filter, bool) {

  	goodFilters := make(Filter)
  	cnt, len := 0, 0

  	for fi := range f {

  		len++
  		for _, v := range validFilters {

  			if fi == v {

  				cnt++

  				goodFilters[fi] = f[fi]

  			}
  		}
  	}
  
  	result := true
  	if len > 0 && cnt == 0 {
  		// if no valid filters are found declare filtering request as invalid
  		result = false
  	}
  
  	return goodFilters, result
  }

  // ParseFilters requires input in format: "param1::value1|param2::value2..."

  func ParseFilters(req *http.Request, header string) (filters Filter) {
  	q := req.FormValue(header)
  	q = strings.Trim(q, "\"")
  	kvp := strings.Split(q, "|")

  	filters = make(Filter, len(kvp))

  	for i := range kvp {

  		kv := strings.Split(kvp[i], "::")
  		if len(kv) == 2 {

  			key, _ := url.QueryUnescape(kv[0])

  
  			// get values (if more than 1)
  			vals := strings.Split(kv[1], ",")
  			for _, v := range vals {
  				u, _ := url.QueryUnescape(v)
  				filters[key] = append(filters[key], u)
  			}

  		}
  	}
  
  	return filters
  }