package event

import (
	"regexp"
	"strings"
	"time"

	"git.rosy.net.cn/baseapi/utils"
	"git.rosy.net.cn/jx-callback/business/jxutils"
	"git.rosy.net.cn/jx-callback/business/jxutils/jxcontext"
	"git.rosy.net.cn/jx-callback/business/model"
	"git.rosy.net.cn/jx-callback/business/model/dao"
)

var (
	NoUseEventMap = map[string]string{
		"CreateQrOrBarCode":         "CreateQrOrBarCode",
		"StatisticsReportForOrders": "StatisticsReportForOrders",
		"UpdateUser":                "UpdateUser",
	}
	regexpToken = regexp.MustCompile(`,"token":".*"`)
)

const (
	sysMessageTitle = ""
)

func AddOperateEvent(ctx *jxcontext.Context, accessUUID, jsonData string, errCode, errMsg string, useTime int, apiFunctionSpec string) (err error) {
	var (
		apiFunction string
		db          = dao.GetDB()
	)
	// if ctx.GetRequest() == nil {
	// 	return nil
	// }
	if apiFunctionSpec == "" {
		url := ctx.GetRequest().URL.Path
		if url != "" {
			apiFunction = url[strings.LastIndex(url, "/")+1 : len(url)]
		}
	} else {
		apiFunction = apiFunctionSpec
	}
	if apiFunction != "" {
		if apiFunction[0:3] == "Get" || NoUseEventMap[apiFunction] != "" {
			return err
		}
	}
	if accessUUID != "" {
		accessUUID = accessUUID[0:strings.Index(accessUUID, ",")]
	}
	jsonData = strings.ReplaceAll(jsonData, regexpToken.FindString(jsonData), "")
	jsonData = utils.LimitUTF8StringLen(jsonData, 3200)
	errMsg = utils.LimitUTF8StringLen(errMsg, 9999)
	event := &model.OperateEvent{
		CreatedAt:    time.Now(),
		LastOperator: ctx.GetUserName(),
		APIFunction:  apiFunction,
		UserID:       ctx.GetUserID(),
		AccessUUID:   accessUUID,
		JsonData:     jsonData,
		ErrCode:      errCode,
		ErrMsg:       errMsg,
		UseTime:      useTime,
	}
	txDB, _ := dao.Begin(db)
	defer func() {
		if r := recover(); r != nil {
			dao.Rollback(db, txDB)
			panic(r)
		}
	}()
	err = dao.CreateEntity(db, event)
	dao.Commit(db, txDB)
	return err
}

func AddOperateEventDetail(db *dao.DaoDB, operateEventDetail *model.OperateEventDetail) (err error) {
	txDB, _ := dao.Begin(db)
	defer func() {
		if r := recover(); r != nil {
			dao.Rollback(db, txDB)
			panic(r)
		}
	}()
	operateEventDetail.BeforeData = utils.LimitUTF8StringLen(operateEventDetail.BeforeData, 3200)
	operateEventDetail.AfterData = utils.LimitUTF8StringLen(operateEventDetail.AfterData, 3200)
	err = dao.CreateEntity(db, operateEventDetail)
	dao.Commit(db, txDB)
	return err
}

func DeleteOperateEventAndDetail(ctx *jxcontext.Context, deleteTime time.Time) (err error) {
	db := dao.GetDB()
	txDB, _ := dao.Begin(db)
	defer func() {
		if r := recover(); r != nil {
			dao.Rollback(db, txDB)
			panic(r)
		}
	}()
	dao.DeleteOperateEventDetail(db, deleteTime)
	dao.DeleteOperateEvent(db, deleteTime)
	dao.Commit(db, txDB)
	return err
}

func GetOperateEvents(ctx *jxcontext.Context, name string, apiFunctions []string, operateTypes, skuIDs, storeIDs []int, fromTime, toTime, keyword string, errType, offset, pageSize int) (pageInfo *model.PagedInfo, err error) {
	var (
		fromTimeP time.Time
		toTimeP   time.Time
	)
	db := dao.GetDB()
	if fromTime != "" {
		fromTimeP = utils.Str2Time(fromTime)
	}
	if toTime != "" {
		toTimeP = utils.Str2Time(toTime)
	}
	pageSize = jxutils.FormalizePageSize(pageSize)
	offset = jxutils.FormalizePageOffset(offset)
	operateEventExt, totalCount, err := dao.GetOperateEvents(db, name, apiFunctions, operateTypes, skuIDs, storeIDs, fromTimeP, toTimeP, keyword, errType, offset, pageSize)
	if err != nil {
		return pageInfo, err
	}
	pageInfo = &model.PagedInfo{
		Data:       operateEventExt,
		TotalCount: totalCount,
	}
	return pageInfo, err
}