package handler

import (
	"strconv"
	"strings"

	"github.com/gin-gonic/gin"

	"nl-game-api-gin/internal/database"
	"nl-game-api-gin/internal/middleware"
	"nl-game-api-gin/internal/model"
	"nl-game-api-gin/internal/room"
	"nl-game-api-gin/pkg/resp"
)

// userBrief 用户摘要（好友列表/会话列表/搜索结果通用）
type userBrief struct {
	UserID   int    `json:"user_id"`  // 用户ID
	Username string `json:"username"` // 用户名
	Nickname string `json:"nickname"` // 昵称
	Avatar   string `json:"avatar"`   // emoji 头像
	Online   bool   `json:"online"`   // 是否在线（有活跃 WebSocket 连接）
}

// briefOf 把用户模型转为摘要
func briefOf(u *model.User, online bool) userBrief {
	return userBrief{UserID: u.ID, Username: u.Username, Nickname: u.Nickname, Avatar: u.Avatar, Online: online}
}

// loadBriefs 批量加载用户摘要（自动附带在线状态）
func loadBriefs(ids []int) map[int]userBrief {
	out := map[int]userBrief{}
	if len(ids) == 0 {
		return out
	}
	var users []model.User
	database.DB.Where("id IN ?", ids).Find(&users)
	online := room.OnlineMap(ids)
	for i := range users {
		u := &users[i]
		out[u.ID] = briefOf(u, online[u.ID])
	}
	return out
}

// isFriend 两人是否已互为好友（任一方向的已通过记录）
func isFriend(a, b int) bool {
	var cnt int64
	database.DB.Model(&model.Friend{}).
		Where("status = ? AND ((user_id = ? AND friend_id = ?) OR (user_id = ? AND friend_id = ?))",
			model.FriendStatusAccepted, a, b, b, a).
		Count(&cnt)
	return cnt > 0
}

// FriendList 我的好友列表（在线的排在前面）
func FriendList(c *gin.Context) {
	uid := middleware.UID(c)
	var rels []model.Friend
	database.DB.Where("status = ? AND (user_id = ? OR friend_id = ?)", model.FriendStatusAccepted, uid, uid).
		Order("updated_at DESC").Find(&rels)
	ids := make([]int, 0, len(rels))
	sinceMap := map[int]int64{}
	for _, r := range rels {
		peer := r.UserID
		if peer == uid {
			peer = r.FriendID
		}
		ids = append(ids, peer)
		sinceMap[peer] = r.UpdatedAt
	}
	briefs := loadBriefs(ids)
	type friendItem struct {
		userBrief
		Since int64 `json:"since"` // 成为好友时间
	}
	list := make([]friendItem, 0, len(ids))
	for _, id := range ids {
		if b, ok := briefs[id]; ok {
			list = append(list, friendItem{userBrief: b, Since: sinceMap[id]})
		}
	}
	// 在线的排前面（保持各自原有相对顺序）
	sorted := make([]friendItem, 0, len(list))
	for _, it := range list {
		if it.Online {
			sorted = append(sorted, it)
		}
	}
	for _, it := range list {
		if !it.Online {
			sorted = append(sorted, it)
		}
	}
	resp.OK(c, sorted)
}

// FriendRequests 好友申请：received=发给我的待处理申请，sent=我发出的待验证申请
func FriendRequests(c *gin.Context) {
	uid := middleware.UID(c)
	var in, out []model.Friend
	database.DB.Where("friend_id = ? AND status = ?", uid, model.FriendStatusPending).Order("id DESC").Find(&in)
	database.DB.Where("user_id = ? AND status = ?", uid, model.FriendStatusPending).Order("id DESC").Find(&out)
	ids := make([]int, 0, len(in)+len(out))
	for _, r := range in {
		ids = append(ids, r.UserID)
	}
	for _, r := range out {
		ids = append(ids, r.FriendID)
	}
	briefs := loadBriefs(ids)
	type reqItem struct {
		ID   int       `json:"id"`   // 关系ID（同意/拒绝时用）
		User userBrief `json:"user"` // 对方信息
		At   int64     `json:"at"`   // 申请时间
	}
	received := make([]reqItem, 0, len(in))
	for _, r := range in {
		received = append(received, reqItem{ID: r.ID, User: briefs[r.UserID], At: r.CreatedAt})
	}
	sent := make([]reqItem, 0, len(out))
	for _, r := range out {
		sent = append(sent, reqItem{ID: r.ID, User: briefs[r.FriendID], At: r.CreatedAt})
	}
	resp.OK(c, gin.H{"received": received, "sent": sent})
}

