package handler

import (
	"fmt"
	"github.com/rabbitmq/amqp091-go"
	"samba/pkg/log"
	"samba/pkg/servername"
	"samba/proto"
	"samba/util/model"
	"samba/util/routingKey"
	"samba/util/util"
)

func fillClubMainPageInfo(uid int64, rsp *proto.RspClubMainPage, clubInfo *model.ClubInfo, userClubInfo *model.UserClubInfo) {
	rsp.MainPageInfo.ClubId = clubInfo.ID
	rsp.MainPageInfo.Name = clubInfo.Name
	//rsp.MainPageInfo.Coin = clubInfo.Coin
	rsp.MainPageInfo.Score = userClubInfo.Score + userClubInfo.FreeScore + userClubInfo.InOutFreeScore
	rsp.MainPageInfo.PrettyNo = clubInfo.PrettyNo
	rsp.MainPageInfo.Creator = clubInfo.CreatorName
	rsp.MainPageInfo.IconId = clubInfo.IconId
	rsp.MainPageInfo.HeadUrl = clubInfo.HeadUrl
	rsp.MainPageInfo.Level = clubInfo.Level
	rsp.MainPageInfo.UserScore = clubInfo.UserScore

	rsp.MainPageInfo.JobTitle = userClubInfo.Admin

	if uid != clubInfo.Creator {
		rsp.MainPageInfo.Coin = 0
	} else {
		clubCoin, _ := model.NewUserResourceOp().Get(uid, model.ResClubCoins)
		rsp.MainPageInfo.Coin = clubCoin
	}
}

func fillClubPlayingRoom(playingRoom *model.ClubPlayingRoom) *proto.ClubPlayingRoom {
	return &proto.ClubPlayingRoom{
		RoomId:        playingRoom.RoomId,
		RoomType:      playingRoom.RoomType,
		PlayType:      playingRoom.PlayType,
		Blind:         playingRoom.Blind,
		CurrPlayerNum: playingRoom.CurrPlayerNum,
		MaxPlayerNum:  playingRoom.MaxPlayerNum,
		Status:        playingRoom.Status,
		MaxGameNum:    playingRoom.MaxGameNum,
		Top:           playingRoom.Top,
	}
}

// 俱乐部在线房间刷新
func onClubPlayingRooms(_ *amqp091.Delivery, msg map[string]interface{}) {
	_, _, uid, data := ParseMsg(msg)
	req, err := util.MapToStructT[proto.ReqClubPlayingRooms](data)
	if err != nil {
		log.Error(err.Error())
		return
	}

	rsp := &proto.RspClubPlayingRooms{Code: proto.Ok, ClubId: req.ClubId}
	playingRooms, err := model.NewClubPlayingRoomOp().LoadAll(req.ClubId)
	if err != nil {
		log.Error(err.Error())
		SendMsgToGate(uid, proto.RspClubPlayingRoomsId, &proto.RspClubPlayingRooms{Code: proto.Internal})
		return
	}

	for _, rm := range playingRooms {
		rsp.Rooms = append(rsp.Rooms, fillClubPlayingRoom(rm))
	}
	//for _, rm := range rsp.Rooms {
	//	log.Debug(fmt.Sprintf("RspClubPlayingRoomsId:%#v", rm))
	//}
	//b, _ := json.Marshal(rsp)
	//log.Debug(fmt.Sprintf("RspClubPlayingRoomsId:%#v", string(b)))

	SendMsgToGate(uid, proto.RspClubPlayingRoomsId, rsp)
}

