# Coming soon!
go get github.com/team-connect/go

# For now, use standard library net/http
# No external dependencies needed!

// Future module usage
package main

import (
    "context"
    "fmt"
    "log"
    
    "github.com/team-connect/go/teamconnect"
)

func main() {
    // Initialize with your API key
    client := teamconnect.NewClient("tc_live_your_api_key_here")
    
    ctx := context.Background()
    
    // Make a voice call
    callResult, err := client.Voice.MakeCall(ctx, &teamconnect.CallRequest{
        To:      "+447123456789",
        Message: "Hello from Team Connect!",
    })
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Call initiated: %s\n", callResult.CallID)
    
    // Send an SMS
    smsResult, err := client.SMS.Send(ctx, &teamconnect.SMSRequest{
        To:      "+447123456789",
        Message: "Your verification code is 123456",
    })
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("SMS sent: %s\n", smsResult.MessageID)
    
    // Send an email
    emailResult, err := client.Email.Send(ctx, &teamconnect.EmailRequest{
        To:      "customer@example.com",
        Subject: "Welcome to our service",
        HTML:    "
Welcome!
Thanks for signing up.
",
    })
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Email sent: %s\n", emailResult.MessageID)
    
    // AI Chat
    aiResult, err := client.AI.Chat(ctx, &teamconnect.ChatRequest{
        Messages: []teamconnect.Message{
            {Role: "system", Content: "You are a helpful assistant."},
            {Role: "user", Content: "Hello!"},
        },
    })
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("AI Response: %s\n", aiResult.Response)
}

package main

import (
    "context"
    "fmt"
    "log"
    "time"
)

// Voice call helper with context and timeout
func makeCall(client *TeamConnectClient, to, message string, options map[string]interface{}) error {
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()

    data := map[string]interface{}{
        "to":      to,
        "message": message,
    }

    // Add optional parameters
    for key, value := range options {
        data[key] = value
    }

    resp, err := client.MakeRequest(ctx, "voice", "make_call", data)
    if err != nil {
        return fmt.Errorf("call failed: %w", err)
    }

    if !resp.Success {
        return fmt.Errorf("call failed: %s", resp.Error)
    }

    fmt.Printf("✅ Call initiated successfully!\n")
    if callID, ok := resp.Result["call_id"].(string); ok {
        fmt.Printf("Call ID: %s\n", callID)
    }
    if status, ok := resp.Result["status"].(string); ok {
        fmt.Printf("Status: %s\n", status)
    }
    if billing := resp.Billing; billing != nil {
        if cost, ok := billing["costFormatted"].(string); ok {
            fmt.Printf("Cost: %s\n", cost)
        }
        if remaining, ok := billing["creditsRemainingFormatted"].(string); ok {
            fmt.Printf("Credits remaining: %s\n", remaining)
        }
    }

    return nil
}

// Appointment confirmation system
type Appointment struct {
    ID           string
    CustomerName string
    CustomerPhone string
    ServiceType  string
    DateTime     time.Time
}

func sendAppointmentConfirmation(client *TeamConnectClient, appointment *Appointment) error {
    message := fmt.Sprintf(
        "Hi %s, this is confirming your %s appointment tomorrow at %s. Reply YES to confirm or NO to reschedule.",
        appointment.CustomerName,
        appointment.ServiceType,
        appointment.DateTime.Format("3:04 PM"),
    )

    return makeCall(client, appointment.CustomerPhone, message, map[string]interface{}{
        "voice": "Polly.Amy",
        "webhook_url": fmt.Sprintf("https://yourapp.com/webhooks/appointment/%s", appointment.ID),
    })
}

// Payment reminder system
type Invoice struct {
    ID           string
    CustomerName string
    CustomerPhone string
    Amount       float64
    PaymentURL   string
}

func sendPaymentReminder(client *TeamConnectClient, invoice *Invoice) error {
    message := fmt.Sprintf(
        "Hello %s, this is a friendly reminder that your payment of £%.2f is due. You can pay online at %s or call us back.",
        invoice.CustomerName,
        invoice.Amount,
        invoice.PaymentURL,
    )

    return makeCall(client, invoice.CustomerPhone, message, map[string]interface{}{})
}

