package processor

import (
	"apskel-pos-be/internal/models"
	"context"
	"testing"

	"github.com/google/uuid"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/mock"
)

// MockUnitRepository is a mock implementation of the unit repository
type MockUnitRepository struct {
	mock.Mock
}

func (m *MockUnitRepository) Create(ctx context.Context, unit *models.Unit) error {
	args := m.Called(ctx, unit)
	return args.Error(0)
}

func (m *MockUnitRepository) GetByID(ctx context.Context, id, organizationID uuid.UUID) (*models.Unit, error) {
	args := m.Called(ctx, id, organizationID)
	if args.Get(0) == nil {
		return nil, args.Error(1)
	}
	return args.Get(0).(*models.Unit), args.Error(1)
}

func (m *MockUnitRepository) GetAll(ctx context.Context, organizationID uuid.UUID, outletID *uuid.UUID, page, limit int, search string) ([]*models.Unit, int, error) {
	args := m.Called(ctx, organizationID, outletID, page, limit, search)
	if args.Get(0) == nil {
		return nil, args.Int(1), args.Error(2)
	}
	return args.Get(0).([]*models.Unit), args.Int(1), args.Error(2)
}

func (m *MockUnitRepository) Update(ctx context.Context, unit *models.Unit) error {
	args := m.Called(ctx, unit)
	return args.Error(0)
}

func (m *MockUnitRepository) Delete(ctx context.Context, id, organizationID uuid.UUID) error {
	args := m.Called(ctx, id, organizationID)
	return args.Error(0)
}

func TestUnitProcessor_Create(t *testing.T) {
	// Create mock repository
	mockRepo := &MockUnitRepository{}

	// Create processor
	processor := NewUnitProcessor(mockRepo)

	// Test data
	organizationID := uuid.New()
	request := &models.CreateUnitRequest{
		Name:         "Gram",
		Abbreviation: "g",
		IsActive:     true,
	}

	// Mock expectations
	mockRepo.On("Create", mock.Anything, mock.AnythingOfType("*models.Unit")).Return(nil)

	// Execute
	result, err := processor.Create(request, organizationID)

	// Assertions
	assert.NoError(t, err)
	assert.NotNil(t, result)
	assert.Equal(t, request.Name, result.Name)
	assert.Equal(t, request.Abbreviation, result.Abbreviation)
	assert.Equal(t, request.IsActive, result.IsActive)
	assert.Equal(t, organizationID, result.OrganizationID)

	mockRepo.AssertExpectations(t)
}

func TestUnitProcessor_GetByID(t *testing.T) {
	// Create mock repository
	mockRepo := &MockUnitRepository{}

	// Create processor
	processor := NewUnitProcessor(mockRepo)

	// Test data
	unitID := uuid.New()
	organizationID := uuid.New()
	expectedUnit := &models.Unit{
		ID:             unitID,
		OrganizationID: organizationID,
		Name:           "Gram",
		Abbreviation:   "g",
		IsActive:       true,
	}

	// Mock expectations
	mockRepo.On("GetByID", mock.Anything, unitID, organizationID).Return(expectedUnit, nil)

	// Execute
	result, err := processor.GetByID(unitID, organizationID)

	// Assertions
	assert.NoError(t, err)
	assert.NotNil(t, result)
	assert.Equal(t, expectedUnit.ID, result.ID)
	assert.Equal(t, expectedUnit.Name, result.Name)

	mockRepo.AssertExpectations(t)
}

func TestUnitProcessor_GetAll(t *testing.T) {
	// Create mock repository
	mockRepo := &MockUnitRepository{}

	// Create processor
	processor := NewUnitProcessor(mockRepo)

	// Test data
	organizationID := uuid.New()
	expectedUnits := []*models.Unit{
		{
			ID:             uuid.New(),
			OrganizationID: organizationID,
			Name:           "Gram",
			Abbreviation:   "g",
			IsActive:       true,
		},
		{
			ID:             uuid.New(),
			OrganizationID: organizationID,
			Name:           "Liter",
			Abbreviation:   "L",
			IsActive:       true,
		},
	}

	// Mock expectations
	mockRepo.On("GetAll", mock.Anything, organizationID, (*uuid.UUID)(nil), 1, 10, "").Return(expectedUnits, 2, nil)

	// Execute
	result, err := processor.GetAll(organizationID, nil, 1, 10, "")

	// Assertions
	assert.NoError(t, err)
	assert.NotNil(t, result)
	assert.Len(t, result.Data, 2)
	assert.Equal(t, 2, result.Pagination.Total)

	mockRepo.AssertExpectations(t)
}