package handlers

import (
	"bytes"
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"testing"

	"veza-backend-api/internal/models"
	"veza-backend-api/internal/services"

	"github.com/gin-gonic/gin"
	"github.com/google/uuid"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"go.uber.org/zap"
	"gorm.io/driver/sqlite"
	"gorm.io/gorm"
)

func setupPresenceHandler(t *testing.T) (*PresenceHandler, *gin.Engine) {
	gin.SetMode(gin.TestMode)
	logger := zap.NewNop()
	db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
	require.NoError(t, err)
	require.NoError(t, db.AutoMigrate(&models.UserPresence{}))

	presenceSvc := services.NewPresenceService(db, logger)
	handler := NewPresenceHandler(presenceSvc, logger)

	router := gin.New()
	router.Use(func(c *gin.Context) {
		if uidStr := c.GetHeader("X-User-ID"); uidStr != "" {
			if uid, err := uuid.Parse(uidStr); err == nil {
				c.Set("user_id", uid)
			}
		}
		c.Next()
	})
	router.GET("/users/:id/presence", handler.GetPresence)
	router.PUT("/users/me/presence", handler.UpdatePresence)

	return handler, router
}

func TestPresenceHandler_GetPresence_InvalidUserID(t *testing.T) {
	_, router := setupPresenceHandler(t)

	req := httptest.NewRequest("GET", "/users/invalid-id/presence", nil)
	w := httptest.NewRecorder()
	router.ServeHTTP(w, req)

	assert.Equal(t, http.StatusBadRequest, w.Code)
}

func TestPresenceHandler_GetPresence_NotFound(t *testing.T) {
	_, router := setupPresenceHandler(t)
	userID := uuid.New()
	viewerID := uuid.New()

	// Pass X-User-ID so GetUserIDUUID (optional viewer) succeeds; request targets a different user with no presence
	req := httptest.NewRequest("GET", "/users/"+userID.String()+"/presence", nil)
	req.Header.Set("X-User-ID", viewerID.String())
	w := httptest.NewRecorder()
	router.ServeHTTP(w, req)

	// Should return 200 with offline status when user has no presence
	assert.Equal(t, http.StatusOK, w.Code)
	var resp APIResponse
	require.NoError(t, json.Unmarshal(w.Body.Bytes(), &resp))
	assert.True(t, resp.Success)
}

func TestPresenceHandler_UpdatePresence_Unauthorized(t *testing.T) {
	_, router := setupPresenceHandler(t)
	body := bytes.NewBufferString(`{"status":"online"}`)
	req := httptest.NewRequest("PUT", "/users/me/presence", body)
	req.Header.Set("Content-Type", "application/json")
	w := httptest.NewRecorder()
	router.ServeHTTP(w, req)

	// No user_id in context - GetUserIDUUID fails, handler returns 401 via RespondWithAppError
	assert.True(t, w.Code == http.StatusUnauthorized || w.Code == http.StatusBadRequest)
}