// 俱乐部主页
func onClubMainPage(_ *amqp091.Delivery, msg map[string]interface{}) {
	_, _, uid, data := ParseMsg(msg)
	req, err := util.MapToStructT[proto.ReqClubMainPage](data)
	if err != nil {
		log.Error(err.Error())
		return
	}
	clubInfo, err := model.NewClubInfoOp().Load(req.ClubId)
	if err != nil {
		log.Error(err.Error())
		SendMsgToGate(uid, proto.RspClubMainPageId, &proto.RspClubMainPage{Code: proto.ClubNotExist})
		return
	}
	if lv := model.NewClubLevelOp().GetLevel(clubInfo); lv != nil {
		clubInfo.Level = lv.Level
	}
	userClubInfo, err := model.NewUserClubInfoOp().Load(uid, req.ClubId)
	if err != nil {
		log.Error(err.Error())
		SendMsgToGate(uid, proto.RspClubMainPageId, &proto.RspClubMainPage{Code: proto.NotInClub})
		return
	}
	perms := model.NewClubPermissionsOp().Load(req.ClubId)
	rsp := &proto.RspClubMainPage{Code: proto.Ok, Rooms: nil, MainPageInfo: proto.ClubMainPageInfo{}, Permissions: perms}
	fillClubMainPageInfo(uid, rsp, clubInfo, userClubInfo)

	playingRooms, err := model.NewClubPlayingRoomOp().LoadAll(req.ClubId)
	if err != nil {
		log.Error(err.Error())
		SendMsgToGate(uid, proto.RspClubMainPageId, &proto.RspClubMainPage{Code: proto.NotClubPlayGame})
		return
	}

	for _, rm := range playingRooms {
		rsp.Rooms = append(rsp.Rooms, fillClubPlayingRoom(rm))
	}
	SendMsgToGate(uid, proto.RspClubMainPageId, rsp)
}

func checkCreatePlayGame(userId int64, req *proto.ReqCreatePlayGame) proto.ErrorCode {
	if !checkCreatePermissions(userId, req.ClubId) {
		return proto.BadParam
	}
	if req.GameInfo.Blind < 1 || req.GameInfo.PlayerNum < 2 {
		return proto.BadParam
	}
	return proto.Ok
}

// 俱乐部创建玩法
func onCreatePlayGame(_ *amqp091.Delivery, msg map[string]interface{}) {
	_, _, uid, data := ParseMsg(msg)
	req, err := util.MapToStructT[proto.ReqCreatePlayGame](data)
	if err != nil {
		log.Error(err.Error())
		return
	}
	if code := checkCreatePlayGame(uid, req); code != proto.Ok {
		SendMsgToGate(uid, proto.RspCreatePlayGameId, &proto.RspCreatePlayGame{Code: proto.BadParam})
		return
	}
	rsp := &proto.RspCreatePlayGame{Code: proto.Ok}
	playInfo := &model.ClubPlayInfo{
		ID:        0,
		ClubId:    req.ClubId,
		Name:      req.GameInfo.Name,
		PlayType:  req.GameInfo.PlayType,
		Blind:     req.GameInfo.Blind,
		PlayerNum: req.GameInfo.PlayerNum,
		GameNum:   req.GameInfo.GameNum,
		Fee:       req.GameInfo.Fee,
		State:     1,
		IsValid:   1,
		Top:       req.GameInfo.Top,
	}
	playInfos, _ := model.NewClubPlayInfoOp().Load(req.ClubId)
	exist := false
	if len(playInfos) != 0 {
		for _, pi := range playInfos {
			if pi.PlayType == playInfo.PlayType && pi.Blind == playInfo.Blind && pi.PlayerNum == playInfo.PlayerNum &&
				pi.Fee == playInfo.Fee && pi.GameNum == playInfo.GameNum {
				exist = true
				break
			}
		}
	}
	if exist {
		rsp.Code = proto.ExistClubPlayGame
		SendMsgToGate(uid, proto.RspCreatePlayGameId, rsp)
		return
	}
	err = model.NewClubPlayInfoOp().Create(playInfo)

	if err != nil {
		rsp.Code = proto.BadParam
		SendMsgToGate(uid, proto.RspCreatePlayGameId, rsp)
		return
	}
	rsp.ClubId = req.ClubId
	rsp.GameInfo = req.GameInfo
	rsp.GameInfo.Id = playInfo.ID
	rsp.GameInfo.Blind = req.GameInfo.Blind
	rsp.GameInfo.Valid = playInfo.IsValid
	SendMsgToGate(uid, proto.RspCreatePlayGameId, rsp)
	if rsp.Code == proto.Ok {
		// 广播创建玩法
		SendMsg(util.Topic(servername.Club), routingKey.CreateClubPlayType, 0, proto.RspCreatePlayGameId, rsp)
	}
}

