package repositories

import (
	"clapclap/internal/models"
	"clapclap/internal/uuid"
	"errors"
	// "gorm.io/gorm"
)

func (r *Repo) AddFriend(userID, friendID uuid.UUID) error {
	if err := r.db.Model(&models.User{Base: models.Base{ID: userID}}).
		Association("Friends").
		Append(&models.User{Base: models.Base{ID: friendID}}); err != nil {
		return err
	}

	return r.db.Model(&models.User{Base: models.Base{ID: friendID}}).
		Association("Friends").
		Append(&models.User{Base: models.Base{ID: userID}})
}

func (r *Repo) RemoveFriend(userID, friendID uuid.UUID) error {
	if err := r.db.Model(&models.User{Base: models.Base{ID: userID}}).
		Association("Friends").
		Delete(&models.User{Base: models.Base{ID: friendID}}); err != nil {
		return err
	}

	return r.db.Model(&models.User{Base: models.Base{ID: friendID}}).
		Association("Friends").
		Delete(&models.User{Base: models.Base{ID: userID}})
}

func (r *Repo) GetFriends(userID uuid.UUID) ([]*models.User, error) {
	var friends []*models.User
	err := r.db.Model(&models.User{Base: models.Base{ID: userID}}).
		Association("Friends").
		Find(&friends)
	return friends, err
}

/*
func (r *Repo) GetFriendsWithPagination(userID uuid.UUID, page, pageSize int64) ([]*models.User, int64, error) {
	var friends []*models.User
	total := r.db.Model(&models.User{Base: models.Base{ID: userID}}).
		Association("Friends").
		Count()
	if r.db.Error != nil {
		return nil, 0, r.db.Error
	}

	offset := (page - 1) * pageSize
	err := r.db.Model(&models.User{Base: models.Base{ID: userID}}).
		Association("Friends").
		Find(&friends, "LIMIT ? OFFSET ?", pageSize, offset)

	if err != nil {
		return nil, 0, r.db.Error
	}

	return friends, total, err
}
*/

/*

func (r *Repo) GetFriendsCount(userID uuid.UUID) (int64, error) {
	count := r.db.Model(&models.User{Base: models.Base{ID: userID}}).
		Association("Friends").
		Count()
	if r.db.Error != nil {
		return 0, r.db.Error
	}
	return count, nil
}

*/

func (r *Repo) IsFriend(userID, friendID uuid.UUID) (bool, error) {
	count := r.db.Model(&models.User{Base: models.Base{ID: userID}}).
		Where("id = ?", friendID).
		Association("Friends").
		Count()
	if r.db.Error != nil {
		return false, r.db.Error
	}
	return count > 0, nil
}

/*
func (r *Repo) SearchFriends(userID uuid.UUID, searchTerm string) ([]*models.User, error) {
	var friends []*models.User
	err := r.db.
		Joins("INNER JOIN user_friends ON users.id = user_friends.friend_id").
		Where("user_friends.user_id = ? AND (users.first_name LIKE ? OR users.last_name LIKE ?)",
			userID, "%"+searchTerm+"%", "%"+searchTerm+"%").
		Find(&friends).Error
	return friends, err
}

func (r *Repo) GetMutualFriends(userID1, userID2 uuid.UUID) ([]*models.User, error) {
	var mutual []*models.User
	err := r.db.Table("users").
		Joins("JOIN user_friends uf1 ON users.id = uf1.friend_id AND uf1.user_id = ?", userID1).
		Joins("JOIN user_friends uf2 ON users.id = uf2.friend_id AND uf2.user_id = ?", userID2).
		Find(&mutual).Error
	return mutual, err
}

// GetFriendsOrderedBy retrieves friends with custom ordering
func (r *Repo) GetFriendsOrderedBy(userID uuid.UUID, orderBy string) ([]*models.User, error) {
	var friends []*models.User
	err := r.db.
		Joins("INNER JOIN user_friends ON users.id = user_friends.friend_id").
		Where("user_friends.user_id = ?", userID).
		Order(orderBy).
		Find(&friends).Error
	return friends, err
}

*/

