package event

import (
	"encoding/json"
	"fmt"
	"regexp"
	"strings"
	"time"

	"git.rosy.net.cn/baseapi/utils"
	"git.rosy.net.cn/jx-callback/business/jxstore/financial"
	"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",
	}
	regexpToken = regexp.MustCompile(`,"token":".*"`)
)

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,
	}
	dao.Begin(db)
	defer func() {
		if r := recover(); r != nil {
			dao.Rollback(db)
			panic(r)
		}
	}()
	err = dao.CreateEntity(db, event)
	dao.Commit(db)
	return err
}

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

func DeleteOperateEventAndDetail(ctx *jxcontext.Context, deleteTime time.Time) (err error) {
	db := dao.GetDB()
	dao.Begin(db)
	defer func() {
		if r := recover(); r != nil {
			dao.Rollback(db)
			panic(r)
		}
	}()
	dao.DeleteOperateEventDetail(db, deleteTime)
	dao.DeleteOperateEvent(db, deleteTime)
	dao.Commit(db)
	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
}

func CreateMessageGroup(ctx *jxcontext.Context, userID, userID2, groupName string, dividePercentage, quitPrice int) (messageGroupResult *dao.GetMessageGroupsResult, err error) {
	var (
		db      = dao.GetDB()
		groupID int
	)
	if userID2 != "" {
		messageGroups, err := dao.GetMessageGroups(db, userID, model.GroupTypeSingle, true, userID2)
		if len(messageGroups) > 0 && len(messageGroups[0].MessageGroupMembers) > 0 {
			return messageGroups[0], err
		}
		user, err := dao.GetUserByID(db, "user_id", userID2)
		if err != nil {
			return nil, err
		}
		if user == nil {
			return nil, fmt.Errorf("无法找到要联系的用户！")
		}
		for {
			groupID = jxutils.GenRand6()
			temp := &model.MessageGroup{
				GroupID: groupID,
			}
			dao.GetEntity(db, temp, "GroupID")
			if temp.UserID == "" {
				break
			}
		}
		messageGroup := &model.MessageGroup{
			GroupID: groupID,
			UserID:  userID,
			// Name:     user.Name,
			Type:     model.GroupTypeSingle,
			MaxCount: 2,
		}
		messageGroupMember := &model.MessageGroupMember{
			GroupID:      groupID,
			MemberUserID: userID2,
			Type:         model.GroupMemberTypeNormal,
		}
		dao.WrapAddIDCULDEntity(messageGroup, ctx.GetUserName())
		dao.WrapAddIDCULDEntity(messageGroupMember, ctx.GetUserName())
		dao.CreateEntity(db, messageGroup)
		dao.CreateEntity(db, messageGroupMember)
		if data, err := json.Marshal(messageGroup); err == nil {
			json.Unmarshal(data, &messageGroupResult)
			messageGroupResult.Name = user.Name
			messageGroupResult.MessageGroupMembers = append(messageGroupResult.MessageGroupMembers, messageGroupMember)
		}
	} else {
		userMembers, err := dao.GetUserMember(db, userID, model.MemberTypeNormal)
		if err != nil {
			return nil, err
		}
		if len(userMembers) == 0 {
			return nil, fmt.Errorf("抱歉，只有会员才能创建群聊！")
		}
		messageGroup := &model.MessageGroup{
			GroupID:          groupID,
			UserID:           userID,
			Name:             groupName,
			Type:             model.GroupTypeMulit,
			MaxCount:         50,
			DividePercentage: dividePercentage,
			QuitPrice:        quitPrice,
		}
		user, err := dao.GetUserByID(db, "user_id", userID)
		if groupName == "" {
			messageGroup.Name = user.Name + "的集团"
		}
		dao.WrapAddIDCULDEntity(messageGroup, ctx.GetUserName())
		dao.CreateEntity(db, messageGroup)
		messageGroupResult.MessageGroup = *messageGroup
	}
	return messageGroupResult, err
}