func main() {
    client := NewTeamConnectClient("tc_live_your_api_key_here")

    // Example appointment confirmation
    appointment := &Appointment{
        ID:           "apt_123",
        CustomerName: "John Doe",
        CustomerPhone: "+447123456789",
        ServiceType:  "dental cleaning",
        DateTime:     time.Now().Add(24 * time.Hour),
    }

    if err := sendAppointmentConfirmation(client, appointment); err != nil {
        log.Printf("Failed to send appointment confirmation: %v", err)
    }

    // Example payment reminder
    invoice := &Invoice{
        ID:           "inv_456",
        CustomerName: "Jane Smith",
        CustomerPhone: "+447123456790",
        Amount:       125.50,
        PaymentURL:   "https://pay.example.com/inv_456",
    }

    if err := sendPaymentReminder(client, invoice); err != nil {
        log.Printf("Failed to send payment reminder: %v", err)
    }
}

package main

import (
    "context"
    "crypto/rand"
    "fmt"
    "math/big"
    "sync"
    "time"
)

// SMS helper with context
func sendSMS(client *TeamConnectClient, to, message string, options map[string]interface{}) error {
    ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
    defer cancel()

    data := map[string]interface{}{
        "to":      to,
        "message": message,
    }

    for key, value := range options {
        data[key] = value
    }

    resp, err := client.MakeRequest(ctx, "sms", "send", data)
    if err != nil {
        return fmt.Errorf("SMS failed: %w", err)
    }

    if !resp.Success {
        return fmt.Errorf("SMS failed: %s", resp.Error)
    }

    fmt.Printf("✅ SMS sent successfully!\n")
    if messageID, ok := resp.Result["message_id"].(string); ok {
        fmt.Printf("Message ID: %s\n", messageID)
    }

    return nil
}

// 2FA system with concurrent sending
type TwoFactorAuth struct {
    client *TeamConnectClient
    codes  sync.Map // thread-safe map for storing codes
}

func NewTwoFactorAuth(client *TeamConnectClient) *TwoFactorAuth {
    return &TwoFactorAuth{
        client: client,
    }
}

func (tfa *TwoFactorAuth) GenerateCode() (string, error) {
    // Generate 6-digit code
    max := big.NewInt(900000)
    n, err := rand.Int(rand.Reader, max)
    if err != nil {
        return "", err
    }
    return fmt.Sprintf("%06d", n.Int64()+100000), nil
}

func (tfa *TwoFactorAuth) SendCode(phone, appName string) (string, error) {
    code, err := tfa.GenerateCode()
    if err != nil {
        return "", fmt.Errorf("generate code: %w", err)
    }

    // Store code with expiry (in production, use Redis or database)
    tfa.codes.Store(phone, map[string]interface{}{
        "code":      code,
        "expires":   time.Now().Add(5 * time.Minute),
        "attempts":  0,
    })

    message := fmt.Sprintf("Your %s verification code: %s", appName, code)
    
    if err := sendSMS(tfa.client, phone, message, nil); err != nil {
        tfa.codes.Delete(phone)
        return "", err
    }

    return code, nil
}

func (tfa *TwoFactorAuth) VerifyCode(phone, inputCode string) bool {
    value, exists := tfa.codes.Load(phone)
    if !exists {
        return false
    }

    codeData := value.(map[string]interface{})
    
    // Check expiry
    if time.Now().After(codeData["expires"].(time.Time)) {
        tfa.codes.Delete(phone)
        return false
    }

    // Check attempts
    attempts := codeData["attempts"].(int)
    if attempts >= 3 {
        tfa.codes.Delete(phone)
        return false
    }

    // Update attempts
    codeData["attempts"] = attempts + 1
    tfa.codes.Store(phone, codeData)

    // Verify code
    if codeData["code"].(string) == inputCode {
        tfa.codes.Delete(phone)
        return true
    }

    return false
}

// Order notification system
type Order struct {
    Number      string
    CustomerPhone string
    Status      string
    TrackingURL string
}

