teams.go

package controllers

import (
	"fmt"
	"net/http"
	"strings"
	"time"

	"github.com/CodeChefVIT/devsoc-backend-26/pkg/db"
	"github.com/CodeChefVIT/devsoc-backend-26/pkg/db/sqlc"
	"github.com/CodeChefVIT/devsoc-backend-26/pkg/dto"
	"github.com/CodeChefVIT/devsoc-backend-26/pkg/models"
	"github.com/CodeChefVIT/devsoc-backend-26/pkg/redis"
	"github.com/CodeChefVIT/devsoc-backend-26/pkg/utils"
	"github.com/google/uuid"
	"github.com/jackc/pgx/v5/pgtype"
	"github.com/labstack/echo/v4"
)

// This function is to generate a pointer for round qualified
// This is happening because our schema contains nullable round
// -> I ain't fixing allat I'm just doing this workaround 🙏🙏
func ptrInt32(v int32) *int32 {
	return &v
}

func CreateTeam(c echo.Context) error {
	var req dto.CreateTeamRequest

	if err := c.Bind(&req); err != nil {
		return c.JSON(http.StatusBadRequest, &models.Response{
			Success: false,
			Message: err.Error(),
		})
	}
	user, ok := c.Get("user").(sqlc.User)
	if !ok {
		return c.JSON(http.StatusUnauthorized, &models.Response{
			Success: false,
			Message: "user not found",
		})
	}
	if user.TeamID.Valid {
		return c.JSON(http.StatusUnauthorized, &models.Response{
			Success: false,
			Message: "user already in a team",
		})
	}
	var (
		team sqlc.Team
		err  error
	)
	if len(strings.TrimSpace(req.Name)) < 5 || len(req.Name) > 12 {
		return c.JSON(http.StatusBadRequest, &models.Response{
			Success: false,
			Message: "team name should be in between 5 to 12 characters",
		})
	}

	ctx := c.Request().Context()
	exists, err := db.Queries.NameExists(ctx, req.Name)
	if err != nil {
		return c.JSON(http.StatusInternalServerError, &models.Response{
			Success: false,
			Message: "failed to check team name availability",
		})
	}
	if exists {
		return c.JSON(http.StatusBadRequest, &models.Response{
			Success: false,
			Message: "team name already taken TwT",
		})
	}
	for range 5 {
		code, genErr := utils.GenerateTeamCode(6)
		if genErr != nil {
			return c.JSON(http.StatusInternalServerError, &models.Response{
				Success: false,
				Message: "failed to generate team code",
			})
		}
		team, err = db.Queries.CreateTeam(ctx, sqlc.CreateTeamParams{
			ID: pgtype.UUID{
				Bytes: uuid.New(),
				Valid: true,
			},
			Name:           req.Name,
			TeamSize:       1,
			RoundQualified: ptrInt32(0),
			Code:           code,
			IsBanned:       false,
			TotalScore:     0,
		})
		if err == nil {
			break
		}
	}
	if err != nil {
		return c.JSON(http.StatusInternalServerError, &models.Response{
			Success: false,
			Message: "failed to create team",
		})
	}

	err = db.Queries.MakeLeader(ctx, sqlc.MakeLeaderParams{
		TeamID: team.ID,
		Email:  user.Email,
	})
	if err != nil {
		return c.JSON(http.StatusInternalServerError, &models.Response{
			Success: false,
			Message: "failed to promote user to leader",
		})
	}

	if err := utils.ReissueToken(
		c,
		user.ID.String(),
		"leader",
		user.Email,
		"access",
		time.Hour,
	); err != nil {
		return c.JSON(http.StatusInternalServerError, &models.Response{
			Success: false,
			Message: "failed to update token",
		})
	}

	return c.JSON(http.StatusCreated, &models.Response{
		Success: true,
		Message: "team created successfully",
		Data: map[string]interface{}{
			"name": team.Name,
			"code": team.Code,
		},
	})
}

