package http

import (
	"context"
	"fmt"
	"io"
	"net/http"
	"reflect"
	"strings"

	"github.com/unistack-org/micro/v3/codec"
	"github.com/unistack-org/micro/v3/errors"
	"github.com/unistack-org/micro/v3/logger"
	"github.com/unistack-org/micro/v3/metadata"
	"github.com/unistack-org/micro/v3/register"
	"github.com/unistack-org/micro/v3/server"
	rflutil "github.com/unistack-org/micro/v3/util/reflect"
	rutil "github.com/unistack-org/micro/v3/util/router"
)

var (
	DefaultErrorHandler = func(ctx context.Context, s server.Handler, w http.ResponseWriter, r *http.Request, err error, status int) {
		w.WriteHeader(status)
		w.Write([]byte(err.Error()))
	}
	DefaultContentType = "application/json"
)

type patHandler struct {
	pat   rutil.Pattern
	mtype *methodType
	name  string
	rcvr  reflect.Value
}

type httpHandler struct {
	name     string
	opts     server.HandlerOptions
	sopts    server.Options
	eps      []*register.Endpoint
	hd       interface{}
	handlers map[string][]patHandler
}

func (h *httpHandler) newCodec(ct string) (codec.Codec, error) {
	if cf, ok := h.sopts.Codecs[ct]; ok {
		return cf, nil
	}
	return nil, codec.ErrUnknownContentType
}

func (h *httpHandler) Name() string {
	return h.name
}

func (h *httpHandler) Handler() interface{} {
	return h.hd
}

func (h *httpHandler) Endpoints() []*register.Endpoint {
	return h.eps
}

func (h *httpHandler) Options() server.HandlerOptions {
	return h.opts
}

