package traces

import (
	"basic.com/valib/bhomeclient.git"
	"basic.com/valib/logc.git"
	"basic.com/valib/logger.git"
	"bytes"
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/pkg/errors"
	"io/ioutil"
	"mime"
	"net/url"
	"strings"
	"sync"
	"time"
	"vamicro/api-gateway/auth"
	"vamicro/api-gateway/models"
	"vamicro/api-gateway/service"
	"vamicro/config"
)

type OperationPara struct {
	Context    *gin.Context
	Error       error
	Reply       *bhomeclient.Reply
}


var (
	blockSet = map[string]interface{}{}
	allowSet = map[string]interface{}{}

	methodBlockSet = map[string]map[string]interface{}{}
	methodAllowSet = map[string]map[string]interface{}{}

	moduleMap = map[string]string{}

	wg sync.WaitGroup
	done  chan struct{}
	cModule string
)

func DeInit() {
	close(done)
	wg.Wait()
}

func Init(logCallback logc.LogReportCallback) {
	done = make(chan struct{})
	wg.Add(1)

	log := &logc.Log{
		FatalLog: logger.Fatal,
		ErrorLog: logger.Error,
		WarnLog:  logger.Warn,
		InfoLog:  logger.Info,
	}

	logc.Init(logCallback, log, service.ProcName, service.ProcName, &wg, done)
}

func SetModuleMap(newmoduleMap map[string]string) {
	moduleMap = newmoduleMap
}

func SetBlockMethod(list [] models.Operations) {
	for _, v := range list {
		if v.Method == "*" || v.Method == "" || true {
			if v.Exclude {
				blockSet[v.Path] = v
			} else {
				allowSet[v.Path] = v
			}
		} else {
			if v.Exclude {
				if m, ok := methodBlockSet[v.Method]; ok {
					m[v.Path] = true
				} else {
					m := make(map[string]interface{})
					m[v.Path] = v
					methodBlockSet[v.Method] = m
				}
			} else {
				if m, ok := methodAllowSet[v.Method]; ok {
					m[v.Path] = v
				} else {
					m := make(map[string]interface{})
					m[v.Path] = v
					methodAllowSet[v.Method] = m
				}
			}
		}
	}
}

func blockOrAllow(method, path string) (string, bool) {

	var module models.Modules
	if len (strings.Split(path, "/")) > 3 {
		modulePart := strings.Split(path, "/")[3]
		module.NameZh = modulePart
		module.ProcName = modulePart
		isNew := module.Insert()
		cModule = modulePart
		if isNew {
			moduleMap[cModule] = cModule
		}
	}
	//logger.Debug(method,methodAllowSet[method])
	if m, exist := methodAllowSet[method]; exist {
		if v, ok := m[path]; ok {
			return v.(models.Operations).Name, true
		}
	}
	//logger.Debug(allowSet,path)
	if v, ok := allowSet[path]; ok {
		return v.(models.Operations).Name, true
	}

	var name string
	if config.Traceconf.UseBlockList != 0 {
		if m, exist := methodBlockSet[method]; exist {
			if v, ok := m[path]; ok {
				return v.(models.Operations).Name, false
			}
		}

		if v, ok := blockSet[path]; ok {
			return v.(models.Operations).Name, false
		}

		//return name, true
	}

	var op models.Operations
	op.Name = path
	op.Exclude = false
	op.Method = method
	op.Path = path
	op.Module = cModule
	op.Insert()
	if _, ok := allowSet[path]; ok {

	} else {
		allowSet[path] = op
	}



	return name, true
}