func sendOrderUpdates(client *TeamConnectClient, orders []Order) {
    var wg sync.WaitGroup
    semaphore := make(chan struct{}, 10) // Limit concurrent SMS

    for _, order := range orders {
        wg.Add(1)
        go func(o Order) {
            defer wg.Done()
            
            semaphore <- struct{}{}
            defer func() { <-semaphore }()

            message := fmt.Sprintf(
                "Your order #%s is %s. Track: %s",
                o.Number,
                o.Status,
                o.TrackingURL,
            )

            if err := sendSMS(client, o.CustomerPhone, message, nil); err != nil {
                fmt.Printf("Failed to send order update for %s: %v\n", o.Number, err)
            } else {
                fmt.Printf("Order update sent for %s\n", o.Number)
            }
        }(order)
    }

    wg.Wait()
}

func main() {
    client := NewTeamConnectClient("tc_live_your_api_key_here")

    // 2FA example
    tfa := NewTwoFactorAuth(client)
    
    code, err := tfa.SendCode("+447123456789", "Dad-Link")
    if err != nil {
        fmt.Printf("Failed to send 2FA code: %v\n", err)
        return
    }
    
    fmt.Printf("2FA code sent: %s\n", code)
    
    // Simulate verification
    isValid := tfa.VerifyCode("+447123456789", code)
    fmt.Printf("Code verification: %t\n", isValid)

    // Batch order updates
    orders := []Order{
        {Number: "ORD001", CustomerPhone: "+447123456789", Status: "shipped", TrackingURL: "https://track.me/ORD001"},
        {Number: "ORD002", CustomerPhone: "+447123456790", Status: "delivered", TrackingURL: "https://track.me/ORD002"},
        {Number: "ORD003", CustomerPhone: "+447123456791", Status: "processing", TrackingURL: "https://track.me/ORD003"},
    }

    fmt.Println("Sending order updates...")
    sendOrderUpdates(client, orders)
    fmt.Println("All order updates sent")
}

package main

import (
    "bytes"
    "context"
    "fmt"
    "html/template"
    "sync"
    "time"
)

// Email helper with template support
func sendEmail(client *TeamConnectClient, to, subject, html string, options map[string]interface{}) error {
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()

    data := map[string]interface{}{
        "to":      to,
        "subject": subject,
        "html":    html,
    }

    for key, value := range options {
        data[key] = value
    }

    resp, err := client.MakeRequest(ctx, "email", "send", data)
    if err != nil {
        return fmt.Errorf("email failed: %w", err)
    }

    if !resp.Success {
        return fmt.Errorf("email failed: %s", resp.Error)
    }

    fmt.Printf("✅ Email sent successfully!\n")
    if messageID, ok := resp.Result["message_id"].(string); ok {
        fmt.Printf("Message ID: %s\n", messageID)
    }

    return nil
}

// Email template system
type EmailTemplate struct {
    tmpl *template.Template
}

func NewEmailTemplate(templateStr string) (*EmailTemplate, error) {
    tmpl, err := template.New("email").Parse(templateStr)
    if err != nil {
        return nil, fmt.Errorf("parse template: %w", err)
    }
    
    return &EmailTemplate{tmpl: tmpl}, nil
}

func (et *EmailTemplate) Render(data interface{}) (string, error) {
    var buf bytes.Buffer
    if err := et.tmpl.Execute(&buf, data); err != nil {
        return "", fmt.Errorf("execute template: %w", err)
    }
    return buf.String(), nil
}

// Welcome email template
const welcomeEmailTemplate = `



    


    

        

            
Welcome to {{.CompanyName}}!
        
        

            
Hi {{.CustomerName}},
            
Thanks for signing up! Your account is now active and ready to use.
            
Get started by exploring our features:
            

                
🎤 AI Voice Calls
                
💬 SMS Messaging
                
📧 Email Campaigns
                
🤖 AI Chat Integration
            
            Get Started
            
If you have any questions, just reply to this email!
        
        

            
© 2025 {{.CompanyName}}. All rights reserved.
            
You received this email because you signed up for our service.
        
    


`

type WelcomeEmailData struct {
    CustomerName string
    CompanyName  string
    DashboardURL string
}

// Email campaign system
type EmailCampaign struct {
    client    *TeamConnectClient
    template  *EmailTemplate
    semaphore chan struct{}
}

