package router

import (
	"encoding/json"
	"fmt"
	"net/http"
	"reflect"

	"github.com/julienschmidt/httprouter"
)

type route struct {
	Method string
	Path   string
	Handle interface{}
}

// GetHandle handles a request that doesn't receive a body
type GetHandle func(*Context) error

// Router is the router itself
type Router struct {
	routes []route
	Port   int
}

// New returns a new Router
func New() *Router {
	return &Router{}
}

// GET adds a GET route
func (r *Router) GET(path string, handle GetHandle) {
	r.routes = append(r.routes, route{`GET`, path, handle})
}

// POST adds a POST route
func (r *Router) POST(path string, handle interface{}) {
	checkInterfaceHandle(handle)
	r.routes = append(r.routes, route{`POST`, path, handle})
}

// DELETE adds a DELETE route
func (r *Router) DELETE(path string, handle GetHandle) {
	r.routes = append(r.routes, route{`DELETE`, path, handle})
}

// PUT adds a PUT route
func (r *Router) PUT(path string, handle interface{}) {
	checkInterfaceHandle(handle)
	r.routes = append(r.routes, route{`PUT`, path, handle})
}

// PATCH adds a PATCH route
func (r *Router) PATCH(path string, handle interface{}) {
	checkInterfaceHandle(handle)
	r.routes = append(r.routes, route{`PATCH`, path, handle})
}

// HEAD adds a HEAD route
func (r *Router) HEAD(path string, handle GetHandle) {
	r.routes = append(r.routes, route{`HEAD`, path, handle})
}

// OPTIONS adds a OPTIONS route
func (r *Router) OPTIONS(path string, handle GetHandle) {
	r.routes = append(r.routes, route{`OPTIONS`, path, handle})
}

// Start starts the web server and binds to the given address
func (r *Router) Start(addr string) error {
	httpr := r.getHttpr()

	return http.ListenAndServe(addr, httpr)
}

func (r *Router) getHttpr() *httprouter.Router {
	httpr := httprouter.New()

	for _, v := range r.routes {
		if handle, ok := v.Handle.(GetHandle); ok {
			httpr.Handle(v.Method, v.Path, handleGET(handle))
			continue
		}

		httpr.Handle(v.Method, v.Path, handlePOST(v.Handle))
	}

	return httpr
}

func checkInterfaceHandle(f interface{}) {
	if _, ok := f.(GetHandle); ok {
		return
	}

	rt := reflect.TypeOf(f)

	if rt.Kind() != reflect.Func {
		panic(`non-func handle`)
	}

	if rt.NumIn() != 2 {
		panic(`handle should take 2 arguments`)
	}

	if rt.NumOut() != 1 || rt.Out(0).Name() != `error` {
		panic(`handle should return only error`)
	}

	if rt.In(0) != reflect.TypeOf(&Context{}) {
		panic(`handle should accept Context as first argument`)
	}

	return
}

func handlePOST(f interface{}) httprouter.Handle {
	funcRv, inputRt := reflect.ValueOf(f), reflect.TypeOf(f).In(1)

	return func(res http.ResponseWriter, req *http.Request, param httprouter.Params) {
		c := newContext(res, req, param)

		data := reflect.New(inputRt)
		{
			err := json.NewDecoder(req.Body).Decode(data.Interface())
			req.Body.Close()
			if err != nil {
				c.NoContent(400) // TODO: send info about error (BindError)
				return
			}
		}

		out := funcRv.Call([]reflect.Value{reflect.ValueOf(c), data.Elem()})
		err := out[0].Interface()
		_ = err
	}
}

func handleGET(f GetHandle) httprouter.Handle {
	return func(res http.ResponseWriter, req *http.Request, param httprouter.Params) {
		c := newContext(res, req, param)

		err := f(c)

		fmt.Println(err)
	}
}