package lkratos

import (
	"context"
	"fmt"
	"gitee.com/fmpt/fmgo/logx"
	"github.com/go-kratos/kratos/v2/errors"
	klog "github.com/go-kratos/kratos/v2/log"
	"github.com/go-kratos/kratos/v2/middleware"
	"github.com/go-kratos/kratos/v2/transport"
	"time"
)

type Logger struct {
	*logx.Logger
}

// NewKratosLogger	returns a new kratos logger
func NewKratosLogger(logger *logx.Logger) klog.Logger {
	return Logger{
		Logger: logger,
	}
}

var kratosDeep = 4

func (l Logger) Log(level klog.Level, msg ...interface{}) error {
	switch level {
	case klog.LevelDebug:
		l.Logger.Debug(kratosDeep, msg...)
	case klog.LevelInfo:
		l.Logger.Info(kratosDeep, msg...)
	case klog.LevelWarn:
		l.Logger.Warn(kratosDeep, msg...)
	case klog.LevelError:
		l.Logger.Error(kratosDeep, msg...)
	case klog.LevelFatal:
		l.Logger.Fatal(kratosDeep, msg...)
	}
	return nil
}

// KratosServer is an server logging middleware.
func KratosServer(logger klog.Logger) middleware.Middleware {
	return func(handler middleware.Handler) middleware.Handler {
		return func(ctx context.Context, req interface{}) (reply interface{}, err error) {
			var (
				code      int32
				reason    string
				kind      string
				operation string
			)
			startTime := time.Now()
			if info, ok := transport.FromServerContext(ctx); ok {
				kind = info.Kind().String()
				operation = info.Operation()
			}
			reply, err = handler(ctx, req)
			if se := errors.FromError(err); se != nil {
				code = se.Code
				reason = se.Reason
			}
			level, _ := extractError(err)
			_ = klog.WithContext(ctx, logger).Log(level,
				"msg",
				fmt.Sprintf("[Kratos] %4d | %12s | %8s | %7s | %s\t%s",
					code,
					time.Since(startTime).String(),
					"server",
					kind,
					operation,
					reason,
				),
			)
			return
		}
	}
}

// extractError returns the string of the error
func extractError(err error) (klog.Level, string) {
	if err != nil {
		return klog.LevelError, fmt.Sprintf("%+v", err.Error())
	}
	return klog.LevelInfo, ""
}

// extractArgs returns the string of the req
func extractArgs(req interface{}) string {
	if stringer, ok := req.(fmt.Stringer); ok {
		return stringer.String()
	}
	return fmt.Sprintf("%+v", req)
}