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/auth"
	"erp-mvp/core-service/internal/models"
)

// setClaims устанавливает claims в контекст для тестов
func setClaims(c *gin.Context, orgID uuid.UUID) {
	claims := &auth.Claims{
		UserID:         uuid.New(),
		OrganizationID: orgID,
		Email:          "test@example.com",
		Role:           "admin",
	}
	c.Set("user_id", claims.UserID)
	c.Set("organization_id", claims.OrganizationID)
	c.Set("email", claims.Email)
	c.Set("role", claims.Role)
}

// MockItemService мок для ItemService
type MockItemService struct {
	mock.Mock
}

func (m *MockItemService) GetItems(ctx context.Context, orgID uuid.UUID) ([]*models.Item, error) {
	args := m.Called(ctx, orgID)
	return args.Get(0).([]*models.Item), args.Error(1)
}

func (m *MockItemService) CreateItem(ctx context.Context, orgID uuid.UUID, req *models.CreateItemRequest) (*models.Item, error) {
	args := m.Called(ctx, orgID, req)
	return args.Get(0).(*models.Item), args.Error(1)
}

func (m *MockItemService) GetItem(ctx context.Context, orgID uuid.UUID, itemID uuid.UUID) (*models.Item, error) {
	args := m.Called(ctx, orgID, itemID)
	return args.Get(0).(*models.Item), args.Error(1)
}

func (m *MockItemService) UpdateItem(ctx context.Context, orgID uuid.UUID, itemID uuid.UUID, req *models.CreateItemRequest) (*models.Item, error) {
	args := m.Called(ctx, orgID, itemID, req)
	return args.Get(0).(*models.Item), args.Error(1)
}

func (m *MockItemService) DeleteItem(ctx context.Context, orgID uuid.UUID, itemID uuid.UUID) error {
	args := m.Called(ctx, orgID, itemID)
	return args.Error(0)
}

func (m *MockItemService) SearchItems(ctx context.Context, orgID uuid.UUID, query string, category string) ([]*models.Item, error) {
	args := m.Called(ctx, orgID, query, category)
	return args.Get(0).([]*models.Item), args.Error(1)
}

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

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

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

// TestItemHandler_GetItems_Success тестирует успешное получение товаров
func TestItemHandler_GetItems_Success(t *testing.T) {
	// Arrange
	gin.SetMode(gin.TestMode)

	mockItemService := &MockItemService{}
	handler := handlers.NewItemHandler(mockItemService)

	orgID := uuid.New()
	expectedItems := []*models.Item{
		{
			ID:             uuid.New(),
			OrganizationID: orgID,
			Name:           "Item 1",
			Description:    "Description 1",
			Category:       "electronics",
		},
		{
			ID:             uuid.New(),
			OrganizationID: orgID,
			Name:           "Item 2",
			Description:    "Description 2",
			Category:       "clothing",
		},
	}

	mockItemService.On("GetItems", mock.Anything, orgID).Return(expectedItems, nil)

	router := gin.New()
	router.GET("/items", func(c *gin.Context) {
		setClaims(c, orgID)
		handler.GetItems(c)
	})

	// Act
	w := httptest.NewRecorder()
	req, _ := http.NewRequest("GET", "/items", nil)
	router.ServeHTTP(w, req)

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

	var response []*models.Item
	err := json.Unmarshal(w.Body.Bytes(), &response)
	assert.NoError(t, err)
	assert.Len(t, response, 2)
	assert.Equal(t, "Item 1", response[0].Name)
	assert.Equal(t, "Item 2", response[1].Name)

	mockItemService.AssertExpectations(t)
}