// 俱乐部获取所有玩法
func onGetPlayGames(_ *amqp091.Delivery, msg map[string]interface{}) {
	_, _, uid, data := ParseMsg(msg)
	req, err := util.MapToStructT[proto.ReqGetPlayGames](data)
	if err != nil {
		log.Error(err.Error())
		return
	}
	if !checkPermissions(uid, req.ClubId) {
		SendMsgToGate(uid, proto.RspGetPlayGamesId, &proto.RspGetPlayGames{Code: proto.BadParam})
		return
	}
	rsp := &proto.RspGetPlayGames{Code: proto.Ok}
	playInfos, err := model.NewClubPlayInfoOp().Load(req.ClubId)
	if err != nil {
		SendMsgToGate(uid, proto.RspGetPlayGamesId, rsp)
		return
	}
	for _, info := range playInfos {
		rsp.GameInfo = append(rsp.GameInfo, proto.ClubPlayGameInfo{
			Id:        info.ID,
			Name:      info.Name,
			PlayType:  info.PlayType,
			Blind:     info.Blind,
			PlayerNum: info.PlayerNum,
			GameNum:   info.GameNum,
			Fee:       info.Fee,
			Valid:     info.IsValid,
			Top:       info.Top,
		})
	}
	log.Debug(fmt.Sprintf("%#v", rsp))
	SendMsgToGate(uid, proto.RspGetPlayGamesId, rsp)
}

func checkPermissions(userId int64, clubId int) bool {
	userClubInfo, err := model.NewUserClubInfoOp().Load(userId, clubId)
	if err != nil {
		log.Error(err.Error())
		return false
	}
	if userClubInfo.Admin == 1 {
		return true
	}
	if userClubInfo.Admin == 2 {
		return true
	}
	return false
}

// 检查创建玩法的权限
func checkCreatePermissions(userId int64, clubId int) bool {
	userClubInfo, err := model.NewUserClubInfoOp().Load(userId, clubId)
	if err != nil {
		log.Error(err.Error())
		return false
	}
	if userClubInfo.Admin == 1 {
		return true
	}
	if userClubInfo.Admin != 2 {
		return false
	}
	perms := model.NewClubPermissionsOp().Load(clubId)
	for _, pi := range perms {
		if pi == 1001 {
			return true
		}
	}
	return false
}

// 俱乐部修改玩法
func onUpdatePlayGame(_ *amqp091.Delivery, msg map[string]interface{}) {
	_, _, uid, data := ParseMsg(msg)
	req, err := util.MapToStructT[proto.ReqUpdatePlayGame](data)
	if err != nil {
		log.Error(err.Error())
		return
	}
	if !checkCreatePermissions(uid, req.ClubId) {
		SendMsgToGate(uid, proto.RspUpdatePlayGameId, &proto.RspUpdatePlayGame{Code: proto.BadParam})
		return
	}
	playInfo := &model.ClubPlayInfo{
		ID:        req.GameInfo.Id,
		ClubId:    req.ClubId,
		Name:      req.GameInfo.Name,
		PlayType:  req.GameInfo.PlayType,
		Blind:     req.GameInfo.Blind,
		PlayerNum: req.GameInfo.PlayerNum,
		GameNum:   req.GameInfo.GameNum,
		Fee:       req.GameInfo.Fee,
		State:     1,
		IsValid:   req.GameInfo.Valid,
		Top:       req.GameInfo.Top,
	}
	playInfos, _ := model.NewClubPlayInfoOp().Load(req.ClubId)
	exist := false
	if len(playInfos) != 0 {
		for _, pi := range playInfos {
			if pi.PlayType == playInfo.PlayType && pi.Blind == playInfo.Blind && pi.PlayerNum == playInfo.PlayerNum &&
				pi.Fee == playInfo.Fee && pi.GameNum == playInfo.GameNum {
				exist = true
				break
			}
		}
	}
	rsp := &proto.RspUpdatePlayGame{Code: proto.Ok}
	if exist {
		rsp.Code = proto.ExistClubPlayGame
		SendMsgToGate(uid, proto.RspUpdatePlayGameId, rsp)
		return
	}
	err = model.NewClubPlayInfoOp().Update(playInfo)

	if err != nil {
		rsp.Code = proto.BadParam
		SendMsgToGate(uid, proto.RspUpdatePlayGameId, rsp)
		return
	}
	rsp.ClubId = req.ClubId
	rsp.SrcGameId = req.GameInfo.Id
	rsp.GameInfo = req.GameInfo
	rsp.GameInfo.Id = playInfo.ID
	rsp.GameInfo.Valid = req.GameInfo.Valid
	rsp.GameInfo.Blind = req.GameInfo.Blind
	SendMsgToGate(uid, proto.RspUpdatePlayGameId, rsp)
	if rsp.Code == proto.Ok {
		// 广播创建玩法
		SendMsg(util.Topic(servername.Club), routingKey.CreateClubPlayType, 0, proto.RspUpdatePlayGameId, rsp)
	}
}