func GetTeam(c echo.Context) error {
	uid, err := uuid.Parse(c.Param("id"))
	if err != nil {
		return c.JSON(http.StatusBadRequest, &models.Response{
			Success: false,
			Message: err.Error(),
		})
	}
	team, err := db.Queries.GetTeamById(
		c.Request().Context(),
		pgtype.UUID{
			Bytes: uid,
			Valid: true,
		},
	)
	if err != nil {
		return c.JSON(http.StatusNotFound, &models.Response{
			Success: false,
			Message: err.Error(),
		})
	}
	return c.JSON(http.StatusOK, &models.Response{
		Success: true,
		Message: "team fetched successfully",
		Data:    team,
	})
}

func GetAllTeams(c echo.Context) error {
	teams, err := db.Queries.GetAllTeams(c.Request().Context())
	if err != nil {
		return c.JSON(http.StatusInternalServerError, &models.Response{
			Success: false,
			Message: err.Error(),
		})
	}

	return c.JSON(http.StatusOK, &models.Response{
		Success: true,
		Message: "teams fetched successfully",
		Data: map[string]interface{}{
			"teams": teams,
			"count": len(teams),
		},
	})
}

func UpdateTeam(c echo.Context) error {
	ctx := c.Request().Context()
	uid, err := uuid.Parse(c.Param("id"))
	user, ok := c.Get("user").(sqlc.User)
	if !ok {
		return c.JSON(http.StatusUnauthorized, &models.Response{
			Success: false,
			Message: "user not found",
		})
	}
	if user.TeamID.Valid && user.TeamID.Bytes != uid {
		return c.JSON(http.StatusForbidden, &models.Response{
			Success: false,
			Message: "you don't have permission to update this team",
		})
	}

	if err != nil {
		return c.JSON(http.StatusBadRequest, &models.Response{
			Success: false,
			Message: err.Error(),
		})
	}

	id := pgtype.UUID{Bytes: uid, Valid: true}

	existing, err := db.Queries.GetTeamById(c.Request().Context(), id)
	if err != nil {
		return c.JSON(http.StatusNotFound, &models.Response{
			Success: false,
			Message: err.Error(),
		})
	}

	var req dto.UpdateTeamRequest

	if err := c.Bind(&req); err != nil {
		return c.JSON(http.StatusBadRequest, &models.Response{
			Success: false,
			Message: err.Error(),
		})
	}

	name := existing.Name
	if req.Name != nil {
		name = *req.Name
	}

	exists, err := db.Queries.NameExists(ctx, name)
	if err != nil {
		return c.JSON(http.StatusInternalServerError, &models.Response{
			Success: false,
			Message: "failed to check team name availability",
		})
	}
	if exists {
		return c.JSON(http.StatusBadRequest, &models.Response{
			Success: false,
			Message: "Team name already taken TwT",
		})
	}

	err = db.Queries.UpdateTeamName(c.Request().Context(), sqlc.UpdateTeamNameParams{
		ID:   id,
		Name: name,
	})
	if err != nil {
		return c.JSON(http.StatusInternalServerError, &models.Response{
			Success: false,
			Message: err.Error(),
		})
	}

	return c.JSON(http.StatusOK, &models.Response{
		Success: true,
		Message: "team updated",
	})
}

func ToggleTeamBan(c echo.Context) error {
	uid, err := uuid.Parse(c.Param("id"))
	if err != nil {
		return c.JSON(http.StatusBadRequest, &models.Response{
			Success: false,
			Message: err.Error(),
		})
	}

	id := pgtype.UUID{Bytes: uid, Valid: true}

	existing, err := db.Queries.GetTeamById(c.Request().Context(), id)
	if err != nil {
		return c.JSON(http.StatusNotFound, &models.Response{
			Success: false,
			Message: err.Error(),
		})
	}

	newBanStatus := !existing.IsBanned

	err = db.Queries.UpdateTeam(c.Request().Context(), sqlc.UpdateTeamParams{
		ID:             id,
		Name:           existing.Name,
		TeamSize:       existing.TeamSize,
		RoundQualified: existing.RoundQualified,
		IsBanned:       newBanStatus,
		TotalScore:     existing.TotalScore,
	})
	if err != nil {
		return c.JSON(http.StatusInternalServerError, &models.Response{
			Success: false,
			Message: err.Error(),
		})
	}

	return c.JSON(http.StatusOK, &models.Response{
		Success: true,
		Message: "team ban status toggled",
		Data: map[string]interface{}{
			"is_banned": newBanStatus,
		},
	})
}

