package controllers

import (
	"crypto/sha256"
	"encoding/hex"
	"fmt"
	"github.com/astaxie/beego"
	"strconv"
	"strings"

	"opp/protocol"
	"opp/services/auth"

	"github.com/astaxie/beego/context"
	"github.com/astaxie/beego/validation"
	"github.com/prometheus/client_golang/prometheus"
	"gitlab.fjmaimaimai.com/mmm-go/gocomm/common"
	"gitlab.fjmaimaimai.com/mmm-go/gocomm/pkg/log"
	"gitlab.fjmaimaimai.com/mmm-go/gocomm/pkg/mybeego"
)

var (
	//prometheus 监控endpoint
	HTTPReqTotal *prometheus.CounterVec
)

type BaseController struct {
	mybeego.BaseController
}

func init() {
	// HistogramVec 是一组Histogram
	HTTPReqTotal = prometheus.NewCounterVec(prometheus.CounterOpts{
		Name: "request_count_vec", //http_requests_total
		Help: "total number of http requests made.",
	}, []string{"method", "path"})
	// 这里的"method"、"path"、"status" 都是label , "status"
	prometheus.MustRegister(
		HTTPReqTotal,
	)
	//if err:=prometheus.Register(HTTPReqTotal);err!=nil{
	//	log.Error(err)
	//}
}

var DefaultController *BaseController = &BaseController{}

//Valid  valid struct
func (this *BaseController) Valid(obj interface{}) (result bool, msg *protocol.ResponseMessage) {
	/*校验*/
	var err error
	valid := validation.Validation{}
	result, err = valid.Valid(obj)
	if err != nil {
		msg = protocol.BadRequestParam(1)
		return
	}
	if !result {
		for _, err := range valid.Errors {
			if strings.HasSuffix(err.Key, ".Mobile") {
				msg = protocol.BadRequestParam(2001)
				return
			}
			log.Error(err.Key, err.Message)
		}
		msg = protocol.BadRequestParam(2)
		return
	}

	return
}

func (this *BaseController) Resp(msg *protocol.ResponseMessage) {

	this.Data["json"] = msg
	this.ServeJSON()
}

//获取请求头信息
func GetRequestHeader(ctx *context.Context) *protocol.RequestHeader {
	h := &protocol.RequestHeader{}
	h.AccessToken = ctx.Input.Header("x-mmm-accesstoken")
	h.AppProject = ctx.Input.Header("x-mmm-appproject")
	h.DeviceType, _ = strconv.Atoi(ctx.Input.Header("x-mmm-devicetype"))
	h.Sign = ctx.Input.Header("x-mmm-sign")
	h.Uuid = ctx.Input.Header("x-mmm-uuid")
	h.TimeStamp = ctx.Input.Header("x-mmm-timestamp")
	h.Uid, _ = strconv.ParseInt(ctx.Input.Header("uid"), 10, 64) //需要uid写入到header里面
	if h.Uid == 0 {
		h.Uid, _ = strconv.ParseInt(ctx.Input.Header("x-mmm-uid"), 10, 64)
	}
	h.CompanyId, _ = strconv.ParseInt(ctx.Input.Header("x-mmm-cid"), 10, 64)
	log.Debug(common.AssertJson(h))
	return h
}

//过滤器
func FilterComm(ctx *context.Context) {
	//if strings.HasSuffix(ctx.Request.RequestURI,"login"){
	//	return
	//}

	//统计
	MetricCounter(ctx)

	if beego.BConfig.RunMode == "dev" {
		return
	}
	//1.检查签名
	if !CheckSign(ctx) {
		return
	}
	//2.检查token是否有效
	if !CheckToken(ctx) {
		return
	}
	//3.查重uuid
	//if !CheckUuid(ctx) {
	//	return
	//}
	return
}

func MetricCounter(ctx *context.Context) {
	// 请求数加1
	HTTPReqTotal.With(prometheus.Labels{
		"method": ctx.Request.Method,
		"path":   ctx.Request.RequestURI,
		//"status": strconv.Itoa(c.Writer.Status()),
	}).Inc()
}

//检查签名
func CheckSign(ctx *context.Context) (result bool) {
	var (
		h       *protocol.RequestHeader
		sign    string
		signHex string
	)
	result = true
	h = GetRequestHeader(ctx)
	//1.检查签名
	sign = fmt.Sprintf("v!(MmM%v%v%vMmM)i^", h.TimeStamp, h.Uuid, h.AccessToken)
	sha256 := sha256.New()
	sha256.Write([]byte(sign))
	signHex = hex.EncodeToString(sha256.Sum(nil))
	if strings.Compare(signHex, h.Sign) != 0 {
		msg := protocol.BadRequestParam(113)
		log.Error(fmt.Sprintf("%v req:%v resp:%v %v", ctx.Request.RequestURI, common.AssertJson(h), common.AssertJson(msg), signHex))
		ctx.Output.JSON(msg, false, false)
		result = false
		return
	}
	return
}

//检查access_token
func CheckToken(ctx *context.Context) (result bool) {
	var (
		msg *protocol.ResponseMessage
	)
	if strings.HasSuffix(ctx.Request.RequestURI, "login") {
		return true
	}
	result = true
	defer func() {
		if msg != nil {
			result = false
			ctx.Output.JSON(msg, false, false)
		}
	}()
	token := ctx.Input.Header("x-mmm-accesstoken")
	if rsp, err := auth.CheckToken(&protocol.CheckTokenRequest{Token: token}); err != nil || rsp.UserInfo == nil {
		msg = protocol.NewReturnResponse(rsp, err)
		log.Error(fmt.Sprintf("%v req:%v resp:%v", ctx.Request.RequestURI, token, common.AssertJson(msg)))
		return
	} else {
		if rsp.UserInfo != nil {
			//设置附加数据
			ctx.Request.Header.Add("x-mmm-uid", fmt.Sprintf("%v", rsp.UserInfo.UserId))
			ctx.Request.Header.Add("x-mmm-cid", fmt.Sprintf("%v", rsp.UserInfo.CurrentCompanyId))
		}
	}
	return
}

//检查Uuid
func CheckUuid(ctx *context.Context) (result bool) {
	var (
		msg *protocol.ResponseMessage
	)
	result = true
	defer func() {
		if msg != nil {
			result = false
			ctx.Output.JSON(msg, false, false)
		}
	}()
	uuid := ctx.Input.Header("x-mmm-uuid")
	msg = protocol.NewReturnResponse(auth.CheckUuid(&protocol.CheckUuidRequest{Uuid: uuid}))
	if msg != nil {
		log.Error(fmt.Sprintf("%v req:%v resp:%v", ctx.Request.RequestURI, uuid, common.AssertJson(msg)))
	}
	return
}