package dao

import (
	"strings"
	"time"

	"git.rosy.net.cn/baseapi/utils"

	"git.rosy.net.cn/jx-callback/business/model"
)

type OperateEventExt struct {
	model.OperateEvent
	Detail []*model.OperateEventDetail `json:"detail"`
	Name   string                      `json:"name"`
}

func DeleteOperateEventDetail(db *DaoDB, deleteTime time.Time) (err error) {
	sql := `
	DELETE FROM a 
	USING operate_event_detail a,operate_event b 
	WHERE a.access_uuid = b.access_uuid
	AND b.created_at < ?
	`
	sqlParams := []interface{}{
		deleteTime,
	}
	_, err = ExecuteSQL(db, sql, sqlParams...)
	return err
}

func DeleteOperateEvent(db *DaoDB, deleteTime time.Time) (err error) {
	sql := `
	DELETE FROM operate_event 
	WHERE created_at < ?
	`
	sqlParams := []interface{}{
		deleteTime,
	}
	_, err = ExecuteSQL(db, sql, sqlParams...)
	return err
}

func GetOperateEvents(db *DaoDB, name string, apiFunctions []string, operateTypes, skuIDs, storeIDs []int, fromTime, toTime time.Time, keyword string, errType, offset, pageSize int) (operateEventExt []*OperateEventExt, totalCount int, err error) {
	sql := `
		SELECT SQL_CALC_FOUND_ROWS DISTINCT a.*, c.name 
		  FROM operate_event a
	`
	if len(operateTypes) > 0 || len(skuIDs) > 0 || len(storeIDs) > 0 || keyword != "" {
		sql += " LEFT JOIN operate_event_detail b ON a.access_uuid = b.access_uuid"
	}
	sql += `
		  LEFT JOIN user c ON c.user_id = a.user_id
		  WHERE 1=1
	`
	sqlParams := []interface{}{}
	if errType == 1 {
		sql += " AND a.err_msg = ''"
	}
	if errType == -1 {
		sql += " AND a.err_msg <> ''"
	}
	if name != "" {
		sql += " AND c.name LIKE ?"
		sqlParams = append(sqlParams, "%"+name+"%")
	}
	if !utils.IsTimeZero(fromTime) {
		sql += " AND a.created_at >= ?"
		sqlParams = append(sqlParams, fromTime)
	}
	if !utils.IsTimeZero(toTime) {
		sql += " AND a.created_at <= ?"
		sqlParams = append(sqlParams, toTime)
	}
	if len(apiFunctions) > 0 {
		sql += " AND a.api_function IN (" + GenQuestionMarks(len(apiFunctions)) + ")"
		sqlParams = append(sqlParams, apiFunctions)
	}
	if len(operateTypes) > 0 {
		sql += " AND b.operate_type IN (" + GenQuestionMarks(len(operateTypes)) + ")"
		sqlParams = append(sqlParams, operateTypes)
	}
	if len(skuIDs) > 0 {
		sql += " AND b.thing_id IN (" + GenQuestionMarks(len(skuIDs)) + ")"
		sqlParams = append(sqlParams, skuIDs)
	}
	if len(storeIDs) > 0 {
		sql += " AND b.store_id IN (" + GenQuestionMarks(len(storeIDs)) + ")"
		sqlParams = append(sqlParams, storeIDs)
	}
	if keyword != "" {
		sql += " AND ("
		var apiList []string
		for k, v := range model.ApiFunctionName {
			if strings.Contains(v, keyword) {
				apiList = append(apiList, k)
			}
		}
		if len(apiList) > 0 {
			sql += "a.api_function IN (" + GenQuestionMarks(len(apiList)) + ") OR"
			sqlParams = append(sqlParams, apiList)
		}
		sql += " a.err_msg LIKE ? OR b.thing_id LIKE ? OR b.store_id LIKE ? OR c.name LIKE ? OR a.user_id LIKE ?)"
		sqlParams = append(sqlParams, "%"+keyword+"%", "%"+keyword+"%", "%"+keyword+"%", "%"+keyword+"%", "%"+keyword+"%")
	}
	sql += ` 
	ORDER BY a.created_at DESC
	LIMIT ? OFFSET ?
	`
	sqlParams = append(sqlParams, pageSize, offset)
	txDB, _ := Begin(db)
	defer Commit(db, txDB)
	if err = GetRowsTx(txDB, &operateEventExt, sql, sqlParams...); err == nil {
		totalCount = GetLastTotalRowCountTx(txDB)
	}
	var (
		accessUUidList []string
		details        []*model.OperateEventDetail
		detailMap      = make(map[string][]*model.OperateEventDetail)
	)
	for _, v := range operateEventExt {
		accessUUidList = append(accessUUidList, v.AccessUUID)
	}
	if len(accessUUidList) == 0 {
		return operateEventExt, totalCount, err
	}
	sql2 := `
			SELECT * 
			  FROM operate_event_detail
			 WHERE access_uuid IN (` + GenQuestionMarks(len(accessUUidList)) + `)
		`
	sqlParams2 := []interface{}{accessUUidList}
	err = GetRows(db, &details, sql2, sqlParams2...)
	for _, v := range details {
		detailMap[v.AccessUUID] = append(detailMap[v.AccessUUID], v)
	}
	for _, v := range operateEventExt {
		if detailMap[v.AccessUUID] != nil {
			v.Detail = detailMap[v.AccessUUID]
		}
	}
	return operateEventExt, totalCount, err
}

