# Coming soon!
Install-Package TeamConnect.API

# Or via .NET CLI
dotnet add package TeamConnect.API

# For now, use HttpClient (built into .NET)
# No external dependencies needed!

// Future NuGet package usage
using TeamConnect.API;
using TeamConnect.API.Models;

// Initialize with your API key
var client = new TeamConnectClient("tc_live_your_api_key_here");

// Make a voice call
var callRequest = new CallRequest
{
    To = "+447123456789",
    Message = "Hello from Team Connect!"
};

var callResult = await client.Voice.MakeCallAsync(callRequest);
Console.WriteLine($"Call initiated: {callResult.CallId}");

// Send an SMS
var smsRequest = new SmsRequest
{
    To = "+447123456789",
    Message = "Your verification code is 123456"
};

var smsResult = await client.Sms.SendAsync(smsRequest);
Console.WriteLine($"SMS sent: {smsResult.MessageId}");

// Send an email
var emailRequest = new EmailRequest
{
    To = "customer@example.com",
    Subject = "Welcome to our service",
    Html = "
Welcome!
Thanks for signing up.
"
};

var emailResult = await client.Email.SendAsync(emailRequest);
Console.WriteLine($"Email sent: {emailResult.MessageId}");

// AI Chat
var chatRequest = new ChatRequest
{
    Messages = new[]
    {
        new ChatMessage { Role = "system", Content = "You are a helpful assistant." },
        new ChatMessage { Role = "user", Content = "Hello!" }
    }
};

var aiResult = await client.AI.ChatAsync(chatRequest);
Console.WriteLine($"AI Response: {aiResult.Response}");

// Voice call service with comprehensive features
public class VoiceCallService
{
    private readonly ITeamConnectService _teamConnect;
    private readonly ILogger _logger;

    public VoiceCallService(ITeamConnectService teamConnect, ILogger logger)
    {
        _teamConnect = teamConnect;
        _logger = logger;
    }

    public async Task MakeAppointmentReminderAsync(Appointment appointment, CancellationToken cancellationToken = default)
    {
        var message = $"Hi {appointment.CustomerName}, this is confirming your {appointment.ServiceType} appointment tomorrow at {appointment.DateTime:h:mm tt}. Reply YES to confirm or NO to reschedule.";

        var request = new CallRequest
        {
            To = appointment.CustomerPhone,
            Message = message,
            Voice = "Polly.Amy",
            WebhookUrl = $"https://yourapp.com/webhooks/appointment/{appointment.Id}"
        };

        try
        {
            var (result, billing) = await _teamConnect.MakeCallAsync(request, cancellationToken);

            _logger.LogInformation("Appointment reminder call initiated for {AppointmentId}: {CallId}",
                appointment.Id, result.CallId);

            return new CallResult
            {
                Success = true,
                CallId = result.CallId,
                Status = result.Status,
                Cost = billing.Cost,
                CreditsRemaining = billing.CreditsRemaining
            };
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Failed to make appointment reminder call for {AppointmentId}", appointment.Id);
            
            return new CallResult
            {
                Success = false,
                Error = ex.Message
            };
        }
    }

    public async Task MakePaymentReminderAsync(Invoice invoice, CancellationToken cancellationToken = default)
    {
        var message = $"Hello {invoice.CustomerName}, this is a friendly reminder that your payment of £{invoice.Amount:F2} is due. You can pay online at {invoice.PaymentUrl} or call us back.";

        var request = new CallRequest
        {
            To = invoice.CustomerPhone,
            Message = message,
            WebhookUrl = $"https://yourapp.com/webhooks/payment/{invoice.Id}"
        };

        try
        {
            var (result, billing) = await _teamConnect.MakeCallAsync(request, cancellationToken);

            _logger.LogInformation("Payment reminder call initiated for invoice {InvoiceId}: {CallId}",
                invoice.Id, result.CallId);

            return new CallResult
            {
                Success = true,
                CallId = result.CallId,
                Status = result.Status,
                Cost = billing.Cost,
                CreditsRemaining = billing.CreditsRemaining
            };
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Failed to make payment reminder call for invoice {InvoiceId}", invoice.Id);
            
            return new CallResult
            {
                Success = false,
                Error = ex.Message
            };
        }
    }

    public async Task> MakeBatchCallsAsync(IEnumerable requests, int maxConcurrency = 5, CancellationToken cancellationToken = default)
    {
        var semaphore = new SemaphoreSlim(maxConcurrency, maxConcurrency);
        var tasks = requests.Select(async request =>
        {
            await semaphore.WaitAsync(cancellationToken);
            
            try
            {
                var (result, billing) = await _teamConnect.MakeCallAsync(request, cancellationToken);
                
                return new CallResult
                {
                    Success = true,
                    CallId = result.CallId,
                    Status = result.Status,
                    To = result.To,
                    Cost = billing.Cost,
                    CreditsRemaining = billing.CreditsRemaining
                };
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Batch call failed for {PhoneNumber}", request.To);
                
                return new CallResult
                {
                    Success = false,
                    To = request.To,
                    Error = ex.Message
                };
            }
            finally
            {
                semaphore.Release();
            }
        });

        return (await Task.WhenAll(tasks)).ToList();
    }
}

