package handlers_test

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

	"github.com/gin-gonic/gin"
	"github.com/google/uuid"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/mock"

	"erp-mvp/core-service/internal/api/handlers"
	"erp-mvp/core-service/internal/models"
)

// MockAuthService мок для AuthService
type MockAuthService struct {
	mock.Mock
}

func (m *MockAuthService) Register(ctx context.Context, req *models.RegisterRequest) (*models.LoginResponse, error) {
	args := m.Called(ctx, req)
	return args.Get(0).(*models.LoginResponse), args.Error(1)
}

func (m *MockAuthService) Login(ctx context.Context, req *models.LoginRequest) (*models.LoginResponse, error) {
	args := m.Called(ctx, req)
	return args.Get(0).(*models.LoginResponse), args.Error(1)
}

// TestNewAuthHandler тестирует создание AuthHandler
func TestNewAuthHandler(t *testing.T) {
	// Arrange
	mockService := &MockAuthService{}

	// Act
	handler := handlers.NewAuthHandler(mockService)

	// Assert
	assert.NotNil(t, handler)
}

// TestAuthHandler_Register_Success тестирует успешную регистрацию
func TestAuthHandler_Register_Success(t *testing.T) {
	// Arrange
	gin.SetMode(gin.TestMode)

	mockAuthService := &MockAuthService{}
	handler := handlers.NewAuthHandler(mockAuthService)

	router := gin.New()
	router.POST("/register", handler.Register)

	registerReq := &models.RegisterRequest{
		OrganizationName: "Test Workshop",
		UserEmail:        "admin@test.com",
		UserPassword:     "password123",
		OrganizationType: "workshop",
	}

	expectedResponse := &models.LoginResponse{
		Token: "test_token",
		User: models.UserResponse{
			ID:    uuid.New(),
			Email: "admin@test.com",
			Role:  "admin",
		},
		Organization: models.OrganizationResponse{
			ID:   uuid.New(),
			Name: "Test Workshop",
			Type: "workshop",
		},
	}

	mockAuthService.On("Register", mock.Anything, registerReq).Return(expectedResponse, nil)

	reqBody, _ := json.Marshal(registerReq)

	// Act
	w := httptest.NewRecorder()
	req, _ := http.NewRequest("POST", "/register", bytes.NewBuffer(reqBody))
	req.Header.Set("Content-Type", "application/json")
	router.ServeHTTP(w, req)

	// Assert
	assert.Equal(t, http.StatusCreated, w.Code)

	var response models.LoginResponse
	err := json.Unmarshal(w.Body.Bytes(), &response)
	assert.NoError(t, err)
	assert.Equal(t, expectedResponse.Token, response.Token)
	assert.Equal(t, expectedResponse.User.Email, response.User.Email)
	assert.Equal(t, expectedResponse.Organization.Name, response.Organization.Name)

	mockAuthService.AssertExpectations(t)
}

// TestAuthHandler_Register_ValidationError тестирует ошибку валидации при регистрации
func TestAuthHandler_Register_ValidationError(t *testing.T) {
	// Arrange
	gin.SetMode(gin.TestMode)

	mockAuthService := &MockAuthService{}
	handler := handlers.NewAuthHandler(mockAuthService)

	router := gin.New()
	router.POST("/register", handler.Register)

	// Невалидный запрос (пустой email)
	invalidReq := map[string]interface{}{
		"organization_name": "Test Workshop",
		"user_email":        "", // Пустой email
		"user_password":     "password123",
		"organization_type": "workshop",
	}

	reqBody, _ := json.Marshal(invalidReq)

	// Act
	w := httptest.NewRecorder()
	req, _ := http.NewRequest("POST", "/register", bytes.NewBuffer(reqBody))
	req.Header.Set("Content-Type", "application/json")
	router.ServeHTTP(w, req)

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

	mockAuthService.AssertNotCalled(t, "Register")
}

// TestAuthHandler_Login_Success тестирует успешный вход
func TestAuthHandler_Login_Success(t *testing.T) {
	// Arrange
	gin.SetMode(gin.TestMode)

	mockAuthService := &MockAuthService{}
	handler := handlers.NewAuthHandler(mockAuthService)

	router := gin.New()
	router.POST("/login", handler.Login)

	loginReq := &models.LoginRequest{
		Email:    "admin@test.com",
		Password: "password123",
	}

	expectedResponse := &models.LoginResponse{
		Token: "test_token",
		User: models.UserResponse{
			ID:    uuid.New(),
			Email: "admin@test.com",
			Role:  "admin",
		},
		Organization: models.OrganizationResponse{
			ID:   uuid.New(),
			Name: "Test Workshop",
			Type: "workshop",
		},
	}

	mockAuthService.On("Login", mock.Anything, loginReq).Return(expectedResponse, nil)

	reqBody, _ := json.Marshal(loginReq)

	// Act
	w := httptest.NewRecorder()
	req, _ := http.NewRequest("POST", "/login", bytes.NewBuffer(reqBody))
	req.Header.Set("Content-Type", "application/json")
	router.ServeHTTP(w, req)

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

	var response models.LoginResponse
	err := json.Unmarshal(w.Body.Bytes(), &response)
	assert.NoError(t, err)
	assert.Equal(t, expectedResponse.Token, response.Token)
	assert.Equal(t, expectedResponse.User.Email, response.User.Email)

	mockAuthService.AssertExpectations(t)
}

// TestAuthHandler_Login_ValidationError тестирует ошибку валидации при входе
func TestAuthHandler_Login_ValidationError(t *testing.T) {
	// Arrange
	gin.SetMode(gin.TestMode)

	mockAuthService := &MockAuthService{}
	handler := handlers.NewAuthHandler(mockAuthService)

	router := gin.New()
	router.POST("/login", handler.Login)

	// Невалидный запрос (пустой пароль)
	invalidReq := map[string]interface{}{
		"email":    "admin@test.com",
		"password": "", // Пустой пароль
	}

	reqBody, _ := json.Marshal(invalidReq)

	// Act
	w := httptest.NewRecorder()
	req, _ := http.NewRequest("POST", "/login", bytes.NewBuffer(reqBody))
	req.Header.Set("Content-Type", "application/json")
	router.ServeHTTP(w, req)

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

	mockAuthService.AssertNotCalled(t, "Login")
}