package services

import (
	"errors"
	"time"

	"github.com/inchstep/server/internal/models"
	"gorm.io/gorm"
)

type SocialService struct {
	db *gorm.DB
}

func NewSocialService(db *gorm.DB) *SocialService {
	return &SocialService{db: db}
}

// SendFriendRequest 发送好友请求
func (s *SocialService) SendFriendRequest(userID, friendID string) error {
	if userID == friendID {
		return errors.New("不能添加自己为好友")
	}
	f := &models.Friend{
		UserID:    userID,
		FriendID:  friendID,
		Status:    "pending",
		CreatedAt: time.Now(),
	}
	return s.db.Create(f).Error
}

// AcceptFriendRequest 接受好友请求
func (s *SocialService) AcceptFriendRequest(userID, friendID string) error {
	return s.db.Model(&models.Friend{}).
		Where("user_id = ? AND friend_id = ?", friendID, userID).
		Update("status", "accepted").Error
}

// RemoveFriend 删除好友
func (s *SocialService) RemoveFriend(userID, friendID string) error {
	return s.db.Where("(user_id = ? AND friend_id = ?) OR (user_id = ? AND friend_id = ?)",
		userID, friendID, friendID, userID).Delete(&models.Friend{}).Error
}

// GetFriends 获取好友列表
func (s *SocialService) GetFriends(userID string) ([]models.User, error) {
	var friendIDs []string
	s.db.Model(&models.Friend{}).Select("friend_id").
		Where("user_id = ? AND status = ?", userID, "accepted").Find(&friendIDs)

	var users []models.User
	if len(friendIDs) > 0 {
		s.db.Where("id IN ?", friendIDs).Find(&users)
	}
	return users, nil
}

// CreatePost 创建动态
func (s *SocialService) CreatePost(post *models.Post) error {
	post.ID = generateID()
	post.CreatedAt = time.Now()
	return s.db.Create(post).Error
}

// GetFeed 获取动态广场
func (s *SocialService) GetFeed(page, pageSize int) ([]models.Post, int64, error) {
	var total int64
	s.db.Model(&models.Post{}).Where("privacy = ?", 1).Count(&total)

	var posts []models.Post
	err := s.db.Where("privacy = ?", 1).Preload("User").
		Order("created_at desc").Offset((page - 1) * pageSize).Limit(pageSize).Find(&posts).Error
	return posts, total, err
}

// LikePost 点赞动态
func (s *SocialService) LikePost(postID string) error {
	return s.db.Model(&models.Post{}).Where("id = ?", postID).
		UpdateColumn("likes", gorm.Expr("likes + ?", 1)).Error
}

// CommentPost 评论动态
func (s *SocialService) CommentPost(postID string) error {
	return s.db.Model(&models.Post{}).Where("id = ?", postID).
		UpdateColumn("comments", gorm.Expr("comments + ?", 1)).Error
}

// CreateGroup 创建小组
func (s *SocialService) CreateGroup(userID string, group *models.Group) error {
	group.ID = generateID()
	group.CreatedBy = userID
	group.CreatedAt = time.Now()
	tx := s.db.Begin()

	if err := tx.Create(group).Error; err != nil {
		tx.Rollback()
		return err
	}

	member := &models.GroupMember{
		GroupID:  group.ID,
		UserID:   userID,
		Role:     "admin",
		JoinedAt: time.Now(),
	}
	if err := tx.Create(member).Error; err != nil {
		tx.Rollback()
		return err
	}

	return tx.Commit().Error
}

// JoinGroup 加入小组
func (s *SocialService) JoinGroup(groupID, userID string) error {
	member := &models.GroupMember{
		GroupID:  groupID,
		UserID:   userID,
		Role:     "member",
		JoinedAt: time.Now(),
	}
	return s.db.Create(member).Error
}

// LeaveGroup 退出小组
func (s *SocialService) LeaveGroup(groupID, userID string) error {
	return s.db.Where("group_id = ? AND user_id = ?", groupID, userID).
		Delete(&models.GroupMember{}).Error
}

// GetGroupMembers 获取小组成员
func (s *SocialService) GetGroupMembers(groupID string) ([]models.GroupMember, error) {
	var members []models.GroupMember
	err := s.db.Where("group_id = ?", groupID).Find(&members).Error
	return members, err
}