// Supporting models
public class Appointment
{
    public string Id { get; set; }
    public string CustomerName { get; set; }
    public string CustomerPhone { get; set; }
    public string ServiceType { get; set; }
    public DateTime DateTime { get; set; }
}

public class Invoice
{
    public string Id { get; set; }
    public string CustomerName { get; set; }
    public string CustomerPhone { get; set; }
    public decimal Amount { get; set; }
    public string PaymentUrl { get; set; }
}

public class CallResult
{
    public bool Success { get; set; }
    public string CallId { get; set; }
    public string Status { get; set; }
    public string To { get; set; }
    public decimal Cost { get; set; }
    public decimal CreditsRemaining { get; set; }
    public string Error { get; set; }
}

// Usage example
public async Task ProcessAppointmentReminders()
{
    var voiceService = serviceProvider.GetRequiredService();
    
    var appointment = new Appointment
    {
        Id = "apt_123",
        CustomerName = "John Doe",
        CustomerPhone = "+447123456789",
        ServiceType = "dental cleaning",
        DateTime = DateTime.Tomorrow.AddHours(14) // 2 PM tomorrow
    };

    var result = await voiceService.MakeAppointmentReminderAsync(appointment);

    if (result.Success)
    {
        Console.WriteLine($"✅ Appointment reminder sent: {result.CallId}");
        Console.WriteLine($"💰 Cost: £{result.Cost:F2}");
        
        if (result.CreditsRemaining < 5.00m)
        {
            Console.WriteLine("⚠️ Low credits remaining!");
        }
    }
    else
    {
        Console.WriteLine($"❌ Failed to send reminder: {result.Error}");
    }
}

// SMS service with 2FA and notifications
public class SmsService
{
    private readonly ITeamConnectService _teamConnect;
    private readonly IMemoryCache _cache;
    private readonly ILogger _logger;

    public SmsService(ITeamConnectService teamConnect, IMemoryCache cache, ILogger logger)
    {
        _teamConnect = teamConnect;
        _cache = cache;
        _logger = logger;
    }

    public async Task SendTwoFactorCodeAsync(string phoneNumber, string appName = "Dad-Link", CancellationToken cancellationToken = default)
    {
        // Generate 6-digit code
        var code = Random.Shared.Next(100000, 999999).ToString();
        
        // Store in cache with 5-minute expiry
        var cacheKey = $"2fa:{phoneNumber}";
        var cacheValue = new TwoFactorCache
        {
            Code = code,
            Attempts = 0,
            CreatedAt = DateTime.UtcNow
        };
        
        _cache.Set(cacheKey, cacheValue, TimeSpan.FromMinutes(5));

        var request = new SmsRequest
        {
            To = phoneNumber,
            Message = $"Your {appName} verification code: {code}"
        };

        try
        {
            var (result, billing) = await _teamConnect.SendSmsAsync(request, cancellationToken);

            _logger.LogInformation("2FA code sent to {PhoneNumber}: {MessageId}",
                phoneNumber, result.MessageId);

            return new TwoFactorResult
            {
                Success = true,
                MessageId = result.MessageId,
                Code = code, // Don't expose in production
                ExpiresAt = DateTime.UtcNow.AddMinutes(5)
            };
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Failed to send 2FA code to {PhoneNumber}", phoneNumber);
            
            // Remove from cache on failure
            _cache.Remove(cacheKey);
            
            return new TwoFactorResult
            {
                Success = false,
                Error = ex.Message
            };
        }
    }

    public bool VerifyTwoFactorCode(string phoneNumber, string inputCode)
    {
        var cacheKey = $"2fa:{phoneNumber}";
        
        if (!_cache.TryGetValue(cacheKey, out TwoFactorCache cacheValue))
        {
            _logger.LogWarning("2FA verification failed - code not found for {PhoneNumber}", phoneNumber);
            return false;
        }

        // Check if expired
        if (DateTime.UtcNow > cacheValue.CreatedAt.AddMinutes(5))
        {
            _cache.Remove(cacheKey);
            _logger.LogWarning("2FA verification failed - code expired for {PhoneNumber}", phoneNumber);
            return false;
        }

        // Check attempts
        if (cacheValue.Attempts >= 3)
        {
            _cache.Remove(cacheKey);
            _logger.LogWarning("2FA verification failed - too many attempts for {PhoneNumber}", phoneNumber);
            return false;
        }

        // Increment attempts
        cacheValue.Attempts++;
        _cache.Set(cacheKey, cacheValue, TimeSpan.FromMinutes(5));

        // Verify code
        if (cacheValue.Code == inputCode)
        {
            _cache.Remove(cacheKey);
            _logger.LogInformation("2FA verification successful for {PhoneNumber}", phoneNumber);
            return true;
        }

        _logger.LogWarning("2FA verification failed - invalid code for {PhoneNumber}", phoneNumber);
        return false;
    }

