error.go

package applause

import (
	"fmt"
	"strings"
)

// ApplauseError is the base interface for all applause errors
type ApplauseError interface {
	error
	Code() string
	Context() map[string]interface{}
}

// ParseError represents an error that occurred during value parsing
type ParseError struct {
	Type     string // The expected type (e.g., "int", "bool")
	Value    string // The value that failed to parse
	Original error  // The underlying error from the parser
}

func (e *ParseError) Error() string {
	if e.Original != nil {
		return fmt.Sprintf("failed to parse '%s' as %s: %v", e.Value, e.Type, e.Original)
	}
	return fmt.Sprintf("failed to parse '%s' as %s", e.Value, e.Type)
}

func (e *ParseError) Code() string {
	return "PARSE_ERROR"
}

func (e *ParseError) Context() map[string]interface{} {
	return map[string]interface{}{
		"type":     e.Type,
		"value":    e.Value,
		"original": e.Original,
	}
}

// TypeMismatchError represents an error when a value is accessed with the wrong type
type TypeMismatchError struct {
	Expected ValueType
	Actual   ValueType
	Value    string
}

func (e *TypeMismatchError) Error() string {
	return fmt.Sprintf("type mismatch: expected %s but value was parsed as %s (value: '%s')", 
		e.Expected, e.Actual, e.Value)
}

func (e *TypeMismatchError) Code() string {
	return "TYPE_MISMATCH"
}

func (e *TypeMismatchError) Context() map[string]interface{} {
	return map[string]interface{}{
		"expected": e.Expected.String(),
		"actual":   e.Actual.String(),
		"value":    e.Value,
	}
}

// ValidationError represents an error that occurred during argument validation
type ValidationError struct {
	Argument string // The name of the argument that failed validation
	Value    string // The value that failed validation
	Message  string // Human-readable validation error message
	Rule     string // The validation rule that was violated
}

func (e *ValidationError) Error() string {
	return fmt.Sprintf("validation failed for argument '%s': %s (value: '%s')", 
		e.Argument, e.Message, e.Value)
}

func (e *ValidationError) Code() string {
	return "VALIDATION_ERROR"
}

func (e *ValidationError) Context() map[string]interface{} {
	return map[string]interface{}{
		"argument": e.Argument,
		"value":    e.Value,
		"rule":     e.Rule,
	}
}

// RequiredError represents an error when a required argument is missing
type RequiredError struct {
	Argument string // The name of the required argument that is missing
	Type     string // "positional" or "flag"
}

func (e *RequiredError) Error() string {
	return fmt.Sprintf("required %s argument '%s' is missing", e.Type, e.Argument)
}

func (e *RequiredError) Code() string {
	return "REQUIRED_ERROR"
}

func (e *RequiredError) Context() map[string]interface{} {
	return map[string]interface{}{
		"argument": e.Argument,
		"type":     e.Type,
	}
}

// UnknownArgumentError represents an error when an unknown argument is provided
type UnknownArgumentError struct {
	Argument   string   // The unknown argument
	Type       string   // "flag" or "subcommand"
	Suggestion string   // Suggested similar argument (optional)
	Available  []string // List of available arguments
}

func (e *UnknownArgumentError) Error() string {
	msg := fmt.Sprintf("unknown %s '%s'", e.Type, e.Argument)
	if e.Suggestion != "" {
		msg += fmt.Sprintf(", did you mean '%s'?", e.Suggestion)
	}
	return msg
}

func (e *UnknownArgumentError) Code() string {
	return "UNKNOWN_ARGUMENT"
}

func (e *UnknownArgumentError) Context() map[string]interface{} {
	return map[string]interface{}{
		"argument":   e.Argument,
		"type":       e.Type,
		"suggestion": e.Suggestion,
		"available":  e.Available,
	}
}

// ConflictError represents an error when conflicting arguments are provided
type ConflictError struct {
	Arguments []string // The conflicting arguments
	Message   string   // Human-readable conflict description
}

func (e *ConflictError) Error() string {
	args := strings.Join(e.Arguments, "', '")
	return fmt.Sprintf("conflicting arguments: '%s' - %s", args, e.Message)
}

func (e *ConflictError) Code() string {
	return "CONFLICT_ERROR"
}

func (e *ConflictError) Context() map[string]interface{} {
	return map[string]interface{}{
		"arguments": e.Arguments,
		"message":   e.Message,
	}
}

// GroupError represents an error related to argument groups
type GroupError struct {
	Group   string   // The name of the group
	Type    string   // The type of group error ("mutually_exclusive" or "required_group")
	Message string   // Human-readable error message
	Args    []string // The arguments involved
}

func (e *GroupError) Error() string {
	return fmt.Sprintf("group '%s' error: %s", e.Group, e.Message)
}

func (e *GroupError) Code() string {
	return "GROUP_ERROR"
}

func (e *GroupError) Context() map[string]interface{} {
	return map[string]interface{}{
		"group":   e.Group,
		"type":    e.Type,
		"message": e.Message,
		"args":    e.Args,
	}
}

// ErrorFormatter provides methods to format errors for display
type ErrorFormatter struct {
	UseColors bool
}

// NewErrorFormatter creates a new error formatter
func NewErrorFormatter() *ErrorFormatter {
	return &ErrorFormatter{
		UseColors: true, // TODO: Detect terminal capability
	}
}

// Format formats an error for display to the user
func (ef *ErrorFormatter) Format(err error) string {
	if applauseErr, ok := err.(ApplauseError); ok {
		return ef.formatApplauseError(applauseErr)
	}
	return err.Error()
}

func (ef *ErrorFormatter) formatApplauseError(err ApplauseError) string {
	var result strings.Builder
	
	// Error prefix with color
	if ef.UseColors {
		result.WriteString("\033[31mError:\033[0m ") // Red "Error:"
	} else {
		result.WriteString("Error: ")
	}
	
	result.WriteString(err.Error())
	
	// Add context-specific suggestions
	switch e := err.(type) {
	case *ParseError:
		if e.Type == "bool" {
			result.WriteString("\n  Valid boolean values: true, false, yes, no, 1, 0, on, off")
		} else if e.Type == "int" {
			result.WriteString("\n  Please provide a valid integer")
		} else if e.Type == "duration" {
			result.WriteString("\n  Valid duration format: 1h30m, 5s, 100ms, etc.")
		}
	case *UnknownArgumentError:
		if len(e.Available) > 0 {
			result.WriteString(fmt.Sprintf("\n  Available %ss: %s", 
				e.Type, strings.Join(e.Available, ", ")))
		}
	case *RequiredError:
		result.WriteString("\n  This argument must be provided")
	}
	
	return result.String()
}

// FormatHelp formats multiple errors with help suggestions
func (ef *ErrorFormatter) FormatHelp(errs []error, commandName string) string {
	var result strings.Builder
	
	for i, err := range errs {
		if i > 0 {
			result.WriteString("\n")
		}
		result.WriteString(ef.Format(err))
	}
	
	result.WriteString(fmt.Sprintf("\n\nFor more information try '%s --help'", commandName))
	return result.String()
}