Comprehensive comparison for AI technology in applications

package main

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"log"
	"net/http"
	"strings"
	"time"
)

// AIContentModerationService handles content moderation using AI
type AIContentModerationService struct {
	apiKey     string
	endpoint   string
	httpClient *http.Client
}

// ModerationRequest represents the input for content moderation
type ModerationRequest struct {
	Content string `json:"content"`
	UserID  string `json:"user_id"`
}

// ModerationResponse represents the AI moderation result
type ModerationResponse struct {
	IsSafe     bool     `json:"is_safe"`
	Categories []string `json:"categories"`
	Confidence float64  `json:"confidence"`
	ProcessedAt time.Time `json:"processed_at"`
}

// NewAIModerationService creates a new moderation service instance
func NewAIModerationService(apiKey, endpoint string) *AIContentModerationService {
	return &AIContentModerationService{
		apiKey:   apiKey,
		endpoint: endpoint,
		httpClient: &http.Client{
			Timeout: 10 * time.Second,
		},
	}
}

// ModerateContent analyzes content for safety violations
func (s *AIContentModerationService) ModerateContent(ctx context.Context, req ModerationRequest) (*ModerationResponse, error) {
	// Validate input
	if strings.TrimSpace(req.Content) == "" {
		return nil, errors.New("content cannot be empty")
	}
	if req.UserID == "" {
		return nil, errors.New("user_id is required")
	}

	// Simulate AI API call with timeout
	select {
	case <-ctx.Done():
		return nil, ctx.Err()
	case <-time.After(100 * time.Millisecond):
		// Simulated AI processing logic
		isSafe := !containsUnsafeContent(req.Content)
		categories := detectCategories(req.Content)
		confidence := calculateConfidence(req.Content)

		return &ModerationResponse{
			IsSafe:      isSafe,
			Categories:  categories,
			Confidence:  confidence,
			ProcessedAt: time.Now(),
		}, nil
	}
}

// HTTP handler for the moderation endpoint
func (s *AIContentModerationService) HandleModeration(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
		return
	}

	var req ModerationRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, fmt.Sprintf("Invalid request body: %v", err), http.StatusBadRequest)
		return
	}
	defer r.Body.Close()

	ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second)
	defer cancel()

	result, err := s.ModerateContent(ctx, req)
	if err != nil {
		log.Printf("Moderation error for user %s: %v", req.UserID, err)
		http.Error(w, "Moderation failed", http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusOK)
	json.NewEncoder(w).Encode(result)
}

// Helper functions for content analysis
func containsUnsafeContent(content string) bool {
	unsafeKeywords := []string{"spam", "abuse", "threat"}
	lower := strings.ToLower(content)
	for _, keyword := range unsafeKeywords {
		if strings.Contains(lower, keyword) {
			return true
		}
	}
	return false
}

func detectCategories(content string) []string {
	categories := []string{}
	if len(content) > 500 {
		categories = append(categories, "long_form")
	}
	if strings.Contains(strings.ToLower(content), "http") {
		categories = append(categories, "contains_links")
	}
	return categories
}

func calculateConfidence(content string) float64 {
	if len(content) < 10 {
		return 0.5
	}
	return 0.95
}

func main() {
	service := NewAIModerationService("sk-test-key", "https://api.example.com/moderate")
	http.HandleFunc("/api/moderate", service.HandleModeration)
	log.Println("AI Moderation service running on :8080")
	log.Fatal(http.ListenAndServe(":8080", nil))
}