package tests

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

// 	"github.com/Caknoooo/go-gin-clean-starter/database/entities"
// 	authRepo "github.com/Caknoooo/go-gin-clean-starter/modules/auth/repository"
// 	authService "github.com/Caknoooo/go-gin-clean-starter/modules/auth/service"
// 	"github.com/Caknoooo/go-gin-clean-starter/modules/user/controller"
// 	"github.com/Caknoooo/go-gin-clean-starter/modules/user/dto"
// 	"github.com/Caknoooo/go-gin-clean-starter/modules/user/repository"
// 	"github.com/Caknoooo/go-gin-clean-starter/modules/user/service"
// 	"github.com/Caknoooo/go-gin-clean-starter/providers"
// 	"github.com/gin-gonic/gin"
// 	"github.com/samber/do"
// 	"github.com/stretchr/testify/assert"
// )

// func SetUpRoutes() *gin.Engine {
// 	r := gin.Default()
// 	return r
// }

// func SetUpInjector() *do.Injector {
// 	injector := do.New()
// 	providers.RegisterDependencies(injector)
// 	return injector
// }

// func SetupControllerUser() controller.UserController {
// 	var (
// 		db               = SetUpDatabaseConnection()
// 		injector         = SetUpInjector()
// 		userRepo         = repository.NewUserRepository(db)
// 		jwtService       = authService.NewJWTService()
// 		refreshTokenRepo = authRepo.NewRefreshTokenRepository(db)
// 		userService      = service.NewUserService(userRepo, refreshTokenRepo, jwtService, db)
// 		userController   = controller.NewUserController(injector, userService)
// 	)

// 	return userController
// }

// func InsertTestUser() ([]entities.User, error) {
// 	db := SetUpDatabaseConnection()
// 	users := []entities.User{
// 		{
// 			Name:  "admin",
// 			Email: "admin1234@gmail.com",
// 		},
// 		{
// 			Name:  "user",
// 			Email: "user1234@gmail.com",
// 		},
// 	}

// 	for _, user := range users {
// 		if err := db.Create(&user).Error; err != nil {
// 			return nil, err
// 		}
// 	}

// 	return users, nil
// }

// func Test_GetAllUser_BadRequest(t *testing.T) {
// 	r := SetUpRoutes()
// 	uc := SetupControllerUser()
// 	r.GET("/api/user", uc.GetAllUser)

// 	// missing query params triggers binding error
// 	req, _ := http.NewRequest(http.MethodGet, "/api/user", nil)
// 	w := httptest.NewRecorder()
// 	r.ServeHTTP(w, req)

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

// func Test_Register_OK(t *testing.T) {
// 	r := SetUpRoutes()
// 	uc := SetupControllerUser()
// 	r.POST("/api/user", uc.Register)

// 	payload := dto.UserCreateRequest{Name: "testuser", Email: "test@example.com", Password: "password123"}
// 	b, _ := json.Marshal(payload)
// 	req, _ := http.NewRequest(http.MethodPost, "/api/user", bytes.NewBuffer(b))
// 	req.Header.Set("Content-Type", "application/json")
// 	w := httptest.NewRecorder()
// 	r.ServeHTTP(w, req)

// 	assert.Equal(t, http.StatusOK, w.Code)
// 	var out struct {
// 		Data entities.User `json:"data"`
// 	}
// 	json.Unmarshal(w.Body.Bytes(), &out)
// 	assert.Equal(t, payload.Email, out.Data.Email)
// }

// func Test_Register_BadRequest(t *testing.T) {
// 	r := SetUpRoutes()
// 	uc := SetupControllerUser()
// 	r.POST("/api/user", uc.Register)

// 	// empty body
// 	req, _ := http.NewRequest(http.MethodPost, "/api/user", nil)
// 	w := httptest.NewRecorder()
// 	r.ServeHTTP(w, req)

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

// func Test_Login_BadRequest(t *testing.T) {
// 	r := SetUpRoutes()
// 	uc := SetupControllerUser()
// 	r.POST("/api/user/login", uc.Login)

// 	req, _ := http.NewRequest(http.MethodPost, "/api/user/login", nil)
// 	w := httptest.NewRecorder()
// 	r.ServeHTTP(w, req)

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