    public async Task> SendOrderNotificationsAsync(IEnumerable orders, CancellationToken cancellationToken = default)
    {
        var semaphore = new SemaphoreSlim(10, 10); // Limit concurrent SMS
        var tasks = orders.Select(async order =>
        {
            await semaphore.WaitAsync(cancellationToken);
            
            try
            {
                var request = new SmsRequest
                {
                    To = order.CustomerPhone,
                    Message = $"Your order #{order.Number} is {order.Status}. Track: {order.TrackingUrl}"
                };

                var (result, billing) = await _teamConnect.SendSmsAsync(request, cancellationToken);

                _logger.LogInformation("Order notification sent for {OrderNumber}: {MessageId}",
                    order.Number, result.MessageId);

                return new SmsResult
                {
                    Success = true,
                    MessageId = result.MessageId,
                    To = result.To,
                    OrderNumber = order.Number,
                    Cost = billing.Cost
                };
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Failed to send order notification for {OrderNumber}", order.Number);
                
                return new SmsResult
                {
                    Success = false,
                    To = order.CustomerPhone,
                    OrderNumber = order.Number,
                    Error = ex.Message
                };
            }
            finally
            {
                semaphore.Release();
            }
        });

        return (await Task.WhenAll(tasks)).ToList();
    }
}

// Supporting models
public class TwoFactorCache
{
    public string Code { get; set; }
    public int Attempts { get; set; }
    public DateTime CreatedAt { get; set; }
}

public class TwoFactorResult
{
    public bool Success { get; set; }
    public string MessageId { get; set; }
    public string Code { get; set; } // For testing only
    public DateTime ExpiresAt { get; set; }
    public string Error { get; set; }
}

public class Order
{
    public string Number { get; set; }
    public string CustomerPhone { get; set; }
    public string Status { get; set; }
    public string TrackingUrl { get; set; }
}

public class SmsResult
{
    public bool Success { get; set; }
    public string MessageId { get; set; }
    public string To { get; set; }
    public string OrderNumber { get; set; }
    public decimal Cost { get; set; }
    public string Error { get; set; }
}

// Usage example in controller
[ApiController]
[Route("api/[controller]")]
public class AuthController : ControllerBase
{
    private readonly SmsService _smsService;

    public AuthController(SmsService smsService)
    {
        _smsService = smsService;
    }

    [HttpPost("send-2fa")]
    public async Task SendTwoFactorCode([FromBody] Send2FARequest request)
    {
        var result = await _smsService.SendTwoFactorCodeAsync(request.PhoneNumber, "Dad-Link");

        if (result.Success)
        {
            return Ok(new
            {
                Success = true,
                MessageId = result.MessageId,
                ExpiresAt = result.ExpiresAt
            });
        }

        return BadRequest(new
        {
            Success = false,
            Error = result.Error
        });
    }

    [HttpPost("verify-2fa")]
    public IActionResult VerifyTwoFactorCode([FromBody] Verify2FARequest request)
    {
        var isValid = _smsService.VerifyTwoFactorCode(request.PhoneNumber, request.Code);

        return Ok(new
        {
            Success = isValid,
            Message = isValid ? "Code verified successfully" : "Invalid or expired code"
        });
    }
}

public class Send2FARequest
{
    [Required]
    public string PhoneNumber { get; set; }
}

public class Verify2FARequest
{
    [Required]
    public string PhoneNumber { get; set; }
    
    [Required]
    public string Code { get; set; }
}

// Email service with templating system
public class EmailService
{
    private readonly ITeamConnectService _teamConnect;
    private readonly ILogger _logger;

    public EmailService(ITeamConnectService teamConnect, ILogger logger)
    {
        _teamConnect = teamConnect;
        _logger = logger;
    }

    public async Task SendWelcomeEmailAsync(WelcomeEmailData data, CancellationToken cancellationToken = default)
    {
        var template = GetWelcomeEmailTemplate();
        var html = RenderTemplate(template, data);

        var request = new EmailRequest
        {
            To = data.CustomerEmail,
            Subject = $"Welcome to {data.CompanyName} - Your Account is Ready!",
            Html = html,
            FromName = $"{data.CompanyName} Team"
        };

        return await SendEmailAsync(request, "welcome", cancellationToken);
    }

    public async Task SendInvoiceEmailAsync(InvoiceEmailData data, CancellationToken cancellationToken = default)
    {
        var template = GetInvoiceEmailTemplate();
        var html = RenderTemplate(template, data);

        var request = new EmailRequest
        {
            To = data.CustomerEmail,
            Subject = $"Invoice #{data.InvoiceNumber} - Payment Due",
            Html = html,
            FromName = "Dad-Link Billing"
        };

        return await SendEmailAsync(request, "invoice", cancellationToken);
    }