func TraceOperation(op *OperationPara) {
	defer func() {
		if r := recover(); r != nil {
			logger.Error("TraceOperation recover...", r)
		}
	}()

	funcName, allow := blockOrAllow(op.Context.Request.Method, op.Context.Request.URL.Path)
	if !allow {
		logger.Debug(op.Context.Request.URL.Path, " op log skipped")
		return
	}

	serviceName := moduleMap[cModule]

	var success bool = false
	var msg string
	if op.Error != nil {
		msg = op.Error.Error()
	} else {
		if !op.Reply.Success {
			msg = op.Reply.Msg
		} else {
			success = true
		}
	}

	var buffer = new(bytes.Buffer)
	n, err := buffer.ReadFrom(op.Context.Request.Body)
	if nil == err && n > 0 {
		_ = op.Context.Request.Body.Close();
		op.Context.Request.Body = ioutil.NopCloser(buffer)
	}

	queries, err := url.ParseQuery(op.Context.Request.URL.RawQuery)
	if nil != err {
		logger.Error("TraceOperation recover...", err)
		queries = url.Values{}
	}

	var userName string
	authDriver := auth.GenerateAuthDriver()
	user := (*authDriver).User(op.Context)
	if nil != user {
		userName = user["username"].(string)
	} else {
		logger.Warn("TraceOperations failed to get user...", op.Context.Request.URL.Path, op.Context.Request.Method)
	}

	contentType := op.Context.Request.Header.Get("Content-Type")
	body, err := parseContent(contentType, buffer)
	var bodyString string
	if nil == err {
		bodyString = fmt.Sprint(body)
	} else {
		bodyString = buffer.String()
	}

	var queryString string
	if len(queries) > 0 {
		queryString = fmt.Sprint(queries)
	}

	var result string
	var paraBuf bytes.Buffer
	paraBuf.WriteString(bodyString)
	paraBuf.WriteString(queryString)
	if success {
		result = "成功"
	} else {
		result = "失败"
	}
	if funcName == "" {
		funcName = op.Context.Request.URL.Path
	}
	log := &logc.OperationLog{
		Timestamp: time.Now().Unix(),
		UserName:  userName,
		Module:    serviceName,
		Function:  funcName,
		Result:    result,
		Para:      paraBuf.String(),
		Msg:       msg,
		Ip:        op.Context.ClientIP(),
		AddTime:  time.Now().Format("2006-01-02 15:04:05"),
	}
	logger.Debug(log)
	logc.SaveOperationLog(log, 500 * time.Millisecond)
}

func parseContent(contentType string, buf* bytes.Buffer) (url.Values, error) {
	if "" == contentType {
		contentType = "application/octet-stream"
	}

	ct, _, err := mime.ParseMediaType(contentType)
	if nil == err {
		if ct == "application/x-www-form-urlencoded" {
			return url.ParseQuery(buf.String())
		}
	}

	return nil, errors.New("not supported")
}

//func TraceOperations() gin.HandlerFunc {
//	return func(c *gin.Context) {
//		c.Next()
//
//		defer func() {
//			if r := recover(); r != nil {
//				logger.Error("TraceOperations recover...", r)
//			}
//		}()
//
//		var buffer = new(bytes.Buffer)
//		n, err := buffer.ReadFrom(c.Request.Body)
//		if nil == err && n > 0 {
//			_ = c.Request.Body.Close();
//			c.Request.Body = ioutil.NopCloser(buffer)
//		}
//
//		//contentType := c.Request.Header.Get("Content-Type")
//
//		formValues, err := url.ParseQuery(c.Request.URL.RawQuery)
//		if nil == err {
//			fmt.Print("formValues in hood:", formValues)
//		} else {
//			fmt.Print("formValues in hood:", err)
//		}
//
//		var userName string
//		authDriver := auth.GenerateAuthDriver()
//		user := (*authDriver).User(c)
//		if nil != user {
//			userName = user["username"].(string)
//		} else {
//			logger.Warn("TraceOperations failed to get user...", c.Request.URL.Path, c.Request.Method)
//		}
//
//		var module string
//		if m, exists := c.Get("module"); exists {
//			module = m.(string)
//		}
//
//		c.JSON(200, "")
//
//
//		contentType := c.Request.Header.Get("Content-Type")
//		logc.Log(userName, c.Request.Method, c.Request.URL.Path, contentType, module, buffer, formValues)
//	}
//}