func NewEmailCampaign(client *TeamConnectClient, templateStr string, concurrency int) (*EmailCampaign, error) {
    tmpl, err := NewEmailTemplate(templateStr)
    if err != nil {
        return nil, err
    }

    return &EmailCampaign{
        client:    client,
        template:  tmpl,
        semaphore: make(chan struct{}, concurrency),
    }, nil
}

type EmailRecipient struct {
    Email string
    Data  interface{}
}

func (ec *EmailCampaign) SendBatch(subject string, recipients []EmailRecipient) []error {
    var wg sync.WaitGroup
    errors := make([]error, len(recipients))

    for i, recipient := range recipients {
        wg.Add(1)
        go func(index int, rcpt EmailRecipient) {
            defer wg.Done()
            
            // Rate limiting
            ec.semaphore <- struct{}{}
            defer func() { <-ec.semaphore }()

            // Render template
            html, err := ec.template.Render(rcpt.Data)
            if err != nil {
                errors[index] = fmt.Errorf("render template: %w", err)
                return
            }

            // Send email
            if err := sendEmail(ec.client, rcpt.Email, subject, html, map[string]interface{}{
                "from_name": "Dad-Link Team",
            }); err != nil {
                errors[index] = err
            }
        }(i, recipient)
    }

    wg.Wait()
    return errors
}

// Invoice email system
const invoiceEmailTemplate = `



    


    

        

            
Invoice #{{.InvoiceNumber}}
        
        

            
Hi {{.CustomerName}},
            
Your invoice is ready for payment.
            
Amount Due: £{{printf "%.2f" .Amount}}
            
Due Date: {{.DueDate.Format "January 2, 2006"}}
            Pay Now
        
    


`

type InvoiceEmailData struct {
    CustomerName  string
    InvoiceNumber string
    Amount        float64
    DueDate       time.Time
    PaymentURL    string
}

func main() {
    client := NewTeamConnectClient("tc_live_your_api_key_here")

    // Welcome email campaign
    campaign, err := NewEmailCampaign(client, welcomeEmailTemplate, 5)
    if err != nil {
        fmt.Printf("Failed to create campaign: %v\n", err)
        return
    }

    recipients := []EmailRecipient{
        {
            Email: "john@example.com",
            Data: WelcomeEmailData{
                CustomerName: "John Doe",
                CompanyName:  "Dad-Link",
                DashboardURL: "https://team-connect.co.uk/dashboard.html",
            },
        },
        {
            Email: "jane@example.com",
            Data: WelcomeEmailData{
                CustomerName: "Jane Smith",
                CompanyName:  "Dad-Link",
                DashboardURL: "https://team-connect.co.uk/dashboard.html",
            },
        },
    }

    fmt.Println("Sending welcome email campaign...")
    errors := campaign.SendBatch("Welcome to Dad-Link - Your Account is Ready!", recipients)
    
    successCount := 0
    for i, err := range errors {
        if err == nil {
            successCount++
            fmt.Printf("✅ Email %d sent successfully\n", i+1)
        } else {
            fmt.Printf("❌ Email %d failed: %v\n", i+1, err)
        }
    }

    fmt.Printf("Campaign complete: %d/%d successful\n", successCount, len(recipients))

    // Single invoice email
    invoiceTemplate, err := NewEmailTemplate(invoiceEmailTemplate)
    if err != nil {
        fmt.Printf("Failed to create invoice template: %v\n", err)
        return
    }

    invoiceData := InvoiceEmailData{
        CustomerName:  "Alice Johnson",
        InvoiceNumber: "INV-2025-001",
        Amount:        125.50,
        DueDate:       time.Now().Add(30 * 24 * time.Hour),
        PaymentURL:    "https://pay.dad-link.com/INV-2025-001",
    }

    html, err := invoiceTemplate.Render(invoiceData)
    if err != nil {
        fmt.Printf("Failed to render invoice: %v\n", err)
        return
    }

    if err := sendEmail(client, "alice@example.com", "Invoice #INV-2025-001 - Payment Due", html, map[string]interface{}{
        "from_name": "Dad-Link Billing",
    }); err != nil {
        fmt.Printf("Failed to send invoice: %v\n", err)
    }
}