// 俱乐部删除玩法
func onDeletePlayGame(_ *amqp091.Delivery, msg map[string]interface{}) {
	_, _, uid, data := ParseMsg(msg)
	req, err := util.MapToStructT[proto.ReqDeletePlayGame](data)
	if err != nil {
		log.Error(err.Error())
		return
	}
	if !checkCreatePermissions(uid, req.ClubId) {
		SendMsgToGate(uid, proto.RspDeletePlayGameId, &proto.RspDeletePlayGame{Code: proto.BadParam})
		return
	}
	playInfo := &model.ClubPlayInfo{
		ID:     req.PlayGameId,
		ClubId: req.ClubId,
	}
	err = model.NewClubPlayInfoOp().Delete(playInfo)
	rsp := &proto.RspDeletePlayGame{Code: proto.Ok}
	if err != nil {
		rsp.Code = proto.BadParam
		SendMsgToGate(uid, proto.RspDeletePlayGameId, rsp)
		return
	}
	rsp.PlayGameId = req.PlayGameId
	rsp.ClubId = req.ClubId
	SendMsgToGate(uid, proto.RspDeletePlayGameId, rsp)
	if rsp.Code == proto.Ok {
		// 广播创建玩法
		SendMsg(util.Topic(servername.Club), routingKey.CreateClubPlayType, 0, proto.RspDeletePlayGameId, rsp)
	}
}

// 俱乐部设置无效
func onSetPlayGameValid(_ *amqp091.Delivery, msg map[string]interface{}) {
	_, _, uid, data := ParseMsg(msg)
	req, err := util.MapToStructT[proto.ReqSetPlayGameValid](data)
	if err != nil {
		log.Error(err.Error())
		return
	}
	rsp := &proto.RspSetPlayGameValid{Code: proto.BadParam, PlayGameId: req.PlayGameId, Valid: req.Valid, ClubId: req.ClubId}
	if !checkCreatePermissions(uid, req.ClubId) {
		SendMsgToGate(uid, proto.RspSetPlayGameValidId, rsp)
		return
	}
	playInfo := model.NewClubPlayInfoOp().LoadAPlayInfo(req.ClubId, req.PlayGameId)
	if playInfo == nil {
		SendMsgToGate(uid, proto.RspSetPlayGameValidId, rsp)
		return
	}
	broadcast := false
	if playInfo.IsValid != req.Valid {
		playInfo.IsValid = req.Valid
		err = model.NewClubPlayInfoOp().SetValid(playInfo)
		if err != nil {
			SendMsgToGate(uid, proto.RspSetPlayGameValidId, rsp)
			return
		}
		broadcast = true
	}

	rsp.Code = proto.Ok
	SendMsgToGate(uid, proto.RspSetPlayGameValidId, rsp)
	if broadcast {
		// 广播创建玩法
		SendMsg(util.Topic(servername.Club), routingKey.CreateClubPlayType, 0, proto.RspSetPlayGameValidId, rsp)
	}
}

// 俱乐部设置玩法置顶
func onSetPlayGameTop(_ *amqp091.Delivery, msg map[string]interface{}) {
	_, _, uid, data := ParseMsg(msg)
	req, err := util.MapToStructT[proto.ReqSetPlayGameTop](data)
	if err != nil {
		log.Error(err.Error())
		return
	}
	rsp := &proto.RspSetPlayGameTop{Code: proto.BadParam, PlayGameId: req.PlayGameId, Top: req.Top, ClubId: req.ClubId}
	if !checkCreatePermissions(uid, req.ClubId) {
		SendMsgToGate(uid, proto.RspSetPlayGameTopId, rsp)
		return
	}
	playInfo := model.NewClubPlayInfoOp().LoadAPlayInfo(req.ClubId, req.PlayGameId)
	if playInfo == nil {
		SendMsgToGate(uid, proto.RspSetPlayGameTopId, rsp)
		return
	}
	if playInfo.Top != req.Top {
		playInfo.Top = req.Top
		err = model.NewClubPlayInfoOp().SetTop(playInfo)
		if err != nil {
			SendMsgToGate(uid, proto.RspSetPlayGameTopId, rsp)
			return
		}
	}

	rsp.Code = proto.Ok
	SendMsgToGate(uid, proto.RspSetPlayGameTopId, rsp)
}