// file: util/errs/errs.go
package errs

// ErrorType defines a type for different error categories in the service layer
type ErrorType string

const (
 // Input and Request Issues
 ErrInvalidRequest ErrorType = "invalid_request"  // Malformed JSON, missing/invalid fields
 ErrValidation     ErrorType = "validation_error" // Field-level validation (business rules)

 // Authentication and Authorization
 ErrAuthentication ErrorType = "authentication_error" // Invalid credentials
 ErrAuthorization  ErrorType = "authorization_error"  // Permission denied

 // Resource State Issues
 ErrResourceNotFound ErrorType = "resource_not_found"   // Missing entity
 ErrDuplicateEntry   ErrorType = "duplicate_entry"      // Conflict (e.g., unique constraint)
 ErrBusinessLogic    ErrorType = "business_logic_error" // Violations of business rules

 // Infrastructure and General Failures
 ErrDataIntegrity     ErrorType = "data_integrity_error" // Foreign key, constraint violations
 ErrDatabaseFailure   ErrorType = "database_failure"     // DB-level errors
 ErrServiceDependency ErrorType = "service_dependency"   // External service unavailability
 ErrOperationFailed   ErrorType = "operation_failed"     // Generic internal failures
)

// AppError represents a structured error used in the service layer
type AppError struct {
 Type       ErrorType      `json:"type"`        // Error category
 Message    string         `json:"message"`     // Friendly message for clients
}

// Error implements the error interface
func (e *AppError) Error() string {
 return fmt.Sprintf("[%s] %s", e.Type, e.Message)
}

// NewAppError creates a new AppError
func NewAppError(typ ErrorType, message string) *AppError {
 return &AppError{
  Type:       typ,
  Message:    message,
 }
}

// GetErrorType extracts the error type from an error
func GetErrorType(err error) ErrorType {
 if appErr, ok := err.(*AppError); ok {
  return appErr.Type
 }
 return ErrOperationFailed // Default error type if not recognized
}

// file: repository/customer.go
package repository

import (
 "context"
 "database/sql"
 "fmt"
 "time"

 "github.com/lib/pq"

 "my-app/models"
)

type UserRepository struct {
 db *sql.DB
}

func NewUserRepository(db *sql.DB) *UserRepository {
 return &UserRepository{db *sql.DB}
}

func (r *UserRepository) Create(ctx context.Context, user *models.User) error {
 query := `INSERT INTO public.users (email, name) VALUES ($1, $2) RETURING id`

 err := r.db.QueryRowContext(ctx, query, user.Email, user.Name).
 Scan(&user.ID)
 if err != nil {
  // Detect duplicate entry (Postgres unique_violation code: 23505)
  if pqErr, ok := err.(*pq.Error); ok {
   if pqErr.Code == "23505" {
    return NewAppError(ErrDuplicateEntry, "email already registered")
   }
  }
  // Wrap database error
  return fmt.Errorf("failed to create user: %w", err)
 }

 return nil
}

// service/user.go
package service

import (
 "context"
 "log"
 "my-app/dtos"
 "my-app/models"
 "my-app/repository"
 "my-app/util/errs"
)

type UserService struct {
 userRepo *repository.UserRepository
}

func NewOrderService(userRepo repository.UserRepository) *UserService {
 return &UserService{userRepo: userRepo}
}

func (s *UserService) CreateUser(ctx context.Context, req *dtos.User) (int, error) {
  // validation input
 if req.Email == "" {
  return errs.NewAppError(errors.ErrValidation, "email is required")
 }

 user := &models.User{
  Email: req.Email,
  Name:  req.Name,
 }

 err := s.userRepo.Create(ctx, user)
 if err != nil {
  // log unexpected error
  log.Println(err)
  // handle repository error
  if ErrDuplicateEntry == errs.GetErrorType(err) {
   return err
  }
  return errs.NewAppErr(ErrDatabaseFailure, "failed to create user")
 }

 return user.ID, nil
}

// file: handler/user.go
package handler

import (
 "github.com/gin-gonic/gin"
 "my-app/service"
 "my-app/dtos"
 "my-app/util/errs"
 "net/http"
)

type UserHandler struct {
 service *service.UserService
}

func NewUserHandler(srv service.UserService) *UserHandler{
 return &UserHandler{service: srv}
}

func (h *UserHandler) CreateUser(c *gin.Context) {
 var user dtos.User
 if err := c.ShouldBindJSON(&user); err != nil {
  // Invalid JSON format error
  h.handleError(c, errs.NewAppError(errors.ErrJSONParse, "invalid JSON format"))
  return
 }

 id, err := h.service.CreateUser(c.Request.Context(), &user)

 if err != nil {
  // Handle business validation error
  handleError(c, err)
  return
 }

 c.JSON(http.StatusCreated, gin.H{"id": id})
}

// file: handler/handler.go
package handler

import (
 "github.com/gin-gonic/gin"
 "my-app/util/errs"
)

type errorResponse struct {
 ErrorType    errs.ErrorType `json:"error_type"`
 ErrorMessage string         `json:"error_message"`
}

// Centralized error handling
func (h *CustomerHandler) handleError(c *gin.Context, err error) {
 // Convert non-AppError to AppError with type ErrOperationFailed
 appErr, ok := err.(*errs.AppError);
 if !ok {
  appErr = errors.NewAppError(errs.ErrOperationFailed, err.Error())
 }

 // Get the appropriate HTTP status code based on the error type
 statusCode := errs.GetHTTPStatus(err)

 // Return the error in structured JSON format
 c.JSON(statusCode, errorResponse{
  ErrorType:    appErr.Type,
  ErrorMessage: appErr.Message,
 })
}