func JoinTeam(c echo.Context) error {
	ctx := c.Request().Context()

	email, ok := c.Get("email").(string)
	if !ok {
		return c.JSON(http.StatusUnauthorized, &models.Response{
			Success: false,
			Message: "unauthorized",
		})
	}

	var req dto.JoinTeamRequest
	if err := c.Bind(&req); err != nil {
		return c.JSON(http.StatusBadRequest, &models.Response{
			Success: false,
			Message: "invalid request",
		})
	}

	userKey := email

	teamKey, err := db.Queries.GetTeamIDByCode(ctx, req.TeamCode)
	if err != nil {
		return c.JSON(http.StatusNotFound, &models.Response{
			Success: false,
			Message: "team not found",
		})
	}


	teamKeyStr := teamKey.String()

	ok, err = redis.RequestManager.SetNX(
		ctx,
		userKey,
		teamKeyStr,
		30*time.Minute,
	).Result()
	if err != nil {
		fmt.Printf("Rediserror: %v\n", err)
		return c.JSON(http.StatusInternalServerError, &models.Response{
			Success: false,
			Message: "failed to process request",
		})
	}

	if !ok {
		return c.JSON(http.StatusBadRequest, &models.Response{
			Success: false,
			Message: "you already have a pending join request",
		})
	}

	if err := redis.RequestManager.SAdd(ctx, teamKeyStr, email).Err(); err != nil {
		redis.RequestManager.Del(ctx, userKey)
		fmt.Printf("Rediserror: %v\n", err)
		return c.JSON(http.StatusInternalServerError, &models.Response{
			Success: false,
			Message: "failed to join team",
		})
	}

	return c.JSON(http.StatusOK, &models.Response{
		Success: true,
		Message: "join request sent",
	})
}

func CancelRequest(c echo.Context) error {
	ctx := c.Request().Context()

	email, ok := c.Get("email").(string)
	if !ok {
		return c.JSON(http.StatusUnauthorized, &models.Response{
			Success: false,
			Message: "unauthorized",
		})
	}

	userKey := email

	teamKey, err := redis.RequestManager.Get(ctx, userKey).Result()
	if err != nil {
		return c.JSON(http.StatusBadRequest, &models.Response{
			Success: false,
			Message: "no pending join request found",
		})
	}

	if err := redis.RequestManager.Del(ctx, userKey).Err(); err != nil {
		return c.JSON(http.StatusInternalServerError, &models.Response{
			Success: false,
			Message: "failed to cancel request",
		})
	}

	if err := redis.RequestManager.SRem(ctx, teamKey, email).Err(); err != nil {
		return c.JSON(http.StatusInternalServerError, &models.Response{
			Success: false,
			Message: "failed to cancel request",
		})
	}

	return c.JSON(http.StatusOK, &models.Response{
		Success: true,
		Message: "join request cancelled",
	})
}

func Reject(c echo.Context) error {
	ctx := c.Request().Context()

	var req dto.Reject
	if err := c.Bind(&req); err != nil {
		return c.JSON(http.StatusBadRequest, &models.Response{
			Success: false,
			Message: "invalid request body",
		})
	}

	email := req.Email
	if email == "" {
		return c.JSON(http.StatusBadRequest, &models.Response{
			Success: false,
			Message: "email is required",
		})
	}

	user, ok := c.Get("user").(sqlc.User)
	if !ok {
		return c.JSON(http.StatusUnauthorized, &models.Response{
			Success: false,
			Message: "user not found",
		})
	}

	userKey := email

	teamCode, err := redis.RequestManager.Get(ctx, userKey).Result()
	if err != nil {
		return c.JSON(http.StatusBadRequest, &models.Response{
			Success: false,
			Message: "no pending join request found",
		})
	}

	teamKey := user.TeamID.String()

	isMember, err := redis.RequestManager.SIsMember(ctx, teamKey, userKey).Result()
	if err != nil {
		return c.JSON(http.StatusInternalServerError, &models.Response{
			Success: false,
			Message: "internal error",
		})
	}

	if !isMember {
		return c.JSON(http.StatusBadRequest, &models.Response{
			Success: false,
			Message: "no pending request from user",
		})
	}

	teamKey = teamCode

	if err := redis.RequestManager.Del(ctx, userKey).Err(); err != nil {
		return c.JSON(http.StatusInternalServerError, &models.Response{
			Success: false,
			Message: "failed to cancel request",
		})
	}

	if err := redis.RequestManager.SRem(ctx, teamKey, email).Err(); err != nil {
		return c.JSON(http.StatusInternalServerError, &models.Response{
			Success: false,
			Message: "failed to cancel request",
		})
	}

	return c.JSON(http.StatusOK, &models.Response{
		Success: true,
		Message: "join request rejected",
	})
}