package main

import (
    "context"
    "fmt"
    "sync"
    "time"
)

// AI Chat helper
func chatAI(client *TeamConnectClient, messages []map[string]string, model string) (string, error) {
    ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
    defer cancel()

    if model == "" {
        model = "gpt-4"
    }

    data := map[string]interface{}{
        "messages": messages,
        "model":    model,
    }

    resp, err := client.MakeRequest(ctx, "ai", "chat", data)
    if err != nil {
        return "", fmt.Errorf("AI chat failed: %w", err)
    }

    if !resp.Success {
        return "", fmt.Errorf("AI chat failed: %s", resp.Error)
    }

    if response, ok := resp.Result["response"].(string); ok {
        return response, nil
    }

    return "", fmt.Errorf("invalid response format")
}

// Customer support bot
type CustomerSupportBot struct {
    client        *TeamConnectClient
    conversations sync.Map // thread-safe conversation storage
}

func NewCustomerSupportBot(client *TeamConnectClient) *CustomerSupportBot {
    return &CustomerSupportBot{
        client: client,
    }
}

type Conversation struct {
    Messages []map[string]string
    LastUsed time.Time
}

func (bot *CustomerSupportBot) SendMessage(userID, message string) (string, error) {
    // Load or create conversation
    var conv *Conversation
    if value, exists := bot.conversations.Load(userID); exists {
        conv = value.(*Conversation)
    } else {
        conv = &Conversation{
            Messages: []map[string]string{
                {
                    "role":    "system",
                    "content": "You are a helpful customer support assistant for Dad-Link, a communication platform. Be friendly and provide accurate information about our voice, SMS, email, and AI services.",
                },
            },
        }
    }

    // Add user message
    conv.Messages = append(conv.Messages, map[string]string{
        "role":    "user",
        "content": message,
    })

    // Get AI response
    response, err := chatAI(bot.client, conv.Messages, "gpt-4")
    if err != nil {
        return "", err
    }

    // Add AI response to conversation
    conv.Messages = append(conv.Messages, map[string]string{
        "role":    "assistant",
        "content": response,
    })

    // Update conversation
    conv.LastUsed = time.Now()
    bot.conversations.Store(userID, conv)

    return response, nil
}

func (bot *CustomerSupportBot) ClearOldConversations() {
    cutoff := time.Now().Add(-24 * time.Hour)
    
    bot.conversations.Range(func(key, value interface{}) bool {
        conv := value.(*Conversation)
        if conv.LastUsed.Before(cutoff) {
            bot.conversations.Delete(key)
        }
        return true
    })
}

// Content generation system
type ContentGenerator struct {
    client *TeamConnectClient
}

func NewContentGenerator(client *TeamConnectClient) *ContentGenerator {
    return &ContentGenerator{client: client}
}

func (cg *ContentGenerator) GenerateEmailSubjects(product, audience string, count int) ([]string, error) {
    prompt := fmt.Sprintf(
        "Generate %d compelling email subject lines for %s targeting %s. Make them engaging and click-worthy. Return only the subject lines, one per line.",
        count, product, audience,
    )

    messages := []map[string]string{
        {
            "role":    "system",
            "content": "You are a marketing copywriter specializing in email subject lines.",
        },
        {
            "role":    "user",
            "content": prompt,
        },
    }

    response, err := chatAI(cg.client, messages, "gpt-4")
    if err != nil {
        return nil, err
    }

    // Parse response into lines
    subjects := []string{}
    lines := splitLines(response)
    for _, line := range lines {
        if trimmed := trimString(line); trimmed != "" {
            subjects = append(subjects, trimmed)
        }
    }

    return subjects, nil
}

func (cg *ContentGenerator) GenerateProductDescription(product, features string) (string, error) {
prompt := fmt.Sprintf(
    "Write a compelling product description for %s with these features: %s. Make it professional and persuasive.",
    product, features,
)

messages := []map[string]string{
    {
        "role":    "system",
        "content": "You are a product marketing specialist who writes compelling product descriptions.",
    },
    {
        "role":    "user",
        "content": prompt,
    },
}

return chatAI(cg.client, messages, "gpt-4")
}