// func Test_SendVerificationEmail_OK(t *testing.T) {
// 	r := SetUpRoutes()
// 	uc := SetupControllerUser()
// 	r.POST("/api/user/send_verification_email", uc.SendVerificationEmail)

// 	users, _ := InsertTestUser()
// 	reqBody, _ := json.Marshal(dto.SendVerificationEmailRequest{Email: users[0].Email})
// 	req, _ := http.NewRequest(http.MethodPost, "/api/user/send_verification_email", bytes.NewBuffer(reqBody))
// 	req.Header.Set("Content-Type", "application/json")
// 	w := httptest.NewRecorder()
// 	r.ServeHTTP(w, req)

// 	assert.Equal(t, http.StatusOK, w.Code)
// }

// func Test_SendVerificationEmail_BadRequest(t *testing.T) {
// 	r := SetUpRoutes()
// 	uc := SetupControllerUser()
// 	r.POST("/api/user/send_verification_email", uc.SendVerificationEmail)

// 	// missing email
// 	req, _ := http.NewRequest(http.MethodPost, "/api/user/send_verification_email", nil)
// 	w := httptest.NewRecorder()
// 	r.ServeHTTP(w, req)

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

// func Test_VerifyEmail_BadRequest(t *testing.T) {
// 	r := SetUpRoutes()
// 	uc := SetupControllerUser()
// 	r.POST("/api/user/verify_email", uc.VerifyEmail)

// 	// missing token
// 	req, _ := http.NewRequest(http.MethodPost, "/api/user/verify_email", nil)
// 	w := httptest.NewRecorder()
// 	r.ServeHTTP(w, req)

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

// // Note: VerifyEmail_OK requires a valid token setup; implement when token creation is available.
// func Test_VerifyEmail_OK(t *testing.T) {
// 	r := SetUpRoutes()
// 	uc := SetupControllerUser()
// 	r.POST("/api/user/verify_email", uc.VerifyEmail)

// 	// TODO: insert valid verification token into DB and use here
// 	validToken := "valid-token-placeholder"
// 	reqBody, _ := json.Marshal(dto.VerifyEmailRequest{Token: validToken})
// 	req, _ := http.NewRequest(http.MethodPost, "/api/user/verify_email", bytes.NewBuffer(reqBody))
// 	req.Header.Set("Content-Type", "application/json")
// 	w := httptest.NewRecorder()
// 	r.ServeHTTP(w, req)

// 	// expecting BadRequest until token logic is implemented
// 	assert.NotEqual(t, http.StatusInternalServerError, w.Code)
// }

// func Test_GetAllUser_OK(t *testing.T) {
// 	r := SetUpRoutes()
// 	userController := SetupControllerUser()
// 	r.GET("/api/user", userController.GetAllUser)

// 	expectedUsers, err := InsertTestUser()
// 	if err != nil {
// 		t.Fatalf("Failed to insert test users: %v", err)
// 	}

// 	req, err := http.NewRequest(http.MethodGet, "/api/user", nil)
// 	if err != nil {
// 		t.Fatalf("Failed to create request: %v", err)
// 	}

// 	w := httptest.NewRecorder()

// 	r.ServeHTTP(w, req)

// 	assert.Equal(t, http.StatusOK, w.Code)

// 	type Response struct {
// 		Data []entities.User `json:"data"`
// 	}

// 	var response Response
// 	err = json.Unmarshal(w.Body.Bytes(), &response)
// 	if err != nil {
// 		t.Fatalf("Failed to unmarshal response body: %v", err)
// 	}

// 	actualUsers := response.Data

// 	for _, expectedUser := range expectedUsers {
// 		found := false
// 		for _, actualUser := range actualUsers {
// 			if expectedUser.Name == actualUser.Name && expectedUser.Email == actualUser.Email {
// 				found = true
// 				break
// 			}
// 		}
// 		assert.True(t, found, "Expected user not found in actual users: %v", expectedUser)
// 	}
// }

// // Test Login
// func Test_Login_OK(t *testing.T) {
// 	r := SetUpRoutes()
// 	userController := SetupControllerUser()
// 	// first register
// 	r.POST("/api/user", userController.Register)
// 	r.POST("/api/user/login", userController.Login)