// TestItemHandler_CreateItem_Success тестирует успешное создание товара
func TestItemHandler_CreateItem_Success(t *testing.T) {
	// Arrange
	gin.SetMode(gin.TestMode)

	mockItemService := &MockItemService{}
	handler := handlers.NewItemHandler(mockItemService)

	orgID := uuid.New()
	itemID := uuid.New()
	createReq := &models.CreateItemRequest{
		Name:        "New Item",
		Description: "New Description",
		Category:    "electronics",
	}

	expectedItem := &models.Item{
		ID:             itemID,
		OrganizationID: orgID,
		Name:           "New Item",
		Description:    "New Description",
		Category:       "electronics",
	}

	mockItemService.On("CreateItem", mock.Anything, orgID, createReq).Return(expectedItem, nil)

	router := gin.New()
	router.POST("/items", func(c *gin.Context) {
		setClaims(c, orgID)
		handler.CreateItem(c)
	})

	reqBody, _ := json.Marshal(createReq)

	// Act
	w := httptest.NewRecorder()
	req, _ := http.NewRequest("POST", "/items", 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.Item
	err := json.Unmarshal(w.Body.Bytes(), &response)
	assert.NoError(t, err)
	assert.Equal(t, "New Item", response.Name)
	assert.Equal(t, "electronics", response.Category)

	mockItemService.AssertExpectations(t)
}

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

	mockItemService := &MockItemService{}
	handler := handlers.NewItemHandler(mockItemService)

	orgID := uuid.New()

	// Невалидный запрос (пустое имя)
	invalidReq := map[string]interface{}{
		"name":        "", // Пустое имя
		"description": "Description",
		"category":    "electronics",
	}

	router := gin.New()
	router.POST("/items", func(c *gin.Context) {
		setClaims(c, orgID)
		handler.CreateItem(c)
	})

	reqBody, _ := json.Marshal(invalidReq)

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

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

	mockItemService.AssertNotCalled(t, "CreateItem")
}

// TestItemHandler_GetItem_Success тестирует успешное получение товара по ID
func TestItemHandler_GetItem_Success(t *testing.T) {
	// Arrange
	gin.SetMode(gin.TestMode)

	mockItemService := &MockItemService{}
	handler := handlers.NewItemHandler(mockItemService)

	orgID := uuid.New()
	itemID := uuid.New()
	expectedItem := &models.Item{
		ID:             itemID,
		OrganizationID: orgID,
		Name:           "Test Item",
		Description:    "Test Description",
		Category:       "electronics",
	}

	mockItemService.On("GetItem", mock.Anything, itemID, orgID).Return(expectedItem, nil)

	router := gin.New()
	router.GET("/items/:id", func(c *gin.Context) {
		setClaims(c, orgID)
		handler.GetItem(c)
	})

	// Act
	w := httptest.NewRecorder()
	req, _ := http.NewRequest("GET", "/items/"+itemID.String(), nil)
	router.ServeHTTP(w, req)

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

	var response models.Item
	err := json.Unmarshal(w.Body.Bytes(), &response)
	assert.NoError(t, err)
	assert.Equal(t, "Test Item", response.Name)
	assert.Equal(t, itemID, response.ID)

	mockItemService.AssertExpectations(t)
}

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

	mockItemService := &MockItemService{}
	handler := handlers.NewItemHandler(mockItemService)

	orgID := uuid.New()
	expectedItems := []*models.Item{
		{
			ID:             uuid.New(),
			OrganizationID: orgID,
			Name:           "Search Result",
			Description:    "Found item",
			Category:       "electronics",
		},
	}

	mockItemService.On("SearchItems", mock.Anything, orgID, "search", "electronics").Return(expectedItems, nil)

	router := gin.New()
	router.GET("/items/search", func(c *gin.Context) {
		setClaims(c, orgID)
		handler.SearchItems(c)
	})

	// Act
	w := httptest.NewRecorder()
	req, _ := http.NewRequest("GET", "/items/search?q=search&category=electronics", nil)
	router.ServeHTTP(w, req)

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

	var response []*models.Item
	err := json.Unmarshal(w.Body.Bytes(), &response)
	assert.NoError(t, err)
	assert.Len(t, response, 1)
	assert.Equal(t, "Search Result", response[0].Name)

	mockItemService.AssertExpectations(t)
}