    public async Task> SendEmailCampaignAsync(string templateName, IEnumerable recipients, Func selector, int maxConcurrency = 5, CancellationToken cancellationToken = default)
    {
        var semaphore = new SemaphoreSlim(maxConcurrency, maxConcurrency);
        var tasks = recipients.Select(async recipient =>
        {
            await semaphore.WaitAsync(cancellationToken);
            
            try
            {
                var (email, subject, data) = selector(recipient);
                var template = GetEmailTemplate(templateName);
                var html = RenderTemplate(template, data);

                var request = new EmailRequest
                {
                    To = email,
                    Subject = subject,
                    Html = html,
                    FromName = "Dad-Link Team"
                };

                return await SendEmailAsync(request, templateName, cancellationToken);
            }
            finally
            {
                semaphore.Release();
            }
        });

        return (await Task.WhenAll(tasks)).ToList();
    }

    private async Task SendEmailAsync(EmailRequest request, string templateType, CancellationToken cancellationToken)
    {
        try
        {
            var (result, billing) = await _teamConnect.SendEmailAsync(request, cancellationToken);

            _logger.LogInformation("{TemplateType} email sent to {Email}: {MessageId}",
                templateType, request.To, result.MessageId);

            return new EmailResult
            {
                Success = true,
                MessageId = result.MessageId,
                To = result.To,
                Subject = result.Subject,
                Cost = billing.Cost,
                CreditsRemaining = billing.CreditsRemaining
            };
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Failed to send {TemplateType} email to {Email}", templateType, request.To);
            
            return new EmailResult
            {
                Success = false,
                To = request.To,
                Subject = request.Subject,
                Error = ex.Message
            };
        }
    }

    private string GetWelcomeEmailTemplate()
    {
        return @"



    


    

        

            
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.
        
    

";
    }

    private string GetInvoiceEmailTemplate()
    {
        return @"



    


    

        

            
Invoice #{{InvoiceNumber}}
        
        

            
Hi {{CustomerName}},
            
Your invoice is ready for payment.
            
Amount Due: £{{Amount:F2}}
            
Due Date: {{DueDate:MMMM d, yyyy}}
            Pay Now
        
    

";
    }

    private string GetEmailTemplate(string templateName)
    {
        // In production, load from database or file system
        return templateName switch
        {
            "welcome" => GetWelcomeEmailTemplate(),
            "invoice" => GetInvoiceEmailTemplate(),
            _ => throw new ArgumentException($"Unknown template: {templateName}")
        };
    }

    private string RenderTemplate(string template, object data)
    {
        // Simple template rendering - in production, use a proper template engine
        var rendered = template;
        var properties = data.GetType().GetProperties();
        
        foreach (var prop in properties)
        {
            var value = prop.GetValue(data);
            var placeholder = $"{{{{{prop.Name}}}}}";
            
            if (value is DateTime dateTime)
            {
                rendered = rendered.Replace(placeholder, dateTime.ToString("MMMM d, yyyy"));
                }
                else if (value is decimal || value is double || value is float)
                {
                    rendered = rendered.Replace(placeholder, $"{value:F2}");
                }
                else
                {
                    rendered = rendered.Replace(placeholder, value?.ToString() ?? "");
                }
            }
            
            return rendered;
        }
    }

    // Supporting models
    public class WelcomeEmailData
    {
        public string CustomerName { get; set; }
        public string CustomerEmail { get; set; }
        public string CompanyName { get; set; }
        public string DashboardUrl { get; set; }
    }

    public class InvoiceEmailData
    {
        public string CustomerName { get; set; }
        public string CustomerEmail { get; set; }
        public string InvoiceNumber { get; set; }
        public decimal Amount { get; set; }
        public DateTime DueDate { get; set; }
        public string PaymentUrl { get; set; }
    }

    public class EmailResult
    {
        public bool Success { get; set; }
        public string MessageId { get; set; }
        public string To { get; set; }
        public string Subject { get; set; }
        public decimal Cost { get; set; }
        public decimal CreditsRemaining { get; set; }
        public string Error { get; set; }
    }

    // Usage example
    public async Task ProcessWelcomeEmails()
    {
        var emailService = serviceProvider.GetRequiredService();
        
        var welcomeData = new WelcomeEmailData
        {
            CustomerName = "John Doe",
            CustomerEmail = "john@example.com",
            CompanyName = "Dad-Link",
            DashboardUrl = "https://team-connect.co.uk/dashboard.html"
        };

        var result = await emailService.SendWelcomeEmailAsync(welcomeData);

        if (result.Success)
        {
            Console.WriteLine($"✅ Welcome email sent: {result.MessageId}");
            Console.WriteLine($"💰 Cost: £{result.Cost:F4}");
        }
        else
        {
            Console.WriteLine($"❌ Failed to send welcome email: {result.Error}");
        }
    }