// SendFriendRequest sends a friend request
func (r *Repo) SendFriendRequest(senderID, receiverID uuid.UUID) error {
	// Check if already friends
	isFriend, err := r.IsFriend(senderID, receiverID)
	if err != nil {
		return err
	}
	if isFriend {
		return errors.New("already friends")
	}

	// Check if request already exists
	var count int64
	if err := r.db.Model(&models.FriendRequest{}).
		Where("sender_id = ? AND receiver_id = ? AND status = ?", senderID, receiverID, models.Pending).
		Count(&count).Error; err != nil {
		return err
	}
	if count > 0 {
		return errors.New("request already sent")
	}

	// Create new request
	request := &models.FriendRequest{
		SenderID:   senderID,
		ReceiverID: receiverID,
		Status:     models.Pending,
	}
	return r.db.Create(request).Error
}

// GetPendingRequests retrieves pending friend requests for a user
func (r *Repo) GetPendingRequests(userID uuid.UUID) ([]*models.FriendRequest, error) {
	var requests []*models.FriendRequest
	err := r.db.Preload("Sender").
		Where("receiver_id = ? AND status = ?", userID, models.Pending).
		Order("created_at DESC").
		Find(&requests).Error
	return requests, err
}

func (r *Repo) GetPendingRequestWith(userID uuid.UUID, withID uuid.UUID) (*models.FriendRequest, error) {
	var request *models.FriendRequest
	err := r.db.Preload("Sender").
		Where("((sender_id = ? AND receiver_id = ?) OR (sender_id = ? AND receiver_id = ?)) AND status = ?",
			userID, withID, withID, userID, models.Pending).
		First(&request).Error
	return request, err
}

/*
// GetSentRequests retrieves friend requests sent by a user
func (r *Repo) GetSentRequests(userID uuid.UUID) ([]*models.FriendRequest, error) {
	var requests []*models.FriendRequest
	err := r.db.Preload("Receiver").
		Where("sender_id = ? AND status = ?", userID, models.Pending).
		Order("created_at DESC").
		Find(&requests).Error
	return requests, err
}
*/

// AcceptFriendRequest accepts a friend request and creates bidirectional friendship
func (r *Repo) AcceptFriendRequest(requestID uuid.UUID) error {
	var request models.FriendRequest
	if err := r.db.First(&request, requestID).Error; err != nil {
		return err
	}

	// Create bidirectional friendship (uses existing AddFriend method)
	if err := r.AddFriend(request.SenderID, request.ReceiverID); err != nil {
		return err
	}

	// Update request status
	return r.db.Model(&request).Update("status", models.Accepted).Error
}

// RejectFriendRequest rejects a friend request
func (r *Repo) RejectFriendRequest(requestID uuid.UUID) error {
	return r.db.Model(&models.FriendRequest{}).
		Where("id = ?", requestID).
		Update("status", models.Rejected).Error
}

// CancelFriendRequest cancels a sent friend request
func (r *Repo) CancelFriendRequest(requestID uuid.UUID) error {
	return r.db.Delete(&models.FriendRequest{}, requestID).Error
}

/*
// GetRequestStatus checks if there's a pending request between two users
func (r *Repo) GetFriendRequestStatus(senderID, receiverID uuid.UUID) (models.FriendRequestStatus, error) {
	var request models.FriendRequest
	err := r.db.Where("sender_id = ? AND receiver_id = ?", senderID, receiverID).
		First(&request).Error

	if err == gorm.ErrRecordNotFound {
		return "", nil
	}
	return request.Status, err
}

*/

// GetRequestByID retrieves a friend request by ID
func (r *Repo) GetFriendRequestByID(requestID uuid.UUID) (*models.FriendRequest, error) {
	var request models.FriendRequest
	err := r.db.Preload("Sender").Preload("Receiver").
		First(&request, requestID).Error
	return &request, err
}