type GetMessageGroupsResult struct {
	model.MessageGroup
	Avatar              string                          `json:"avatar"`
	LastMessageType     int                             `json:"lastMessageType"`
	LastContent         string                          `json:"lastContent"`
	LastTime            time.Time                       `json:"lastTime"`
	LastUserName        string                          `json:"lastUserName"`
	UserName            string                          `json:"userName"`
	UnReadMessageCount  int                             `json:"unReadMessageCount"`
	MessageGroupMembers []*GetMessageGroupsMemberResult `json:"messageGroupMembers"`
}

type GetMessageGroupsMemberResult struct {
	model.User
	model.MessageGroupMember
}

func GetMessageGroups(db *DaoDB, userID string, groupID, groupType int, isMember bool, userID2 string) (messageGroupsResult []*GetMessageGroupsResult, err error) {
	sql := `
		SELECT a.*, b.name user_name, b.avatar
		  FROM message_group a
		  LEFT JOIN user b ON b.user_id = a.user_id
		 WHERE a.deleted_at = ?  
	`
	sqlParams := []interface{}{utils.DefaultTimeValue}
	if userID != "" {
		sql += " AND a.user_id = ?"
		sqlParams = append(sqlParams, userID)
	}
	if groupType != 0 {
		sql += " AND a.type = ?"
		sqlParams = append(sqlParams, groupType)
	}
	if groupID != 0 {
		sql += " AND a.group_id LIKE ?"
		sqlParams = append(sqlParams, utils.Int2Str(groupID)+"%")
	}
	if err = GetRows(db, &messageGroupsResult, sql, sqlParams); err == nil {
		if isMember {
			for _, v := range messageGroupsResult {
				var messageGroupMembers []*GetMessageGroupsMemberResult
				sql2 := `
					SELECT a.*, b.* 
					  FROM message_group_member a 
				 LEFT JOIN user b ON b.user_id = a.member_user_id
					 WHERE a.group_id = ?
					   AND a.deleted_at = ?
				`
				sqlParams2 := []interface{}{v.GroupID, utils.DefaultTimeValue}
				if userID2 != "" {
					sql2 += ` AND member_user_id = ?`
					sqlParams2 = append(sqlParams2, userID2)
				}
				if err = GetRows(db, &messageGroupMembers, sql2, sqlParams2); err == nil {
					v.MessageGroupMembers = messageGroupMembers
				}
			}
		}
	}
	return messageGroupsResult, err
}

func GetMessageGroupMembers(db *DaoDB, groupID, groupType int, memberUserID string) (messageGroupMembers []*model.MessageGroupMember, err error) {
	sqlParams := []interface{}{}
	sql := `
		SELECT a.* 
		  FROM message_group_member a
	`
	if groupType != 0 {
		sql += ` JOIN message_group b ON b.group_id = a.group_id AND b.type = ? AND b.deleted_at = ?`
		sqlParams = append(sqlParams, groupType, utils.DefaultTimeValue)
	}
	sql += `
		 WHERE a.deleted_at = ?  
	`
	sqlParams = append(sqlParams, utils.DefaultTimeValue)
	if groupID != 0 {
		sql += " AND a.group_id = ?"
		sqlParams = append(sqlParams, groupID)
	}
	if memberUserID != "" {
		sql += " AND a.member_user_id = ?"
		sqlParams = append(sqlParams, memberUserID)
	}
	err = GetRows(db, &messageGroupMembers, sql, sqlParams)
	return messageGroupMembers, err
}

//得到某个用户所在所有群组
func GetUserMessageGroups(db *DaoDB, userID string) (messageGroup []*model.MessageGroup, err error) {
	sql := `
		SELECT group_id
		  FROM message_group
		 WHERE deleted_at = ? AND user_id = ?
		 UNION 
		SELECT group_id  
		  FROM message_group_member
		 WHERE deleted_at = ? AND member_user_id = ?  
	`
	sqlParams := []interface{}{
		utils.DefaultTimeValue, userID,
		utils.DefaultTimeValue, userID,
	}
	err = GetRows(db, &messageGroup, sql, sqlParams)
	messageGroup = append(messageGroup, &model.MessageGroup{
		GroupID: model.SysGroupID,
	})
	return messageGroup, err
}

func GetMessageGroupRead(db *DaoDB, userID string, groupID int) (messageGroupReads []*model.MessageGroupRead, err error) {
	sql := `
		SELECT * 
		  FROM message_group_read a 
		 WHERE 1 = 1
	`
	sqlParams := []interface{}{}
	if userID != "" {
		sql += ` AND a.user_id = ?`
		sqlParams = append(sqlParams, userID)
	}
	if groupID != 0 {
		sql += ` AND a.group_id = ?`
		sqlParams = append(sqlParams, groupID)
	}
	err = GetRows(db, &messageGroupReads, sql, sqlParams...)
	return messageGroupReads, err
}