package dao

import (
	"gorm.io/gorm"
	"videoplayer/proto"
)

type Message struct {
	gorm.Model
	FromUserID int    `gorm:"column:from_user_id"`
	ToUserID   int    `gorm:"column:to_user_id"`
	GroupID    int    `gorm:"column:group_id"`
	Msg        string `gorm:"column:msg"`
	Status     int    `gorm:"column:status"` //单聊时才有0,已读，2未读
	Type       int    `gorm:"column:type"`   //1为单聊，2为群聊，3为系统消息,4为好友请求,5为加入群聊请求
}

type Group struct {
	gorm.Model
	GroupName string `gorm:"column:group_name"`
	GroupInfo string `gorm:"column:group_info"`
	GroupType int    `gorm:"column:group_type"`
	GroupIcon string `gorm:"column:group_icon"`
}

type GroupUser struct {
	gorm.Model
	GroupID  int  `gorm:"column:group_id"`
	UserID   int  `gorm:"column:user_id"`
	IsMaster bool `gorm:"column:is_master"`
}

type Friend struct {
	gorm.Model
	UserID   int `gorm:"column:user_id"`
	FriendID int `gorm:"column:friend_id"`
}

// 创建单聊消息
func CreateSimpleMessage(from_user_id, to_user_id int, message string) (error, uint) {
	msg := Message{FromUserID: from_user_id, ToUserID: to_user_id, Msg: message, Type: proto.MSG_TYPE_SIMPLE, Status: proto.MSG_STATUS_UNREAD}
	res := DB.Debug().Create(&msg)
	return res.Error, msg.ID
}

func CreateGeneralMessage(from_user_id, to_user_id, msg_type, status, group_id int, message string) (error error, id uint) {
	msg := Message{FromUserID: from_user_id, ToUserID: to_user_id, Msg: message, Type: msg_type, Status: status, GroupID: group_id}
	res := DB.Debug().Create(&msg)
	return res.Error, msg.ID
}

// 每20个消息一组，请求index*20
func GetMsgUserByIndex(from_user_id, to_user_id, msg_type, index, status int) ([]Message, error) {
	var msgs []Message
	var res *gorm.DB
	if msg_type == 4 {
		res = DB.Debug().Where("from_user_id = ? and to_user_id = ? and type = ? and status = ? ", from_user_id, to_user_id, msg_type, status).Find(&msgs).Order("created_at DESC").Limit(20 * index)
	} else if msg_type == 1 {
		//单聊,只有两个人的消息
		res = DB.Debug().Where("((from_user_id = ? and to_user_id = ?) or (from_user_id = ? and to_user_id = ?)) and type = ? ", from_user_id, to_user_id, to_user_id, from_user_id, msg_type).Find(&msgs).Order("created_at DESC").Limit(20 * index)
	} else {
		res = DB.Debug().Where("from_user_id = ? and to_user_id = ? and type = ? ", from_user_id, to_user_id, msg_type).Find(&msgs).Order("created_at DESC").Limit(20 * index)
	}
	return msgs, res.Error
}

// 获取邀请消息
func GetFriendGroupReq(user_id int) ([]Message, error) {
	var msgs []Message
	res := DB.Debug().Where("to_user_id = ? and type = ?", user_id, proto.MSG_TYPE_FRIEND).Find(&msgs)
	return msgs, res.Error
}

// 修改信息
func UpdateMessage() {

}

// 添加好友
func AddFriend(user_id, friend_id int) error {
	friend := Friend{UserID: user_id, FriendID: friend_id}
	friend2 := Friend{UserID: friend_id, FriendID: user_id}

	//开启事务
	tx := DB.Begin()
	if err := tx.Create(&friend); err.Error != nil {
		tx.Rollback()
		return err.Error
	}
	if err := tx.Create(&friend2); err.Error != nil {
		tx.Rollback()
		return err.Error
	}
	//提交事务
	if err := tx.Commit().Error; err != nil {
		return err
	}
	return error(nil)
}

// 删除好友,删除后双方都不是好友
func DeleteFriend(user_id, friend_id int) error {
	//开启事务
	tx := DB.Begin()
	if err := tx.Delete(&Friend{}, "user_id = ? and friend_id = ?", user_id, friend_id); err.Error != nil {
		tx.Rollback()
		return err.Error
	}
	if err := tx.Delete(&Friend{}, "user_id = ? and friend_id = ?", friend_id, user_id); err.Error != nil {
		tx.Rollback()
		return err.Error
	}
	//提交事务
	if err := tx.Commit().Error; err != nil {
		return err
	}
	return error(nil)
}

// 通过id查找消息
func FindMessageByID(id uint) []Message {
	var msgs []Message
	DB.Debug().Where("id = ?", id).Find(&msgs)
	return msgs
}

// 更新消息状态
func UpdateMessageStatus(id uint, status int) error {
	res := DB.Debug().Model(&Message{}).Where("id = ?", id).Update("status", status)
	return res.Error
}

// 创建群聊,需要事务
func CreateGroup(groupName, groupInfo, groupType, groupIcon string, user_id int) (error, uint) {
	group := Group{GroupName: groupName, GroupInfo: groupInfo, GroupType: proto.MSG_TYPE_GROUP, GroupIcon: groupIcon}
	//开启事务
	tx := DB.Begin()
	if err := tx.Create(&group); err.Error != nil {
		tx.Rollback()
		return err.Error, 0
	}
	groupUser := GroupUser{GroupID: int(group.ID), UserID: user_id, IsMaster: true}
	if err := tx.Create(&groupUser); err.Error != nil {
		tx.Rollback()
		return err.Error, 0
	}
	//提交事务
	if err := tx.Commit().Error; err != nil {
		return err, 0
	}
	return nil, group.ID
}

// 查找用户是否在群聊
func FindGroupUser(user_id, group_id int) []GroupUser {
	var groupUsers []GroupUser
	DB.Debug().Where("user_id = ? and group_id = ?", user_id, group_id).Find(&groupUsers)
	return groupUsers
}

// 加入群聊
func JoinGroup(group_id, user_id int) error {
	groupUser := GroupUser{GroupID: group_id, UserID: user_id}
	res := DB.Debug().Create(&groupUser)
	return res.Error
}

// 退出群聊
func QuitGroup(group_id, user_id int) error {
	res := DB.Debug().Delete(&GroupUser{}, "group_id = ? and user_id = ?", group_id, user_id)
	return res.Error
}

func FindFriend(from_user_id, to_user_id int) []Friend {
	var friends []Friend
	DB.Debug().Where("user_id = ? and friend_id = ?", from_user_id, to_user_id).Find(&friends)
	return friends
}

type FriendRet struct {
	ID    int    `json:"id"`    //用户id
	Name  string `json:"name"`  //用户名
	Email string `json:"email"` //邮箱
}

func FindFriends(user_id int) []FriendRet {
	var friends []FriendRet
	DB.Debug().Raw("select users.id, users.name, users.email from users join friends on users.id = friends.friend_id where friends.user_id = ?", user_id).Scan(&friends)
	return friends
}

func FindGroups(user_id int) []Group {
	var groups []Group
	DB.Debug().Raw("select groups.* from groups join group_users on groups.id = group_users.group_id where group_users.user_id = ?", user_id).Scan(&groups)
	return groups
}