// Concurrent AI processing
func (cg *ContentGenerator) GenerateBatchContent(requests []string) []string {
results := make([]string, len(requests))
var wg sync.WaitGroup
semaphore := make(chan struct{}, 3) // Limit concurrent AI requests

for i, request := range requests {
    wg.Add(1)
    go func(index int, prompt string) {
        defer wg.Done()
        
        semaphore <- struct{}{}
        defer func() { <-semaphore }()

        messages := []map[string]string{
            {
                "role":    "system",
                "content": "You are a helpful AI assistant.",
            },
            {
                "role":    "user",
                "content": prompt,
            },
        }

        response, err := chatAI(cg.client, messages, "gpt-4")
        if err != nil {
            results[index] = fmt.Sprintf("Error: %v", err)
        } else {
            results[index] = response
        }
    }(i, request)
}

wg.Wait()
return results
}

// Helper functions
func splitLines(text string) []string {
// Simple line splitting - in production, use strings.Split
lines := []string{}
current := ""
for _, char := range text {
    if char == '\n' {
        lines = append(lines, current)
        current = ""
    } else {
        current += string(char)
    }
}
if current != "" {
    lines = append(lines, current)
}
return lines
}

func trimString(s string) string {
// Simple trim - in production, use strings.TrimSpace
for len(s) > 0 && (s[0] == ' ' || s[0] == '\t' || s[0] == '\n' || s[0] == '\r') {
    s = s[1:]
}
for len(s) > 0 && (s[len(s)-1] == ' ' || s[len(s)-1] == '\t' || s[len(s)-1] == '\n' || s[len(s)-1] == '\r') {
    s = s[:len(s)-1]
}
return s
}

func main() {
client := NewTeamConnectClient("tc_live_your_api_key_here")

// Customer support bot example
bot := NewCustomerSupportBot(client)

// Simulate customer conversation
response1, err := bot.SendMessage("user123", "Hello, how can I integrate voice calls into my Go application?")
if err != nil {
    fmt.Printf("Bot error: %v\n", err)
    return
}
fmt.Printf("Bot: %s\n\n", response1)

response2, err := bot.SendMessage("user123", "What's the pricing for voice calls?")
if err != nil {
    fmt.Printf("Bot error: %v\n", err)
    return
}
fmt.Printf("Bot: %s\n\n", response2)

// Content generation example
generator := NewContentGenerator(client)

subjects, err := generator.GenerateEmailSubjects("Team Connect API", "software developers", 5)
if err != nil {
    fmt.Printf("Content generation error: %v\n", err)
    return
}

fmt.Println("Generated email subjects:")
for i, subject := range subjects {
    fmt.Printf("%d. %s\n", i+1, subject)
}

// Batch content generation
prompts := []string{
    "Write a tagline for a communication API",
    "Create a tweet about voice AI technology",
    "Generate a LinkedIn post about developer tools",
}

fmt.Println("\nBatch content generation:")
results := generator.GenerateBatchContent(prompts)
for i, result := range results {
    fmt.Printf("Prompt %d result: %s\n\n", i+1, result)
}

// Clean up old conversations
bot.ClearOldConversations()
}

// Custom error types
type TeamConnectError struct {
Code    string
Message string
Cause   error
}

func (e *TeamConnectError) Error() string {
if e.Cause != nil {
    return fmt.Sprintf("%s: %s (caused by: %v)", e.Code, e.Message, e.Cause)
}
return fmt.Sprintf("%s: %s", e.Code, e.Message)
}

func (e *TeamConnectError) Unwrap() error {
return e.Cause
}

// Specific error types
var (
ErrInvalidAPIKey       = &TeamConnectError{Code: "INVALID_API_KEY", Message: "Invalid or revoked API key"}
ErrInsufficientCredits = &TeamConnectError{Code: "INSUFFICIENT_CREDITS", Message: "Insufficient credits"}
ErrRateLimitExceeded   = &TeamConnectError{Code: "RATE_LIMIT_EXCEEDED", Message: "Rate limit exceeded"}
ErrServiceUnavailable  = &TeamConnectError{Code: "SERVICE_UNAVAILABLE", Message: "Service temporarily unavailable"}
)