func GetRequests(c echo.Context) error {
	ctx := c.Request().Context()

	email, ok := c.Get("email").(string)
	if !ok {
		return c.JSON(http.StatusUnauthorized, &models.Response{
			Success: false,
			Message: "unauthorized",
		})
	}

	teamID, err := db.Queries.GetTeamIDByEmail(ctx, email)
	if err != nil {
		return c.JSON(http.StatusNotFound, &models.Response{
			Success: false,
			Message: "user or team not found",
		})
	}

	requestEmails, err := redis.RequestManager.
		SMembers(ctx, teamID.String()).
		Result()

	if err != nil || len(requestEmails) == 0 {
		return c.JSON(http.StatusOK, &models.Response{
			Success: true,
			Message: "no pending join requests",
			Data:    []interface{}{},
		})
	}

	res := make([]map[string]interface{}, 0, len(requestEmails))

	for _, reqEmail := range requestEmails {
		u, err := db.Queries.GetUserByEmail(ctx, reqEmail)
		if err != nil {
			continue
		}

		res = append(res, map[string]interface{}{
			"id":        u.ID,
			"email":     u.Email,
			"name":      u.Name,
			"reg_no":    u.RegNo,
			"is_leader": u.IsLeader,
		})
	}
	return c.JSON(http.StatusOK, &models.Response{
		Success: true,
		Message: "join requests fetched successfully",
		Data:    res,
	})
}

func AcceptRequest(c echo.Context) error {
	ctx := c.Request().Context()

	me, ok := c.Get("email").(string)
	if !ok {
		return c.JSON(http.StatusUnauthorized, &models.Response{Success: false, Message: "Unauthorized"})
	}

	var req dto.AcceptRequest
	if err := c.Bind(&req); err != nil || req.Email == "" {
		return c.JSON(http.StatusBadRequest, &models.Response{Success: false, Message: "invalid request"})
	}

	teamID, err := db.Queries.GetTeamIDByEmail(ctx, me)
	if err != nil {
		return c.JSON(http.StatusInternalServerError, &models.Response{Success: false, Message: "failed to verify team"})
	}

	teamKey := teamID.String()
	userKey := req.Email

	isMember, err := redis.RequestManager.SIsMember(ctx, teamKey, userKey).Result()
	if err != nil {
		return c.JSON(http.StatusInternalServerError, &models.Response{Success: false, Message: "Internal error"})
	}
	if !isMember {
		return c.JSON(http.StatusBadRequest, &models.Response{Success: false, Message: "no pending request from user"})
	}

	exists, err := db.Queries.UserExistsByEmail(ctx, req.Email)
	if err != nil {
		return c.JSON(http.StatusInternalServerError, &models.Response{Success: false, Message: "internal server error"})
	}
	if !exists {
		return c.JSON(http.StatusNotFound, &models.Response{Success: false, Message: "user not found"})
	}

	userTeamID, err := db.Queries.GetTeamIDByEmail(ctx, req.Email)
	if err == nil && userTeamID.Valid {
		return c.JSON(http.StatusBadRequest, &models.Response{Success: false, Message: "user already in a team"})
	}

	teamSize, err := db.Queries.GetTeamSizeByID(ctx, teamID)
	if err != nil {
		return c.JSON(http.StatusInternalServerError, &models.Response{Success: false, Message: "failed to get team size"})
	}
	if teamSize >= 5 {
		return c.JSON(http.StatusBadRequest, &models.Response{Success: false, Message: "team is full"})
	}

	err = db.Queries.UpdateTeamByEmail(ctx, sqlc.UpdateTeamByEmailParams{
		TeamID: teamID,
		Email:  req.Email,
	})
	if err != nil {
		return c.JSON(http.StatusInternalServerError, &models.Response{Success: false, Message: "failed to add user to team"})
	}

	err = db.Queries.IncrementTeamSize(ctx, teamID)
	if err != nil {
		return c.JSON(http.StatusInternalServerError, &models.Response{Success: false, Message: "failed to update team size"})
	}

	redis.RequestManager.SRem(ctx, teamKey, userKey)
	redis.RequestManager.Del(ctx, userKey)

	return c.JSON(http.StatusOK, &models.Response{Success: true, Message: "user added to team successfully"})
}