// FriendSearch 按用户名/昵称搜索用户（加好友入口），附带与我的关系状态
func FriendSearch(c *gin.Context) {
	uid := middleware.UID(c)
	kw := strings.TrimSpace(c.Query("keyword"))
	if kw == "" {
		resp.OK(c, []any{})
		return
	}
	like := "%" + kw + "%"
	var users []model.User
	database.DB.Where("id != ? AND status = ? AND (username LIKE ? OR nickname LIKE ?)",
		uid, model.UserStatusNormal, like, like).Limit(10).Find(&users)
	ids := make([]int, 0, len(users))
	for _, u := range users {
		ids = append(ids, u.ID)
	}
	online := room.OnlineMap(ids)
	// 一次取出我与这批用户的全部关系，标注状态
	var rels []model.Friend
	if len(ids) > 0 {
		database.DB.Where("(user_id = ? AND friend_id IN ?) OR (friend_id = ? AND user_id IN ?)", uid, ids, uid, ids).Find(&rels)
	}
	// relation: none=无关系 friend=已是好友 pending_out=我已申请 pending_in=对方已申请我
	relMap := map[int]string{}
	for _, r := range rels {
		peer := r.UserID
		dir := "pending_in"
		if r.UserID == uid {
			peer = r.FriendID
			dir = "pending_out"
		}
		if r.Status == model.FriendStatusAccepted {
			relMap[peer] = "friend"
		} else if relMap[peer] != "friend" {
			relMap[peer] = dir
		}
	}
	type searchItem struct {
		userBrief
		Relation string `json:"relation"` // none/friend/pending_out/pending_in
	}
	list := make([]searchItem, 0, len(users))
	for i := range users {
		u := &users[i]
		rel := relMap[u.ID]
		if rel == "" {
			rel = "none"
		}
		list = append(list, searchItem{userBrief: briefOf(u, online[u.ID]), Relation: rel})
	}
	resp.OK(c, list)
}

// friendReqBody 发起好友申请请求体
type friendReqBody struct {
	UserID int `json:"user_id" binding:"required"` // 要添加的用户ID
}

// FriendRequest 发起好友申请：对方在线时实时推送；若对方已申请过我则直接成为好友
func FriendRequest(c *gin.Context) {
	uid := middleware.UID(c)
	var req friendReqBody
	if err := c.ShouldBindJSON(&req); err != nil || req.UserID == uid {
		resp.Fail(c, "参数有误")
		return
	}
	var target model.User
	if err := database.DB.First(&target, req.UserID).Error; err != nil || target.Status != model.UserStatusNormal {
		resp.Fail(c, "用户不存在")
		return
	}
	var me model.User
	database.DB.First(&me, uid)
	// 已有关系判断（两个方向）
	var exist model.Friend
	if err := database.DB.Where("user_id = ? AND friend_id = ?", uid, req.UserID).First(&exist).Error; err == nil {
		if exist.Status == model.FriendStatusAccepted {
			resp.Fail(c, "你们已经是好友了")
		} else {
			resp.Fail(c, "已发送过申请，等待对方同意")
		}
		return
	}
	var reverse model.Friend
	if err := database.DB.Where("user_id = ? AND friend_id = ?", req.UserID, uid).First(&reverse).Error; err == nil {
		if reverse.Status == model.FriendStatusAccepted {
			resp.Fail(c, "你们已经是好友了")
			return
		}
		// 对方已申请过我：视为互相想加，直接通过
		database.DB.Model(&reverse).Update("status", model.FriendStatusAccepted)
		room.PushToUser(req.UserID, "friend_event", gin.H{"kind": "accept", "user": briefOf(&me, true)})
		resp.OK(c, gin.H{"relation": "friend", "msg": "对方也申请过你，已直接成为好友"})
		return
	}
	rel := model.Friend{UserID: uid, FriendID: req.UserID, Status: model.FriendStatusPending}
	if err := database.DB.Create(&rel).Error; err != nil {
		resp.Fail(c, "申请失败，请稍后重试")
		return
	}
	// 对方在线则实时提醒
	room.PushToUser(req.UserID, "friend_event", gin.H{"kind": "request", "user": briefOf(&me, true)})
	resp.OK(c, gin.H{"relation": "pending_out"})
}

// friendRespondBody 处理好友申请请求体
type friendRespondBody struct {
	ID     int  `json:"id" binding:"required"` // 关系ID（来自申请列表）
	Accept bool `json:"accept"`                // true=同意 false=拒绝
}

// FriendRespond 同意/拒绝好友申请（同意后通知申请人）
func FriendRespond(c *gin.Context) {
	uid := middleware.UID(c)
	var req friendRespondBody
	if err := c.ShouldBindJSON(&req); err != nil {
		resp.Fail(c, "参数有误")
		return
	}
	var rel model.Friend
	if err := database.DB.First(&rel, req.ID).Error; err != nil || rel.FriendID != uid || rel.Status != model.FriendStatusPending {
		resp.Fail(c, "申请不存在或已处理")
		return
	}
	if !req.Accept {
		database.DB.Delete(&rel)
		resp.OK(c, gin.H{"relation": "none"})
		return
	}
	database.DB.Model(&rel).Update("status", model.FriendStatusAccepted)
	var me model.User
	database.DB.First(&me, uid)
	room.PushToUser(rel.UserID, "friend_event", gin.H{"kind": "accept", "user": briefOf(&me, true)})
	resp.OK(c, gin.H{"relation": "friend"})
}

// FriendDelete 删除好友（清除双方全部关系记录，聊天记录保留）
func FriendDelete(c *gin.Context) {
	uid := middleware.UID(c)
	peer, _ := strconv.Atoi(c.Param("uid"))
	if peer <= 0 {
		resp.Fail(c, "参数有误")
		return
	}
	database.DB.Where("(user_id = ? AND friend_id = ?) OR (user_id = ? AND friend_id = ?)", uid, peer, peer, uid).
		Delete(&model.Friend{})
	resp.OK(c, nil)
}