// Enhanced client with circuit breaker
type EnhancedTeamConnectClient struct {
*TeamConnectClient
circuitBreaker *CircuitBreaker
metrics        *Metrics
}

type CircuitBreaker struct {
maxFailures    int
resetTimeout   time.Duration
failureCount   int
lastFailure    time.Time
state          string // "CLOSED", "OPEN", "HALF_OPEN"
mutex          sync.RWMutex
}

func NewCircuitBreaker(maxFailures int, resetTimeout time.Duration) *CircuitBreaker {
return &CircuitBreaker{
    maxFailures:  maxFailures,
    resetTimeout: resetTimeout,
    state:        "CLOSED",
}
}

func (cb *CircuitBreaker) Call(fn func() error) error {
cb.mutex.RLock()
state := cb.state
failureCount := cb.failureCount
lastFailure := cb.lastFailure
cb.mutex.RUnlock()

if state == "OPEN" {
    if time.Since(lastFailure) > cb.resetTimeout {
        cb.mutex.Lock()
        cb.state = "HALF_OPEN"
        cb.mutex.Unlock()
    } else {
        return &TeamConnectError{
            Code:    "CIRCUIT_BREAKER_OPEN",
            Message: "Circuit breaker is open",
        }
    }
}

err := fn()

cb.mutex.Lock()
defer cb.mutex.Unlock()

if err != nil {
    cb.failureCount++
    cb.lastFailure = time.Now()

    if cb.failureCount >= cb.maxFailures {
        cb.state = "OPEN"
    }

    return err
}

// Success - reset circuit breaker
cb.failureCount = 0
cb.state = "CLOSED"
return nil
}

type Metrics struct {
RequestCount    int64
SuccessCount    int64
ErrorCount      int64
LastRequestTime time.Time
mutex           sync.RWMutex
}

func (m *Metrics) RecordRequest(success bool) {
m.mutex.Lock()
defer m.mutex.Unlock()

m.RequestCount++
m.LastRequestTime = time.Now()

if success {
    m.SuccessCount++
} else {
    m.ErrorCount++
}
}

func (m *Metrics) GetStats() (int64, int64, int64, time.Time) {
m.mutex.RLock()
defer m.mutex.RUnlock()
return m.RequestCount, m.SuccessCount, m.ErrorCount, m.LastRequestTime
}

func NewEnhancedTeamConnectClient(apiKey string) *EnhancedTeamConnectClient {
return &EnhancedTeamConnectClient{
    TeamConnectClient: NewTeamConnectClient(apiKey),
    circuitBreaker:    NewCircuitBreaker(5, 60*time.Second),
    metrics:          &Metrics{},
}
}

func (c *EnhancedTeamConnectClient) MakeRequestSafe(ctx context.Context, service, action string, data interface{}) (*APIResponse, error) {
var result *APIResponse
var err error

circuitErr := c.circuitBreaker.Call(func() error {
    result, err = c.MakeRequest(ctx, service, action, data)
    return err
})

success := err == nil && circuitErr == nil
c.metrics.RecordRequest(success)

if circuitErr != nil {
    return nil, circuitErr
}

return result, err
}

// Retry wrapper with exponential backoff
func (c *EnhancedTeamConnectClient) MakeRequestWithRetry(ctx context.Context, service, action string, data interface{}, maxRetries int) (*APIResponse, error) {
var lastErr error

for attempt := 0; attempt <= maxRetries; attempt++ {
    resp, err := c.MakeRequestSafe(ctx, service, action, data)
    if err == nil {
        return resp, nil
    }

    lastErr = err

    // Check if error is retryable
    var teamConnectErr *TeamConnectError
    if errors.As(err, &teamConnectErr) {
        switch teamConnectErr.Code {
        case "INVALID_API_KEY", "INSUFFICIENT_CREDITS":
            // Don't retry these errors
            return nil, err
        }
    }

    // Check context cancellation
    if ctx.Err() != nil {
        return nil, ctx.Err()
    }

    // Don't wait after last attempt
    if attempt == maxRetries {
        break
    }

    // Exponential backoff with jitter
    backoff := time.Duration(1<