func (h *httpServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	ctx := metadata.NewContext(r.Context(), nil)

	defer r.Body.Close()

	path := r.URL.Path
	if !strings.HasPrefix(path, "/") {
		h.errorHandler(ctx, nil, w, r, fmt.Errorf("path must contains /"), http.StatusBadRequest)
		return
	}

	ct := strings.Split(DefaultContentType, ";")[0]
	if htype := r.Header.Get("Content-Type"); htype != "" {
		ct = strings.Split(htype, ";")[0]
	}

	var cf codec.Codec
	var err error
	switch ct {
	case "application/x-www-form-urlencoded":
		cf, err = h.newCodec(strings.Split(DefaultContentType, ";")[0])
	default:
		cf, err = h.newCodec(ct)
	}

	if err != nil {
		h.errorHandler(ctx, nil, w, r, err, http.StatusBadRequest)
		return
	}

	components := strings.Split(path[1:], "/")
	l := len(components)
	var verb string
	idx := strings.LastIndex(components[l-1], ":")
	if idx == 0 {
		h.errorHandler(ctx, nil, w, r, fmt.Errorf("not found"), http.StatusNotFound)
		return
	}
	if idx > 0 {
		c := components[l-1]
		components[l-1], verb = c[:idx], c[idx+1:]
	}

	matches := make(map[string]interface{})

	var match bool
	var hldr patHandler
	var handler *httpHandler
	for _, hpat := range h.handlers {
		handlertmp := hpat.(*httpHandler)
		for _, hldrtmp := range handlertmp.handlers[r.Method] {
			mp, err := hldrtmp.pat.Match(components, verb)
			if err == nil {
				match = true
				for k, v := range mp {
					matches[k] = v
				}
				hldr = hldrtmp
				handler = handlertmp
				break
			}
		}
	}

	if !match {
		h.errorHandler(ctx, nil, w, r, fmt.Errorf("not matching route found"), http.StatusNotFound)
		return
	}

	md, ok := metadata.FromIncomingContext(ctx)
	if !ok {
		md = metadata.New(0)
	}

	for k, v := range r.Header {
		md.Set(k, strings.Join(v, ", "))
	}

	// get fields from url values
	if len(r.URL.RawQuery) > 0 {
		umd, err := rflutil.URLMap(r.URL.RawQuery)
		if err != nil {
			h.errorHandler(ctx, handler, w, r, err, http.StatusBadRequest)
			return
		}
		for k, v := range umd {
			matches[k] = v
		}
	}

	if ct == "application/x-www-form-urlencoded" {
		buf, err := io.ReadAll(r.Body)
		if err != nil {
			h.errorHandler(ctx, nil, w, r, err, http.StatusBadRequest)
			return
		}
		umd, err := rflutil.URLMap(string(buf))
		if err != nil {
			h.errorHandler(ctx, handler, w, r, err, http.StatusBadRequest)
			return
		}
		for k, v := range umd {
			matches[k] = v
		}
	}

	var argv, replyv reflect.Value

	// Decode the argument value.
	argIsValue := false // if true, need to indirect before calling.
	if hldr.mtype.ArgType.Kind() == reflect.Ptr {
		argv = reflect.New(hldr.mtype.ArgType.Elem())
	} else {
		argv = reflect.New(hldr.mtype.ArgType)
		argIsValue = true
	}

	if argIsValue {
		argv = argv.Elem()
	}

	// reply value
	replyv = reflect.New(hldr.mtype.ReplyType.Elem())

	function := hldr.mtype.method.Func
	//function := hldr.rcvr
	var returnValues []reflect.Value

	if ct != "application/x-www-form-urlencoded" {
		if err = cf.ReadBody(r.Body, argv.Interface()); err != nil && err != io.EOF {
			h.errorHandler(ctx, handler, w, r, err, http.StatusInternalServerError)
			return
		}
	}

	matches = rflutil.FlattenMap(matches)
	if err = rflutil.Merge(argv.Interface(), matches, rflutil.SliceAppend(true), rflutil.Tags([]string{"protobuf", "json"})); err != nil {
		h.errorHandler(ctx, handler, w, r, err, http.StatusBadRequest)
		return
	}

	var b []byte
	if ct != "application/x-www-form-urlencoded" {
		b, err = cf.Marshal(argv.Interface())
		if err != nil {
			h.errorHandler(ctx, handler, w, r, err, http.StatusBadRequest)
			return
		}
	}

	hr := &rpcRequest{
		codec:       cf,
		service:     handler.sopts.Name,
		contentType: ct,
		method:      fmt.Sprintf("%s.%s", hldr.name, hldr.mtype.method.Name),
		body:        b,
		payload:     argv.Interface(),
	}

	var scode int
	// define the handler func
	fn := func(fctx context.Context, req server.Request, rsp interface{}) (err error) {
		fctx = context.WithValue(fctx, rspCodeKey{}, &rspCodeVal{})
		fctx = metadata.NewIncomingContext(fctx, md)
		returnValues = function.Call([]reflect.Value{hldr.rcvr, hldr.mtype.prepareContext(fctx), reflect.ValueOf(argv.Interface()), reflect.ValueOf(rsp)})

		scode = GetRspCode(fctx)
		// The return value for the method is an error.
		if rerr := returnValues[0].Interface(); rerr != nil {
			err = rerr.(error)
		}

		if md, ok := metadata.FromOutgoingContext(fctx); ok {
			metadata.SetOutgoingContext(ctx, md)
		}

		return err
	}

	// wrap the handler func
	for i := len(handler.sopts.HdlrWrappers); i > 0; i-- {
		fn = handler.sopts.HdlrWrappers[i-1](fn)
	}

	if appErr := fn(ctx, hr, replyv.Interface()); appErr != nil {
		switch verr := appErr.(type) {
		case *errors.Error:
			scode = int(verr.Code)
			b, err = cf.Marshal(verr)
		case *Error:
			b, err = cf.Marshal(verr.err)
		default:
			b, err = cf.Marshal(appErr)
		}
	} else {
		b, err = cf.Marshal(replyv.Interface())
	}
	if err != nil && handler.sopts.Logger.V(logger.ErrorLevel) {
		handler.sopts.Logger.Errorf(handler.sopts.Context, "handler err: %v", err)
		return
	}

	if md, ok := metadata.FromOutgoingContext(ctx); ok {
		for k, v := range md {
			w.Header().Set(k, v)
		}
	}

	w.Header().Set("content-Type", ct)
	if scode != 0 {
		w.WriteHeader(scode)
	} else {
		//handler.sopts.Logger.Warn(handler.sopts.Context, "response code not set in handler via SetRspCode(ctx, http.StatusXXX)")
		w.WriteHeader(200)
	}
	w.Write(b)
}