func Leave(c echo.Context) error {
	ctx := c.Request().Context()

	user, ok := c.Get("user").(sqlc.User)
	if !ok {
		return c.JSON(http.StatusUnauthorized, &models.Response{Success: false, Message: "User not found"})
	}

	if !user.TeamID.Valid {
		return c.JSON(http.StatusBadRequest, &models.Response{Success: false, Message: "User not in any team"})
	}

	teamID := user.TeamID
	team, err := db.Queries.GetTeamById(ctx, teamID)
	if err != nil {
		return c.JSON(http.StatusInternalServerError, &models.Response{Success: false, Message: "failed to fetch team"})
	}

	if user.IsLeader {
		if team.TeamSize == 1 {
			if err := db.Queries.LeaveTeam(ctx, user.ID); err != nil {
				return c.JSON(http.StatusInternalServerError, &models.Response{Success: false, Message: "failed to leave team"})
			}
			if err := db.Queries.DeleteTeam(ctx, teamID); err != nil {
				return c.JSON(http.StatusInternalServerError, &models.Response{Success: false, Message: "failed to delete team"})
			}
			if err := utils.ReissueToken(c, user.ID.String(), "user", user.Email, "access", time.Hour); err != nil {
				return c.JSON(http.StatusInternalServerError, &models.Response{Success: false, Message: "failed to update token"})
			}
			return c.JSON(http.StatusOK, &models.Response{Success: true, Message: "left team and deleted team successfully"})
		}
		if team.TeamSize < 2 {
			if err := db.Queries.LeaveTeam(ctx, user.ID); err != nil {
				return c.JSON(http.StatusInternalServerError, &models.Response{Success: false, Message: "failed to leave team"})
			}

			if err := db.Queries.DecrementSize(ctx, teamID); err != nil {
				return c.JSON(http.StatusInternalServerError, &models.Response{Success: false, Message: "failed to decrement team size"})
			}

			if err := utils.ReissueToken(c, user.ID.String(), "user", user.Email, "access", time.Hour); err != nil {
				return c.JSON(http.StatusInternalServerError, &models.Response{Success: false, Message: "failed to update token"})
			}

			return c.JSON(http.StatusOK, &models.Response{Success: true, Message: "left team successfully"})
		}

		new, err := db.Queries.SwapLeader(ctx, teamID)
		if err != nil {
			return c.JSON(http.StatusInternalServerError, &models.Response{Success: false, Message: "failed to assign new leader"})
		}

		if err := db.Queries.DecrementSize(ctx, teamID); err != nil {
			return c.JSON(http.StatusInternalServerError, &models.Response{Success: false, Message: "failed to decrement team size"})
		}

		if err := db.Queries.LeaveTeam(ctx, user.ID); err != nil {
			return c.JSON(http.StatusInternalServerError, &models.Response{Success: false, Message: "failed to leave team"})
		}

		if err := utils.ReissueToken(c, user.ID.String(), "user", user.Email, "access", time.Hour); err != nil {
			return c.JSON(http.StatusInternalServerError, &models.Response{Success: false, Message: "failed to update token"})
		}

		return c.JSON(http.StatusOK, &models.Response{
			Success: true,
			Message: "team left, new leader assigned",
			Data: map[string]interface{}{
				"leader": map[string]interface{}{
					"name":  new.Name,
					"email": new.Email,
				},
			},
		})
	}

	if err := db.Queries.LeaveTeam(ctx, user.ID); err != nil {
		return c.JSON(http.StatusInternalServerError, &models.Response{Success: false, Message: "failed to leave team"})
	}
	if err := db.Queries.DecrementSize(ctx, teamID); err != nil {
		return c.JSON(http.StatusInternalServerError, &models.Response{Success: false, Message: "failed to decrement team size"})
	}

	return c.JSON(http.StatusOK, &models.Response{Success: true, Message: "left team successfully"})
}