// 	payload := dto.UserLoginRequest{
// 		Email:    "loginuser@example.com",
// 		Password: "securepass",
// 	}
// 	// register user
// 	regBody, _ := json.Marshal(dto.UserCreateRequest{
// 		Name:     "loginuser",
// 		Email:    payload.Email,
// 		Password: payload.Password,
// 	})
// 	reqReg, _ := http.NewRequest(http.MethodPost, "/api/user", bytes.NewBuffer(regBody))
// 	reqReg.Header.Set("Content-Type", "application/json")
// 	httptest.NewRecorder() // ignore

// 	// login
// 	body, _ := json.Marshal(payload)
// 	req, _ := http.NewRequest(http.MethodPost, "/api/user/login", bytes.NewBuffer(body))
// 	req.Header.Set("Content-Type", "application/json")
// 	w := httptest.NewRecorder()

// 	r.ServeHTTP(w, req)

// 	assert.Equal(t, http.StatusOK, w.Code)

// 	type Resp struct {
// 		Data struct {
// 			Token string `json:"token"`
// 			Role  string `json:"role"`
// 		} `json:"data"`
// 	}
// 	var resp Resp
// 	err := json.Unmarshal(w.Body.Bytes(), &resp)
// 	assert.Nil(t, err)
// 	assert.NotEmpty(t, resp.Data.Token)
// }

// // Test Me
// func Test_Me_OK(t *testing.T) {
// 	r := SetUpRoutes()
// 	userController := SetupControllerUser()
// 	r.GET("/api/user/me", func(c *gin.Context) {
// 		// insert and set user_id
// 		users, _ := InsertTestUser()
// 		c.Set("user_id", users[0].ID)
// 		userController.Me(c)
// 	})

// 	req, _ := http.NewRequest(http.MethodGet, "/api/user/me", nil)
// 	w := httptest.NewRecorder()

// 	r.ServeHTTP(w, req)

// 	assert.Equal(t, http.StatusOK, w.Code)

// 	type Resp struct {
// 		Data entities.User `json:"data"`
// 	}
// 	var resp Resp
// 	err := json.Unmarshal(w.Body.Bytes(), &resp)
// 	assert.Nil(t, err)
// 	assert.Equal(t, "admin", resp.Data.Name)
// }

// // Test Update
// func Test_Update_OK(t *testing.T) {
// 	r := SetUpRoutes()
// 	userController := SetupControllerUser()
// 	r.PUT("/api/user", func(c *gin.Context) {
// 		users, _ := InsertTestUser()
// 		c.Set("user_id", users[1].ID)
// 		userController.Update(c)
// 	})

// 	update := dto.UserUpdateRequest{
// 		Name:       "updatedName",
// 		// TelpNumber: "87654321",
// 	}
// 	body, _ := json.Marshal(update)
// 	req, _ := http.NewRequest(http.MethodPut, "/api/user", bytes.NewBuffer(body))
// 	req.Header.Set("Content-Type", "application/json")
// 	w := httptest.NewRecorder()

// 	r.ServeHTTP(w, req)

// 	assert.Equal(t, http.StatusOK, w.Code)

// 	type Resp struct {
// 		Data entities.User `json:"data"`
// 	}
// 	var resp Resp
// 	err := json.Unmarshal(w.Body.Bytes(), &resp)
// 	assert.Nil(t, err)
// 	assert.Equal(t, update.Name, resp.Data.Name)
// }

// // Test Delete
// func Test_Delete_OK(t *testing.T) {
// 	r := SetUpRoutes()
// 	userController := SetupControllerUser()
// 	r.DELETE("/api/user", func(c *gin.Context) {
// 		users, _ := InsertTestUser()
// 		c.Set("user_id", users[0].ID)
// 		userController.Delete(c)
// 	})

// 	req, _ := http.NewRequest(http.MethodDelete, "/api/user", nil)
// 	w := httptest.NewRecorder()

// 	r.ServeHTTP(w, req)

// 	assert.Equal(t, http.StatusOK, w.Code)
// }