// AI Chat service with conversation management
    public class AIChatService
    {
        private readonly ITeamConnectService _teamConnect;
        private readonly IMemoryCache _cache;
        private readonly ILogger _logger;

        public AIChatService(ITeamConnectService teamConnect, IMemoryCache cache, ILogger logger)
        {
            _teamConnect = teamConnect;
            _cache = cache;
            _logger = logger;
        }

        public async Task SendMessageAsync(string userId, string message, CancellationToken cancellationToken = default)
        {
            // Get or create conversation
            var conversation = GetOrCreateConversation(userId);
            
            // Add user message
            conversation.Messages.Add(new ChatMessage
            {
                Role = "user",
                Content = message
            });

            var request = new ChatRequest
            {
                Messages = conversation.Messages.ToArray(),
                Model = "gpt-4"
            };

            try
            {
                var (result, billing) = await _teamConnect.ChatAsync(request, cancellationToken);

                // Add AI response to conversation
                conversation.Messages.Add(new ChatMessage
                {
                    Role = "assistant",
                    Content = result.Response
                });

                // Update conversation in cache
                conversation.LastUsed = DateTime.UtcNow;
                UpdateConversation(userId, conversation);

                _logger.LogInformation("AI chat response generated for user {UserId}, tokens used: {TokensUsed}",
                    userId, result.TokensUsed);

                return new ChatResult
                {
                    Success = true,
                    Response = result.Response,
                    Model = result.Model,
                    TokensUsed = result.TokensUsed,
                    Cost = billing.Cost,
                    CreditsRemaining = billing.CreditsRemaining
                };
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "AI chat failed for user {UserId}", userId);
                
                // Remove the user message on failure
                if (conversation.Messages.Count > 0 && conversation.Messages.Last().Role == "user")
                {
                    conversation.Messages.RemoveAt(conversation.Messages.Count - 1);
                    UpdateConversation(userId, conversation);
                }

                return new ChatResult
                {
                    Success = false,
                    Error = ex.Message
                };
            }
        }

        public async Task GenerateContentAsync(string prompt, string systemContext = null, CancellationToken cancellationToken = default)
        {
            var messages = new List();
            
            if (!string.IsNullOrEmpty(systemContext))
            {
                messages.Add(new ChatMessage
                {
                    Role = "system",
                    Content = systemContext
                });
            }

            messages.Add(new ChatMessage
            {
                Role = "user",
                Content = prompt
            });

            var request = new ChatRequest
            {
                Messages = messages.ToArray(),
                Model = "gpt-4"
            };

            try
            {
                var (result, billing) = await _teamConnect.ChatAsync(request, cancellationToken);
                
                _logger.LogInformation("Content generated, tokens used: {TokensUsed}, cost: {Cost}",
                    result.TokensUsed, billing.CostFormatted);

                return result.Response;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Content generation failed for prompt: {Prompt}", prompt);
                throw;
            }
        }

        public async Task> GenerateEmailSubjectsAsync(string product, string audience, int count = 5, CancellationToken cancellationToken = default)
        {
            var prompt = $"Generate {count} compelling email subject lines for {product} targeting {audience}. Make them engaging and click-worthy. Return only the subject lines, one per line.";
            var systemContext = "You are a marketing copywriter specializing in email subject lines.";

            var content = await GenerateContentAsync(prompt, systemContext, cancellationToken);
            
            return content
                .Split('\n', StringSplitOptions.RemoveEmptyEntries)
                .Select(line => line.Trim())
                .Where(line => !string.IsNullOrEmpty(line))
                .Take(count)
                .ToList();
        }

        public async Task GenerateProductDescriptionAsync(string productName, string features, CancellationToken cancellationToken = default)
        {
            var prompt = $"Write a compelling product description for {productName} with these features: {features}. Make it professional and persuasive.";
            var systemContext = "You are a product marketing specialist who writes compelling product descriptions.";

            return await GenerateContentAsync(prompt, systemContext, cancellationToken);
        }

        public void ClearConversation(string userId)
        {
            var cacheKey = $"conversation:{userId}";
            _cache.Remove(cacheKey);
            _logger.LogInformation("Conversation cleared for user {UserId}", userId);
        }

        public void ClearOldConversations()
        {
            // This is simplified - in production, you'd need a proper cache eviction strategy
            _logger.LogInformation("Old conversations cleanup triggered");
        }

        private Conversation GetOrCreateConversation(string userId)
        {
            var cacheKey = $"conversation:{userId}";
            
            if (_cache.TryGetValue(cacheKey, out Conversation conversation))
            {
                return conversation;
            }

            conversation = new Conversation
            {
                UserId = userId,
                Messages = new List
                {
                    new ChatMessage
                    {
                        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."
                    }
                },
                CreatedAt = DateTime.UtcNow,
                LastUsed = DateTime.UtcNow
            };

            UpdateConversation(userId, conversation);
            return conversation;
        }

        private void UpdateConversation(string userId, Conversation conversation)
        {
            var cacheKey = $"conversation:{userId}";
            var options = new MemoryCacheEntryOptions
            {
                SlidingExpiration = TimeSpan.FromHours(2),
                AbsoluteExpirationRelativeToNow = TimeSpan.FromDays(1)
            };
            
            _cache.Set(cacheKey, conversation, options);
        }
    }

    // Supporting models
    public class Conversation
    {
        public string UserId { get; set; }
        public List Messages { get; set; } = new();
        public DateTime CreatedAt { get; set; }
        public DateTime LastUsed { get; set; }
    }

    public class ChatResult
    {
        public bool Success { get; set; }
        public string Response { get; set; }
        public string Model { get; set; }
        public int TokensUsed { get; set; }
        public decimal Cost { get; set; }
        public decimal CreditsRemaining { get; set; }
        public string Error { get; set; }
    }

    // Usage in SignalR Hub for real-time chat
    public class ChatHub : Hub
    {
        private readonly AIChatService _aiChatService;
        private readonly ILogger _logger;

        public ChatHub(AIChatService aiChatService, ILogger logger)
        {
            _aiChatService = aiChatService;
            _logger = logger;
        }

        public async Task SendMessage(string message)
        {
            var userId = Context.UserIdentifier;
            
            try
            {
                var result = await _aiChatService.SendMessageAsync(userId, message);

                if (result.Success)
                {
                    await Clients.Caller.SendAsync("ReceiveMessage", result.Response);
                    
                    // Optionally send billing info
                    await Clients.Caller.SendAsync("BillingUpdate", new
                    {
                        Cost = result.Cost,
                        CreditsRemaining = result.CreditsRemaining,
                        TokensUsed = result.TokensUsed
                    });
                }
                else
                {
                    await Clients.Caller.SendAsync("Error", result.Error);
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Chat error for user {UserId}", userId);
                await Clients.Caller.SendAsync("Error", "An error occurred processing your message");
            }
        }

        public async Task ClearConversation()
        {
            var userId = Context.UserIdentifier;
            _aiChatService.ClearConversation(userId);
            await Clients.Caller.SendAsync("ConversationCleared");
        }
    }

    // Usage in controller
    [ApiController]
    [Route("api/[controller]")]
    public class ContentController : ControllerBase
    {
        private readonly AIChatService _aiChatService;

        public ContentController(AIChatService aiChatService)
        {
            _aiChatService = aiChatService;
        }

        [HttpPost("email-subjects")]
        public async Task GenerateEmailSubjects([FromBody] GenerateSubjectsRequest request)
        {
            try
            {
                var subjects = await _aiChatService.GenerateEmailSubjectsAsync(
                    request.Product,
                    request.Audience,
                    request.Count
                );

                return Ok(new
                {
                    Success = true,
                    Subjects = subjects
                });
            }
            catch (Exception ex)
            {
                return StatusCode(500, new
                {
                    Success = false,
                    Error = ex.Message
                });
            }
        }

        [HttpPost("product-description")]
        public async Task GenerateProductDescription([FromBody] GenerateDescriptionRequest request)
        {
            try
            {
                var description = await _aiChatService.GenerateProductDescriptionAsync(
                    request.ProductName,
                    request.Features
                );

                return Ok(new
                {
                    Success = true,
                    Description = description
                });
            }
            catch (Exception ex)
            {
                return StatusCode(500, new
                {
                    Success = false,
                    Error = ex.Message
                });
            }
        }
    }

    public class GenerateSubjectsRequest
    {
        [Required]
        public string Product { get; set; }
        
        [Required]
        public string Audience { get; set; }
        
        [Range(1, 20)]
        public int Count { get; set; } = 5;
    }

    public class GenerateDescriptionRequest
    {
        [Required]
        public string ProductName { get; set; }
        
        [Required]
        public string Features { get; set; }
    }

// Comprehensive error handling with Polly
    using Polly;
    using Polly.Extensions.Http;

    // Enhanced client with circuit breaker and retry policies
    public class EnhancedTeamConnectService : ITeamConnectService
    {
        private readonly HttpClient _httpClient;
        private readonly TeamConnectOptions _options;
        private readonly ILogger _logger;
        private readonly IAsyncPolicy _retryPolicy;
        private readonly IAsyncPolicy _circuitBreakerPolicy;
        private readonly IAsyncPolicy _combinedPolicy;

        public EnhancedTeamConnectService(
            HttpClient httpClient,
            IOptions options,
            ILogger logger)
        {
            _httpClient = httpClient;
            _options = options.Value;
            _logger = logger;

            // Retry policy with exponential backoff
            _retryPolicy = Policy
                .HandleResult(r => !r.IsSuccessStatusCode && r.StatusCode != System.Net.HttpStatusCode.PaymentRequired)
                .Or()
                .WaitAndRetryAsync(
                    retryCount: _options.MaxRetries,
                    sleepDurationProvider: retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)),
                    onRetry: (outcome, timespan, retryCount, context) =>
                    {
                        _logger.LogWarning("Retry {RetryCount} for {Operation} after {Delay}ms",
                            retryCount, context.OperationKey, timespan.TotalMilliseconds);
                    });

            // Circuit breaker policy
            _circuitBreakerPolicy = Policy
                .HandleResult(r => !r.IsSuccessStatusCode)
                .Or()
                .CircuitBreakerAsync(
                    handledEventsAllowedBeforeBreaking: 5,
                    durationOfBreak: TimeSpan.FromSeconds(30),
                    onBreak: (exception, duration) =>
                    {
                        _logger.LogError("Circuit breaker opened for {Duration}s due to: {Exception}",
                            duration.TotalSeconds, exception.Exception?.Message ?? exception.Result?.StatusCode.ToString());
                    },
                    onReset: () =>
                    {
                        _logger.LogInformation("Circuit breaker reset");
                    });

            // Combine policies
            _combinedPolicy = Policy.WrapAsync(_retryPolicy, _circuitBreakerPolicy);
        }

        public async Task<(CallResponse Result, BillingInfo Billing)> MakeCallAsync(CallRequest request, CancellationToken cancellationToken = default)
        {
            try
            {
                var context = new Context($"make-call-{request.To}");
                var response = await _combinedPolicy.ExecuteAsync(async (ctx) =>
                {
                    return await MakeHttpRequestAsync("voice", "make_call", request, cancellationToken);
                }, context);

                var apiResponse = await ProcessHttpResponse(response, cancellationToken);
                
                if (!apiResponse.Success)
                {
                    throw new TeamConnectException(apiResponse.Error ?? "Call failed");
                }

                _logger.LogInformation("Call successful: {CallId}, Cost: {Cost}",
                    apiResponse.Result.CallId, apiResponse.Billing?.CostFormatted);

                return (apiResponse.Result, apiResponse.Billing);
            }
            catch (BrokenCircuitException)
            {
                _logger.LogError("Circuit breaker is open for voice calls");
                throw new ServiceUnavailableException("Voice call service is temporarily unavailable");
            }
            catch (HttpRequestException ex)
            {
                _logger.LogError(ex, "Network error making call to {PhoneNumber}", request.To);
                throw new NetworkException("Network error occurred", ex);
            }
            catch (TaskCanceledException ex) when (ex.InnerException is TimeoutException)
            {
                _logger.LogError(ex, "Timeout making call to {PhoneNumber}", request.To);
                throw new TimeoutException("Request timed out", ex);
            }
            catch (TeamConnectException)
            {
                throw; // Re-throw known exceptions
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Unexpected error making call to {PhoneNumber}", request.To);
                throw new TeamConnectException("An unexpected error occurred", ex);
            }
        }

        public async Task<(SmsResponse Result, BillingInfo Billing)> SendSmsAsync(SmsRequest request, CancellationToken cancellationToken = default)
        {
            try
            {
                var context = new Context($"send-sms-{request.To}");
                var response = await _combinedPolicy.ExecuteAsync(async (ctx) =>
                {
                    return await MakeHttpRequestAsync("sms", "send", request, cancellationToken);
                }, context);

                var apiResponse = await ProcessHttpResponse(response, cancellationToken);
                
                if (!apiResponse.Success)
                {
                    throw new TeamConnectException(apiResponse.Error ?? "SMS failed");
                }

                return (apiResponse.Result, apiResponse.Billing);
            }
            catch (BrokenCircuitException)
            {
                throw new ServiceUnavailableException("SMS service is temporarily unavailable");
            }
            catch (Exception ex) when (!(ex is TeamConnectException))
            {
                _logger.LogError(ex, "Error sending SMS to {PhoneNumber}", request.To);
                throw new TeamConnectException("Failed to send SMS", ex);
            }
        }

        public async Task<(EmailResponse Result, BillingInfo Billing)> SendEmailAsync(EmailRequest request, CancellationToken cancellationToken = default)
        {
            try
            {
                var context = new Context($"send-email-{request.To}");
                var response = await _combinedPolicy.ExecuteAsync(async (ctx) =>
                {
                    return await MakeHttpRequestAsync("email", "send", request, cancellationToken);
                }, context);

                var apiResponse = await ProcessHttpResponse(response, cancellationToken);
                
                if (!apiResponse.Success)
                {
                    throw new TeamConnectException(apiResponse.Error ?? "Email failed");
                }

                return (apiResponse.Result, apiResponse.Billing);
            }
            catch (BrokenCircuitException)
            {
                throw new ServiceUnavailableException("Email service is temporarily unavailable");
            }
            catch (Exception ex) when (!(ex is TeamConnectException))
            {
                _logger.LogError(ex, "Error sending email to {EmailAddress}", request.To);
                throw new TeamConnectException("Failed to send email", ex);
            }
        }

        public async Task<(ChatResponse Result, BillingInfo Billing)> ChatAsync(ChatRequest request, CancellationToken cancellationToken = default)
        {
            try
            {
                var context = new Context("ai-chat");
                var response = await _combinedPolicy.ExecuteAsync(async (ctx) =>
                {
                    return await MakeHttpRequestAsync("ai", "chat", request, cancellationToken);
                }, context);

                var apiResponse = await ProcessHttpResponse(response, cancellationToken);
                
                if (!apiResponse.Success)
                {
                    throw new TeamConnectException(apiResponse.Error ?? "AI chat failed");
                }

                return (apiResponse.Result, apiResponse.Billing);
            }
            catch (BrokenCircuitException)
            {
                throw new ServiceUnavailableException("AI service is temporarily unavailable");
            }
            catch (Exception ex) when (!(ex is TeamConnectException))
            {
                _logger.LogError(ex, "Error in AI chat");
                throw new TeamConnectException("AI chat failed", ex);
            }
        }

        private async Task MakeHttpRequestAsync(string service, string action, object data, CancellationToken cancellationToken)
        {
            var request = new
            {
                service,
                action,
                data,
                api_key = _options.ApiKey
            };

            var json = JsonSerializer.Serialize(request, new JsonSerializerOptions
            {
                PropertyNamingPolicy = JsonNamingPolicy.CamelCase
            });

            var content = new StringContent(json, Encoding.UTF8, "application/json");

            return await _httpClient.PostAsync("/executeAPI", content, cancellationToken);
        }

        private async Task> ProcessHttpResponse(HttpResponseMessage response, CancellationToken cancellationToken)
        {
            var responseContent = await response.Content.ReadAsStringAsync(cancellationToken);

            switch (response.StatusCode)
            {
                case System.Net.HttpStatusCode.Unauthorized:
                    throw new InvalidApiKeyException("Invalid or revoked API key");
                
                case System.Net.HttpStatusCode.PaymentRequired:
                    var errorResponse = JsonSerializer.Deserialize(responseContent);
                    throw new InsufficientCreditsException(errorResponse?.Error ?? "Insufficient credits");
                
                case System.Net.HttpStatusCode.TooManyRequests:
                    throw new RateLimitExceededException("Rate limit exceeded");
                
                case System.Net.HttpStatusCode.ServiceUnavailable:
                    throw new ServiceUnavailableException("Service temporarily unavailable");
                
                case System.Net.HttpStatusCode.OK:
                    return JsonSerializer.Deserialize>(responseContent, new JsonSerializerOptions
                    {
                        PropertyNamingPolicy = JsonNamingPolicy.CamelCase
                    });
                
                default:
                    var apiError = JsonSerializer.Deserialize(responseContent);
                    throw new TeamConnectException(apiError?.Error ?? $"HTTP {response.StatusCode}");
            }
        }
    }

    // Custom exception hierarchy
    public class TeamConnectException : Exception
    {
        public string Code { get; }

        public TeamConnectException(string message, string code = null) : base(message)
        {
            Code = code;
        }

        public TeamConnectException(string message, Exception innerException) : base(message, innerException)
        {
            Code = "UNKNOWN_ERROR";
        }
    }

    public class InvalidApiKeyException : TeamConnectException
    {
        public InvalidApiKeyException(string message) : base(message, "INVALID_API_KEY") { }
    }

    public class InsufficientCreditsException : TeamConnectException
    {
        public InsufficientCreditsException(string message) : base(message, "INSUFFICIENT_CREDITS") { }
    }

    public class RateLimitExceededException : TeamConnectException
    {
        public RateLimitExceededException(string message) : base(message, "RATE_LIMIT_EXCEEDED") { }
    }

    public class ServiceUnavailableException : TeamConnectException
    {
        public ServiceUnavailableException(string message) : base(message, "SERVICE_UNAVAILABLE") { }
    }

    public class NetworkException : TeamConnectException
    {
        public NetworkException(string message, Exception innerException) : base(message, innerException)
        {
            Code = "NETWORK_ERROR";
        }
    }

    // Global exception handler for ASP.NET Core
    public class GlobalExceptionHandler : IExceptionHandler
    {
        private readonly ILogger _logger;

        public GlobalExceptionHandler(ILogger logger)
        {
            _logger = logger;
        }

        public async ValueTask TryHandleAsync(HttpContext httpContext, Exception exception, CancellationToken cancellationToken)
        {
            var (statusCode, response) = exception switch
            {
                InvalidApiKeyException ex => (401, new { Success = false, Error = ex.Message, Code = ex.Code }),
                InsufficientCreditsException ex => (402, new { Success = false, Error = ex.Message, Code = ex.Code, TopUpUrl = "https://team-connect.co.uk/api-dashboard.html#topup" }),
                RateLimitExceededException ex => (429, new { Success = false, Error = ex.Message, Code = ex.Code }),
                ServiceUnavailableException ex => (503, new { Success = false, Error = ex.Message, Code = ex.Code }),
                TeamConnectException ex => (500, new { Success = false, Error = ex.Message, Code = ex.Code }),
                _ => (500, new { Success = false, Error = "An unexpected error occurred", Code = "INTERNAL_ERROR" })
            };

            _logger.LogError(exception, "Handling exception: {ExceptionType}", exception.GetType().Name);

            httpContext.Response.StatusCode = statusCode;
            await httpContext.Response.WriteAsJsonAsync(response, cancellationToken);

            return true;
        }
    }

    // Usage example with comprehensive error handling
    public class CommunicationController : ControllerBase
    {
        private readonly ITeamConnectService _teamConnect;

        public CommunicationController(ITeamConnectService teamConnect)
        {
            _teamConnect = teamConnect;
        }

        [HttpPost("call")]
        public async Task MakeCall([FromBody] CallRequest request)
        {
            // No try-catch needed - global exception handler will handle it
            var (result, billing) = await _teamConnect.MakeCallAsync(request);
            
            return Ok(new
            {
                Success = true,
                Data = result,
                Billing = billing
            });
        }
    }