func Kick(c echo.Context) error {
	ctx := c.Request().Context()
	var req dto.Kick
	if err := c.Bind(&req); err != nil {
		return c.JSON(http.StatusBadRequest, &models.Response{
			Success: false,
			Message: err.Error(),
		})
	}
	pgMyAss := pgtype.UUID{
		Bytes: req.Id,
		Valid: true,
	}
	user, ok := c.Get("user").(sqlc.User)
	if !ok {
		return c.JSON(http.StatusUnauthorized, &models.Response{Success: false, Message: "User not found"})
	}

	reqid, err := db.Queries.GetTeamIDByUID(ctx, pgMyAss)
	if err != nil {
		return c.JSON(http.StatusInternalServerError, &models.Response{Success: false, Message: "failed to assign new leader"})
	}

	if reqid != user.TeamID {
		return c.JSON(http.StatusUnauthorized, &models.Response{Success: false, Message: "User not found in your team"})
	}

	if err := db.Queries.LeaveTeam(ctx, pgMyAss); err != nil {
		return c.JSON(http.StatusInternalServerError, &models.Response{Success: false, Message: "failed to leave team"})
	}
	if err := db.Queries.DecrementSize(ctx, reqid); err != nil {
		return c.JSON(http.StatusInternalServerError, &models.Response{Success: false, Message: "failed to decrement team size"})
	}

	return c.JSON(http.StatusOK, &models.Response{Success: true, Message: "Kicked"})
}

func GetTeamMembers(c echo.Context) error {
	ctx := c.Request().Context()

	uid, err := uuid.Parse(c.Param("id"))
	if err != nil {
		return c.JSON(http.StatusBadRequest, &models.Response{
			Success: false,
			Message: "invalid team id",
		})
	}

	teamID := pgtype.UUID{
		Bytes: uid,
		Valid: true,
	}

	members, err := db.Queries.GetTeamMembersByTeamID(ctx, teamID)
	if err != nil {
		return c.JSON(http.StatusInternalServerError, &models.Response{
			Success: false,
			Message: err.Error(),
		})
	}

	res := make([]map[string]interface{}, 0, len(members))
	var leader map[string]interface{}

	for _, m := range members {
		member := map[string]interface{}{
			"id":        m.ID,
			"name":      m.Name,
			"reg_no":    m.RegNo,
			"is_leader": m.IsLeader,
		}

		if m.IsLeader {
			leader = member
		} else {
			res = append(res, member)
		}
	}

	if leader != nil {
		res = append([]map[string]interface{}{leader}, res...)
	}

	return c.JSON(http.StatusOK, &models.Response{
		Success: true,
		Message: "team members fetched successfully",
		Data:    res,
	})
}

func MyRequest(c echo.Context) error {
	ctx := c.Request().Context()

	email, ok := c.Get("email").(string)
	if !ok {
		return c.JSON(http.StatusUnauthorized, &models.Response{
			Success: false,
			Message: "unauthorized",
		})
	}

	_, err := redis.RequestManager.Get(ctx, email).Result()
	if err != nil {
		return c.JSON(http.StatusBadRequest, &models.Response{
			Success: false,
			Message: "no pending request found",
		})
	}

	return c.JSON(http.StatusOK, &models.Response{
		Success: true,
		Message: "pending request found",
	})
}