tm_back/internal/service/customer.go

package service

import (
	"context"
	"errors"

	"github.com/google/uuid"

	"tm/internal/domain"
	"tm/pkg/logger"
)

// CustomerServiceImpl implements the CustomerService interface
type CustomerServiceImpl struct {
	customerRepo domain.CustomerRepository
	logger       logger.Logger
}

// NewCustomerService creates a new customer service
func NewCustomerService(
	customerRepo domain.CustomerRepository,
	logger logger.Logger,
) domain.CustomerService {
	return &CustomerServiceImpl{
		customerRepo: customerRepo,
		logger:       logger,
	}
}

// GetCustomers retrieves customers with pagination (for panel users)
func (s *CustomerServiceImpl) GetCustomers(ctx context.Context, limit, offset int) ([]*domain.Customer, error) {
	s.logger.Info("Retrieving customers", map[string]interface{}{
		"limit":  limit,
		"offset": offset,
	})

	customers, err := s.customerRepo.List(ctx, limit, offset)
	if err != nil {
		s.logger.Error("Failed to retrieve customers", map[string]interface{}{
			"error":  err.Error(),
			"limit":  limit,
			"offset": offset,
		})
		return nil, errors.New("failed to retrieve customers")
	}

	s.logger.Info("Customers retrieved successfully", map[string]interface{}{
		"count":  len(customers),
		"limit":  limit,
		"offset": offset,
	})

	return customers, nil
}

// GetCustomerByID retrieves a customer by ID (for panel users)
func (s *CustomerServiceImpl) GetCustomerByID(ctx context.Context, id uuid.UUID) (*domain.Customer, error) {
	s.logger.Info("Retrieving customer by ID", map[string]interface{}{
		"customer_id": id.String(),
	})

	customer, err := s.customerRepo.GetByID(ctx, id)
	if err != nil {
		s.logger.Error("Failed to retrieve customer", map[string]interface{}{
			"error":       err.Error(),
			"customer_id": id.String(),
		})
		return nil, errors.New("customer not found")
	}

	s.logger.Info("Customer retrieved successfully", map[string]interface{}{
		"customer_id": customer.ID.String(),
		"email":       customer.Email,
	})

	return customer, nil
}

// GetCustomersByCompany retrieves customers by company ID with pagination (for panel users)
func (s *CustomerServiceImpl) GetCustomersByCompany(ctx context.Context, companyID uuid.UUID, limit, offset int) ([]*domain.Customer, error) {
	s.logger.Info("Retrieving customers by company", map[string]interface{}{
		"company_id": companyID.String(),
		"limit":      limit,
		"offset":     offset,
	})

	customers, err := s.customerRepo.GetByCompanyID(ctx, companyID, limit, offset)
	if err != nil {
		s.logger.Error("Failed to retrieve customers by company", map[string]interface{}{
			"error":      err.Error(),
			"company_id": companyID.String(),
			"limit":      limit,
			"offset":     offset,
		})
		return nil, errors.New("failed to retrieve customers")
	}

	s.logger.Info("Customers by company retrieved successfully", map[string]interface{}{
		"count":      len(customers),
		"company_id": companyID.String(),
		"limit":      limit,
		"offset":     offset,
	})

	return customers, nil
}

// UpdateCustomerStatus updates customer active status (for panel users)
func (s *CustomerServiceImpl) UpdateCustomerStatus(ctx context.Context, customerID uuid.UUID, isActive bool, updatedBy uuid.UUID) error {
	s.logger.Info("Updating customer status", map[string]interface{}{
		"customer_id": customerID.String(),
		"is_active":   isActive,
		"updated_by":  updatedBy.String(),
	})

	// Get customer
	customer, err := s.customerRepo.GetByID(ctx, customerID)
	if err != nil {
		s.logger.Error("Customer not found for status update", map[string]interface{}{
			"error":       err.Error(),
			"customer_id": customerID.String(),
		})
		return errors.New("customer not found")
	}

	// Update status
	customer.IsActive = isActive

	// Save changes
	if err := s.customerRepo.Update(ctx, customer); err != nil {
		s.logger.Error("Failed to update customer status", map[string]interface{}{
			"error":       err.Error(),
			"customer_id": customerID.String(),
			"is_active":   isActive,
			"updated_by":  updatedBy.String(),
		})
		return errors.New("failed to update customer status")
	}

	s.logger.Info("Customer status updated successfully", map[string]interface{}{
		"customer_id": customerID.String(),
		"is_active":   isActive,
		"updated_by":  updatedBy.String(),
	})

	return nil
}

// UpdateCustomerPreferences updates customer preferences (for panel users)
func (s *CustomerServiceImpl) UpdateCustomerPreferences(ctx context.Context, customerID uuid.UUID, preferences *domain.CustomerPreferences) error {
	s.logger.Info("Updating customer preferences", map[string]interface{}{
		"customer_id": customerID.String(),
	})

	// Verify customer exists
	_, err := s.customerRepo.GetByID(ctx, customerID)
	if err != nil {
		s.logger.Error("Customer not found for preferences update", map[string]interface{}{
			"error":       err.Error(),
			"customer_id": customerID.String(),
		})
		return errors.New("customer not found")
	}

	// Update preferences
	if err := s.customerRepo.UpdatePreferences(ctx, customerID, preferences); err != nil {
		s.logger.Error("Failed to update customer preferences", map[string]interface{}{
			"error":       err.Error(),
			"customer_id": customerID.String(),
		})
		return errors.New("failed to update customer preferences")
	}

	s.logger.Info("Customer preferences updated successfully", map[string]interface{}{
		"customer_id": customerID.String(),
	})

	return nil
}