handlers_following.go

package main

import (
	"slices"

	"github.com/gin-gonic/gin"
)

func followUser(c *gin.Context) {
	user := c.MustGet("user").(*User)
	targetUsername := Username(c.Query("username"))
	if targetUsername == "" {
		targetUsername = Username(c.Query("name"))
	}
	if targetUsername == "" {
		c.JSON(400, gin.H{"error": "Target username is required"})
		return
	}
	targetId := targetUsername.Id()
	currentId := user.GetId()
	targetUsername = targetUsername.ToLower()

	// Check if the target user exists
	if !accountExists(targetId) {
		c.JSON(404, gin.H{"error": "User not found"})
		return
	}

	if isUserBlockedBy(targetId.User(), currentId) {
		c.JSON(400, gin.H{"error": "You cant follow this user"})
		return
	}

	if targetId == currentId {
		c.JSON(400, gin.H{"error": "You cannot follow yourself"})
		return
	}

	followersMutex.Lock()
	// Ensure target user has an entry in followers data
	if _, exists := followersData[targetId]; !exists {
		followersData[targetId] = FollowerData{Followers: make([]UserId, 0)}
	}

	// Check if already following
	if slices.Contains(followersData[targetId].Followers, currentId) {
		followersMutex.Unlock()
		c.JSON(400, gin.H{"error": "You are already following " + targetUsername})
		return
	}

	// Add to followers list
	data := followersData[targetId]
	data.Followers = append(data.Followers, currentId)
	followersData[targetId] = data
	go saveFollowers()
	followersMutex.Unlock()

	addUserEvent(targetId, "follow", map[string]any{
		"follower": string(currentId),
	})

	c.JSON(200, gin.H{"message": "You are now following " + targetUsername})
}

func unfollowUser(c *gin.Context) {
	user := c.MustGet("user").(*User)
	targetUsername := Username(c.Query("username"))
	if targetUsername == "" {
		targetUsername = Username(c.Query("name"))
	}
	if targetUsername == "" {
		c.JSON(400, gin.H{"error": "Target username is required"})
		return
	}
	targetId := targetUsername.Id()
	if !accountExists(targetId) {
		c.JSON(404, gin.H{"error": "User not found"})
		return
	}
	currentId := user.GetId()
	targetUsername = targetUsername.ToLower()

	followersMutex.Lock()
	data, exists := followersData[targetId]
	if !exists || len(data.Followers) == 0 {
		followersMutex.Unlock()
		c.JSON(400, gin.H{"error": "You are not following this user"})
		return
	}
	// Remove from followers list
	newFollowers := make([]UserId, 0)
	found := false
	for _, follower := range data.Followers {
		if follower != currentId {
			newFollowers = append(newFollowers, follower)
		} else {
			found = true
		}
	}
	if !found {
		followersMutex.Unlock()
		c.JSON(400, gin.H{"error": "You are not following this user"})
		return
	}
	data.Followers = newFollowers
	followersData[targetId] = data
	if followingCountMap[currentId] > 0 {
		followingCountMap[currentId]--
	}
	go saveFollowers()
	followersCount := len(data.Followers)
	followersMutex.Unlock()

	go broadcastClawEvent("followers", map[string]any{
		"username":  targetUsername,
		"followers": followersCount,
	})

	shouldSave := false
	eventsHistoryMutex.Lock()
	if userEvents, exists := eventsHistory[targetId]; exists {
		newEvents := make([]Event, 0)
		for _, event := range userEvents {
			// event.Data["follower"] may be a string after JSON round-trip
			follower, _ := event.Data["follower"].(string)
			if !(event.Type == "follow" && UserId(follower) == currentId) {
				newEvents = append(newEvents, event)
			}
		}
		eventsHistory[targetId] = newEvents
		shouldSave = true
	}
	eventsHistoryMutex.Unlock()
	if shouldSave {
		go saveEventsHistory()
	}

	c.JSON(200, gin.H{"message": "You have unfollowed " + targetUsername})
}

func getFollowing(c *gin.Context) {
	name := Username(c.Query("name"))
	if name == "" {
		name = Username(c.Query("username"))
	}
	if name == "" {
		c.JSON(400, gin.H{"error": "Username is required"})
		return
	}

	targetId := name.Id()
	// Check if the user exists
	if !accountExists(targetId) {
		c.JSON(404, gin.H{"error": "User not found"})
		return
	}

	followersMutex.RLock()
	defer followersMutex.RUnlock()

	following := make([]Username, 0)

	for _, data := range followersData {
		if slices.Contains(data.Followers, targetId) {
			following = append(following, data.Username)
		}
	}

	c.JSON(200, gin.H{"following": following})
}

func getFollowers(c *gin.Context) {
	name := Username(c.Query("name"))
	if name == "" {
		name = Username(c.Query("username"))
	}
	if name == "" {
		c.JSON(400, gin.H{"error": "Username is required"})
		return
	}

	// Check if the user exists
	targetId := name.Id()
	if !accountExists(targetId) {
		c.JSON(404, gin.H{"error": "User not found"})
		return
	}

	followersMutex.RLock()
	defer followersMutex.RUnlock()

	followers := make([]Username, 0)

	data, exists := followersData[targetId]
	if !exists {
		c.JSON(200, gin.H{"followers": []Username{}})
		return
	}
	for _, follower := range data.Followers {
		followers = append(followers, follower.User().GetUsername())
	}

	c.JSON(200, gin.H{"followers": followers})
}