func GetMessageGroupByUser(ctx *jxcontext.Context, userID string) (messageGroupResult []*dao.GetMessageGroupsResult, err error) {
	var (
		db = dao.GetDB()
	)
	messageGroups, err := dao.GetMessageGroups(db, userID, 0, false, "")
	for _, v := range messageGroups {
		var messageMemberGroups []*model.MessageGroupMember
		sql := `
			SELECT * FROM message_group_member WHERE group_id = ? 
		`
		sqlParams := []interface{}{v.GroupID}
		if err = dao.GetRows(db, &messageMemberGroups, sql, sqlParams); err == nil {
			if v.Type == model.GroupTypeSingle {
				user, err := dao.GetUserByID(db, "user_id", messageMemberGroups[0].MemberUserID)
				if err == nil {
					v.Name = user.Name
				}
			}
		}
	}
	return messageGroups, err
}

func AddMessageGroup(ctx *jxcontext.Context, groupID int, userID string) (err error) {
	var (
		db = dao.GetDB()
	)
	messageGroupMembers, err := dao.GetMessageGroupMembers(db, groupID, userID)
	if err != nil {
		return err
	}
	if len(messageGroupMembers) > 0 {
		return fmt.Errorf("此用户已经在该群组中了，请不要重复邀请！")
	}
	messageGroupMember := &model.MessageGroupMember{
		GroupID:      groupID,
		MemberUserID: userID,
		Type:         model.GroupMemberTypeNormal,
	}
	dao.WrapAddIDCULDEntity(messageGroupMember, ctx.GetUserName())
	dao.CreateEntity(db, messageGroupMember)
	return err
}

func UpdateMessageGroup(ctx *jxcontext.Context, groupID int, payload map[string]interface{}) (num int64, err error) {
	var (
		db           = dao.GetDB()
		messageGroup = &model.MessageGroup{
			GroupID: groupID,
		}
	)
	if err = dao.GetEntity(db, messageGroup, "GroupID"); err != nil {
		return 0, err
	}
	valid := dao.StrictMakeMapByStructObject(payload, messageGroup, ctx.GetUserName())
	if len(valid) > 0 {
		dao.Begin(db)
		defer func() {
			if r := recover(); r != nil {
				dao.Rollback(db)
				panic(r)
			}
		}()
		if num, err = dao.UpdateEntityLogically(db, messageGroup, valid, ctx.GetUserName(), nil); err != nil {
			dao.Rollback(db)
			return 0, err
		}
		dao.Commit(db)
	}
	return num, err
}

func DeleteMessageGroup(ctx *jxcontext.Context, groupID int, userID string) (errCode string, err error) {
	var (
		db           = dao.GetDB()
		messageGroup = &model.MessageGroup{
			GroupID: groupID,
		}
	)
	if err = dao.GetEntity(db, messageGroup, "GroupID"); err != nil {
		return errCode, err
	}
	//token中用户与传入user不一致就判定为踢人
	if ctx.GetUserID() != userID {
		if messageGroup.UserID != ctx.GetUserID() {
			messageGroupMembers, err := dao.GetMessageGroupMembers(db, groupID, ctx.GetUserID())
			if err != nil {
				return errCode, err
			}
			if messageGroupMembers[0].Type == model.GroupMemberTypeNormal {
				return errCode, fmt.Errorf("只有创建者和管理员才能踢人！")
			}
		}
		messageGroupMembers, err := dao.GetMessageGroupMembers(db, groupID, userID)
		if err != nil {
			return errCode, err
		}
		messageGroupMembers[0].DeletedAt = time.Now()
		messageGroupMembers[0].LastOperator = ctx.GetUserName()
		dao.UpdateEntity(db, messageGroupMembers[0], "DeletedAt", "LastOperator")
	} else {
		quitPrice := messageGroup.QuitPrice
		userBill, err := dao.GetUserBill(db, userID, "")
		if err != nil {
			return errCode, err
		}
		if userBill.AccountBalance < quitPrice {
			return model.ErrCodeAccountBalanceNotEnough, fmt.Errorf("用户余额不足，请充值！")
		}
		dao.Begin(db)
		defer func() {
			if r := recover(); r != nil {
				dao.Rollback(db)
				panic(r)
			}
		}()
		//账户支出明细
		//1、账户支出增加一条记录
		if err = financial.AddBillExpend(db, userBill.BillID, model.BillTypeQuitGroup, quitPrice); err != nil {
			dao.Rollback(db)
		}
		//2、账户表余额减少相应值
		userBill.AccountBalance -= quitPrice
		if _, err = dao.UpdateEntity(db, userBill, "AccountBalance"); err != nil {
			dao.Rollback(db)
		}
		dao.Commit(db)
	}
	return errCode, err
}