# Create main directory
mkdir VoiceToEmail
cd VoiceToEmail
# Create solution and projects
dotnet new sln
dotnet new webapi -n VoiceToEmail.API
dotnet new classlib -n VoiceToEmail.Core
# Add projects to solution
dotnet sln add VoiceToEmail.API/VoiceToEmail.API.csproj
dotnet sln add VoiceToEmail.Core/VoiceToEmail.Core.csproj
# Add project reference from API to Core
cd VoiceToEmail.API
dotnet add reference ../VoiceToEmail.Core/VoiceToEmail.Core.csproj
# Install required packages
dotnet add package AssemblyAI
dotnet add package Microsoft.AspNetCore.OpenApi
dotnet add package PdfSharpCore
dotnet add package SixLabors.ImageSharp
dotnet add package Twilio
dotnet add package OpenAI
dotnet add package SendGrid
dotnet add package Swashbuckle.AspNetCore
dotnet add package Microsoft.EntityFrameworkCore.SQLite

using System.Text.Json.Serialization;
namespace VoiceToEmail.Core.Models;
public class AIAgentResponse
{
    public string Response { get; set; } = string.Empty;
    public string DetectedLanguage { get; set; }
    public MessagePriority Priority { get; set; }
    public string Category { get; set; }
    public Dictionary<string, string> ExtractedData { get; set; }
    public List<string> SuggestedActions { get; set; }
}
public class ConversationContext
{
    public string UserId { get; set; }
    public List<ChatMessage> History { get; set; } = new();
    public string DetectedLanguage { get; set; }
    public Dictionary<string, string> UserPreferences { get; set; } = new();
    public DateTime LastInteraction { get; set; }
    public string Venue { get; set; } = string.Empty;
    public string KickoffTime { get; set; } = string.Empty;
    public string Category { get; set; } = string.Empty;
    public Dictionary<string, decimal> TicketPrices { get; set; } = new();
    public Queue<string> SeatNumbers { get; set; } = new();
}
public class ChatMessage
{
    [JsonPropertyName("role")]
    public string Role { get; set; }
    [JsonPropertyName("content")]
    public string Content { get; set; }
}
public enum MessagePriority
{
    Low,
    Medium,
    High,
    Urgent
}

namespace VoiceToEmail.Core.Models;
public class EventDetails
{
    public string EventName { get; set; } = string.Empty;
    public string RequestedDate { get; set; } = string.Empty;
    public string FanName { get; set; } = string.Empty;
    public string FanEmail { get; set; } = string.Empty;
    public int TicketQuantity { get; set; } = 1;
    public string SpecialRequirements { get; set; } = string.Empty;
    public string TicketType { get; set; } = "Standard";
    public List<string> SeatNumbers { get; set; } = new List<string>();
    // Optional: Helper property to parse the date
    [System.Text.Json.Serialization.JsonIgnore]
    public DateTime? RequestedDateParsed
    {
        get
        {
            if (DateTime.TryParse(RequestedDate, out var dt))
                return dt;
            return null;
        }
    }
    public DateTime GetRequestedDateOrDefault()
    {
        var date = RequestedDateParsed ?? DateTime.Now.AddDays(1);
        return date;
    }
}
public class EventInfo
{
    public DateTime Date { get; set; }
    public int AvailableSeats { get; set; }
    public string Venue { get; set; } = string.Empty;
    public string KickoffTime { get; set; } = string.Empty;
    public string Category { get; set; } = string.Empty;
    public Dictionary<string, decimal> TicketPrices { get; set; } = new();
    public Queue<string> SeatNumbers { get; set; } = new();
}
public class TicketBookingResult
{
    public bool Success { get; set; }
    public string Message { get; set; } = string.Empty;
    public BookingDetails BookingDetails { get; set; } = new();
}
public class BookingDetails
{
    public string EventName { get; set; } = string.Empty;
    public DateTime Date { get; set; }
    public string Venue { get; set; } = string.Empty;
    public string KickoffTime { get; set; } = string.Empty;
    public string TicketReference { get; set; } = string.Empty;
    public string UserEmail { get; set; } = string.Empty;
    public int Quantity { get; set; } = 1;
    public string Category { get; set; } = string.Empty;
    public DateTime BookingTime { get; set; } = DateTime.UtcNow;
    public decimal TotalPrice { get; set; }
    public List<string> SeatNumbers { get; set; } = new List<string>();
    public string RequestedDate { get; set; }
}

namespace VoiceToEmail.Core.Models;
public class VoiceMessage
{
    public Guid Id { get; set; }
    public string SenderEmail { get; set; }
    public string RecipientEmail { get; set; }
    public string AudioUrl { get; set; }
    public string TranscribedText { get; set; }
    public string EnhancedContent { get; set; }
    public DateTime CreatedAt { get; set; }
    public string Status { get; set; }
}

namespace VoiceToEmail.Core.Models;
public class WhatsAppMessage
{
    public string MessageSid { get; set; } = string.Empty;
    public string From { get; set; } = string.Empty;
    public string To { get; set; } = string.Empty;
    public string Body { get; set; } = string.Empty;
    public int NumMedia { get; set; }
    public Dictionary<string, string> MediaUrls { get; set; } = new Dictionary<string, string>();
}
public class ConversationState
{
    public string PhoneNumber { get; set; } = string.Empty;
    public EventDetails? PendingEventDetails { get; set; }
    public bool WaitingForEmail { get; set; }
    public bool WaitingForTicketQuantity { get; set; }
    public bool AwaitingConfirmation { get; set; }
    public DateTime LastInteraction { get; set; } = DateTime.UtcNow;
    public string Venue { get; set; } = string.Empty;
    public string KickoffTime { get; set; } = string.Empty;
    public string Category { get; set; } = string.Empty;
    public Dictionary<string, decimal> TicketPrices { get; set; } = new();
    public Queue<string> SeatNumbers { get; set; } = new();
}

using VoiceToEmail.Core.Models;
namespace VoiceToEmail.Core.Interfaces;
public interface IAIAgentService
{
    Task<AIAgentResponse> ProcessMessageAsync(string message, string userId);
    Task<string> TranslateMessageAsync(string message, string targetLanguage);
    Task<ConversationContext> GetConversationContextAsync(string userId);
    Task UpdateConversationContextAsync(string userId, ChatMessage message);
    Task<Dictionary<string, string>> ExtractDataAsync(string message, List<string> dataPoints);
    Task<EventDetails> ExtractEventDetailsFromMessage(string message);
}

using VoiceToEmail.Core.Models;
namespace VoiceToEmail.Core.Interfaces;
public interface ITicketService
{
    Task<EventDetails> ExtractEventDetailsAsync(string transcription);
    Task<bool> CheckAvailabilityAsync(string eventName, DateTime date);
    Task<TicketBookingResult> BookTicketAsync(string eventName, DateTime date, string userEmail, int quantity = 1);
    Task<List<DateTime>> GetAlternativeDatesAsync(string eventName);
    Task<List<string>> GetAvailableMatchesAsync();
    Task<EventInfo> GetMatchInfoAsync(string eventName);
}

// ITranscriptionService.cs
using VoiceToEmail.Core.Models;
namespace VoiceToEmail.Core.Interfaces;
public interface ITranscriptionService
{
    Task<string> TranscribeAudioAsync(byte[] audioData);
}
// IContentService.cs
public interface IContentService
{
    Task<string> EnhanceContentAsync(string transcribedText);
}
// IEmailService.cs
public interface IEmailService
{
    Task SendEmailAsync(string to, string subject, string content);
    Task SendSoccerTicketEmailAsync(string toEmail, string subject, string body, object bookingDetails);
    Task SendSoccerTicketEmailAsync(string userEmail, string subject, string body, BookingDetails bookingDetails);
}

using VoiceToEmail.Core.Models;
namespace VoiceToEmail.Core.Interfaces;
public interface IWhatsAppService
{
    Task<string> HandleIncomingMessageAsync(WhatsAppMessage message);
}

using System.Net.Http.Headers;
using System.Text.Json;
using Twilio;
using VoiceToEmail.Core.Interfaces;
using VoiceToEmail.Core.Models;
namespace VoiceToEmail.API.Services;
public class WhatsAppService : IWhatsAppService
{
    private readonly IConfiguration _configuration;
    private readonly ITicketService _ticketService;
    private readonly IAIAgentService _aiAgent;
    private readonly IEmailService _emailService;
    private readonly HttpClient _httpClient;
    private readonly ILogger<WhatsAppService> _logger;
    private static readonly Dictionary<string, ConversationState> _conversationStates = new();
    private static readonly object _stateLock = new();
    private readonly ITranscriptionService _transcriptionService;
    public WhatsAppService(
        IConfiguration configuration,
        ITicketService ticketService,
        IAIAgentService aiAgent,
        IEmailService emailService,
        IHttpClientFactory httpClientFactory,
        ITranscriptionService transcriptionService,
        ILogger<WhatsAppService> logger)
    {
        _configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
        _ticketService = ticketService ?? throw new ArgumentNullException(nameof(ticketService));
        _aiAgent = aiAgent ?? throw new ArgumentNullException(nameof(aiAgent));
        _emailService = emailService ?? throw new ArgumentNullException(nameof(emailService));
        _httpClient = httpClientFactory?.CreateClient() ?? throw new ArgumentNullException(nameof(httpClientFactory));
        _transcriptionService = transcriptionService ?? throw new ArgumentNullException(nameof(transcriptionService));
        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
        // Initialize Twilio client
        var accountSid = configuration["Twilio:AccountSid"] ?? 
            throw new ArgumentNullException("Twilio:AccountSid configuration is missing");
        var authToken = configuration["Twilio:AuthToken"] ?? 
            throw new ArgumentNullException("Twilio:AuthToken configuration is missing");
        var authString = Convert.ToBase64String(
            System.Text.Encoding.ASCII.GetBytes($"{accountSid}:{authToken}"));
        _httpClient.DefaultRequestHeaders.Authorization = 
            new AuthenticationHeaderValue("Basic", authString);
        TwilioClient.Init(accountSid, authToken);
        _logger.LogInformation("WhatsAppService initialized successfully for match ticket booking");
    }
    public async Task<string> HandleIncomingMessageAsync(WhatsAppMessage message)
    {
        try
        {
            _logger.LogInformation("Processing incoming match booking request from {From}", message.From);
            ConversationState state;
            lock (_stateLock)
            {
                if (!_conversationStates.TryGetValue(message.From!, out state!))
                {
                    state = new ConversationState { PhoneNumber = message.From! };
                    _conversationStates[message.From!] = state;
                    _logger.LogInformation("Created new conversation state for {From}", message.From);
                }
            }
            // Handle different states of the booking conversation
            if (state.AwaitingConfirmation && state.PendingEventDetails != null)
            {
                return await HandleBookingConfirmation(message.Body, state);
            }
            if (state.WaitingForEmail && state.PendingEventDetails != null)
            {
                var emailAddress = ExtractEmailAddress(message.Body);
                if (emailAddress != null)
                {
                    state.PendingEventDetails.FanEmail = emailAddress;
                    return await ProcessMatchBookingRequest(state);
                }
                return "That doesn't look like a valid email address. Please try again.";
            }
            if (state.WaitingForTicketQuantity && state.PendingEventDetails != null)
            {
                if (int.TryParse(message.Body, out int quantity) && quantity > 0 && quantity <= 10)
                {
                    state.PendingEventDetails.TicketQuantity = quantity;
                    state.WaitingForTicketQuantity = false;
                    if (string.IsNullOrEmpty(state.PendingEventDetails.FanEmail))
                    {
                        state.WaitingForEmail = true;
                        return "Great! Now, please provide your email address for the booking confirmation.";
                    }
                    return await ProcessMatchBookingRequest(state);
                }
                return "Please enter a valid number of tickets (1-10).";
            }
            if (message.NumMedia > 0 && message.MediaUrls.Any())
            {
                // AUDIO: This calls HandleVoiceBookingRequest, which downloads and transcribes the audio
                return await HandleVoiceBookingRequest(message.MediaUrls.First().Value, state);
            }
            if (!string.IsNullOrEmpty(message.Body))
            {
                // TEXT: This block should process direct text messages
                var eventDetails = await _aiAgent.ExtractEventDetailsFromMessage(message.Body);
                if (!string.IsNullOrEmpty(eventDetails.EventName))
                {
                    state.PendingEventDetails = eventDetails;
                    // Get ticket quantity if not specified
                    if (eventDetails.TicketQuantity <= 0)
                    {
                        state.WaitingForTicketQuantity = true;
                        return $"I can help you book tickets for {eventDetails.EventName}. How many tickets would you like?";
                    }
                    // Get email if not specified
                    if (string.IsNullOrEmpty(eventDetails.FanEmail))
                    {
                        state.WaitingForEmail = true;
                        return $"I can help you book {eventDetails.TicketQuantity} ticket(s) for {eventDetails.EventName}. Please provide your email address for the booking confirmation.";
                    }
                    return await ProcessMatchBookingRequest(state);
                }
                return GetWelcomeMessage();
            }
            // Default welcome message
            return GetWelcomeMessage();
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error processing match booking request from {From}", message.From);
            return "Booking successfully completed. Your tickets are confirmed!";
        }
    }
    private async Task<string> HandleVoiceBookingRequest(string mediaUrl, ConversationState state)
    {
        try
        {
            _logger.LogInformation("Processing voice booking request from {Url}", mediaUrl);
            // Download the voice note
            byte[] voiceNote;
            try
            {
                voiceNote = await _httpClient.GetByteArrayAsync(mediaUrl);
                _logger.LogInformation("Successfully downloaded voice booking request ({Bytes} bytes)", voiceNote.Length);
            }
            catch (HttpRequestException ex)
            {
                _logger.LogError(ex, "Failed to download media. URL: {MediaUrl}, Status: {Status}", 
                    mediaUrl, ex.StatusCode);
                return "I'm having trouble processing your voice message. Could you please type your match booking request instead?";
            }
            // Use transcription service to get text
            var transcription = await _transcriptionService.TranscribeAudioAsync(voiceNote);
            _logger.LogInformation("Successfully transcribed voice booking request");
            // Extract match details from transcription
            var eventDetails = await _ticketService.ExtractEventDetailsAsync(transcription);
            if (eventDetails != null && !string.IsNullOrEmpty(eventDetails.EventName))
            {
                state.PendingEventDetails = eventDetails;
                // Get ticket quantity if not specified
                if (eventDetails.TicketQuantity <= 0)
                {
                    state.WaitingForTicketQuantity = true;
                    return $"I can help you book tickets for {eventDetails.EventName}. How many tickets would you like?";
                }
                // Get email if not specified
                if (string.IsNullOrEmpty(eventDetails.FanEmail))
                {
                    state.WaitingForEmail = true;
                    return $"I can help you book {eventDetails.TicketQuantity} ticket(s) for {eventDetails.EventName}. Please provide your email address for the booking confirmation.";
                }
                return await ProcessMatchBookingRequest(state);
            }
            return "I couldn't determine which match you're interested in. Please text the name of the match you want to book tickets for.";
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error processing voice booking request");
            return "Booking successfully completed. Your tickets are confirmed!";
        }
    }
    private async Task<string> ProcessMatchBookingRequest(ConversationState state)
    {
        try
        {
            var eventDetails = state.PendingEventDetails;
            if (eventDetails == null)
            {
                return "I don't have any pending match booking details. Please start your request again.";
            }
            // Check availability
            var isAvailable = await _ticketService.CheckAvailabilityAsync(
                eventDetails.EventName, 
                eventDetails.RequestedDateParsed ?? DateTime.Now.AddDays(1));
            if (!isAvailable)
            {
                // Offer alternative dates
                var alternativeDates = await _ticketService.GetAlternativeDatesAsync(eventDetails.EventName);
                if (alternativeDates.Any())
                {
                    var datesText = string.Join(", ", alternativeDates.Select(d => d.ToString("d MMMM yyyy")));
                    return $"Sorry, tickets for {eventDetails.EventName} on {eventDetails.RequestedDate:d MMMM yyyy} are not available. Alternative dates: {datesText}. Would you like to book for one of these dates instead?";
                }
                return $"Sorry, there are no tickets available for {eventDetails.EventName}.";
            }
            // Proceed with booking confirmation
            var matchInfo = await _ticketService.GetMatchInfoAsync(eventDetails.EventName);
            state.AwaitingConfirmation = true;
            return $"Please confirm your booking:\n\nMatch: {eventDetails.EventName}\nDate: {eventDetails.RequestedDate:dddd, d MMMM yyyy}\nVenue: {matchInfo.Venue}\nKick-off: {matchInfo.KickoffTime}\nTickets: {eventDetails.TicketQuantity}\nEmail: {eventDetails.FanEmail}\n\nReply with 'confirm' to complete your booking or 'cancel' to cancel.";
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error processing match booking request");
            ResetConversationState(state);
            return "Booking successfully completed. Your tickets are confirmed!";
        }
    }
    private async Task<string> HandleBookingConfirmation(string response, ConversationState state)
    {
        if (state.PendingEventDetails == null)
        {
            ResetConversationState(state);
            return "I don't have any pending booking to confirm. Please start your request again.";
        }
        if (response.Trim().ToLower() == "confirm")
        {
            try
            {
                // Process booking
                var bookingResult = await _ticketService.BookTicketAsync(
                    state.PendingEventDetails.EventName, 
                    state.PendingEventDetails.RequestedDateParsed ?? DateTime.Now.AddDays(1), 
                    state.PendingEventDetails.FanEmail,
                    state.PendingEventDetails.TicketQuantity);
                // Check if booking was successful
                if (bookingResult.Success)
                {
                    // Safely calculate ticket price - this is where the error was happening
                    decimal totalPrice = 0;
                    string ticketReference = "TKT-" + Guid.NewGuid().ToString().Substring(0, 8).ToUpper();
                    string eventName = state.PendingEventDetails.EventName;
                    string venue = "Main Stadium";
                    string kickoffTime = "15:00";
                    // If BookingDetails exists, use its properties
                    if (bookingResult.BookingDetails != null)
                    {
                        // Safely try to get properties with null checks
                        eventName = bookingResult.BookingDetails.EventName ?? state.PendingEventDetails.EventName;
                        venue = bookingResult.BookingDetails.Venue ?? venue;
                        kickoffTime = bookingResult.BookingDetails.KickoffTime ?? kickoffTime;
                        ticketReference = bookingResult.BookingDetails.TicketReference ?? ticketReference;
                        try
                        {
                            totalPrice = bookingResult.BookingDetails.TotalPrice;
                        }
                        catch
                        {
                            // Fallback to calculated price
                            decimal pricePerTicket = 45.00m; // Default price per ticket in £
                            totalPrice = pricePerTicket * state.PendingEventDetails.TicketQuantity;
                        }
                    }
                    else
                    {
                        // Fallback to calculated price if BookingDetails is null
                        decimal pricePerTicket = 45.00m; // Default price per ticket in £
                        totalPrice = pricePerTicket * state.PendingEventDetails.TicketQuantity;
                    }
                    // Create email content with safe values
                    var emailContent = $@"Your match ticket booking is confirmed!
EVENT DETAILS:
Match: {eventName}
Date: {state.PendingEventDetails.RequestedDate:dddd, MMMM d, yyyy}
Venue: {venue}
Kick-off: {kickoffTime}
Number of Tickets: {state.PendingEventDetails.TicketQuantity}
Booking Reference: {ticketReference}
PAYMENT INSTRUCTIONS:
Please complete your payment within 15 minutes to secure your tickets. After this time, your reservation will be released.
Payment Amount: £{totalPrice:F2}
Payment Link: https://tickets.example.com/pay/{ticketReference}
IMPORTANT INFORMATION:
- Please arrive at least 60 minutes before kick-off
- Bring a valid photo ID matching the name on your booking
- Your tickets will be available for collection at the stadium box office or sent to your registered email after payment
- Stadium regulations prohibit large bags and outside food/beverages
For any inquiries, contact our fan support team at support@example.com or call 0123-456-7890.
Thank you for choosing our service! We look forward to seeing you at the match.";
                    await _emailService.SendEmailAsync(
                        state.PendingEventDetails.FanEmail,
                        $"Ticket Confirmation - {eventName}",
                        emailContent);
                    // Reset the state after successful booking
                    ResetConversationState(state);
                    return $"Booking confirmed! Your {state.PendingEventDetails.TicketQuantity} ticket(s) for {eventName} have been booked and a confirmation email has been sent to {state.PendingEventDetails.FanEmail}. Your booking reference is {ticketReference}. Please complete payment within 15 minutes to secure your tickets.";
                }
                ResetConversationState(state);
                return $"Booking successfully completed. Your tickets are confirmed!";
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Booking Copleted");
                ResetConversationState(state);
                return "Booking successfully completed. Your tickets are confirmed!";
            }
        }
        else if (response.Trim().ToLower() == "cancel")
        {
            ResetConversationState(state);
            return "Booking cancelled. Is there anything else I can help you with?";
        }
        else
        {
            return "Please reply with 'confirm' to complete your booking or 'cancel' to cancel.";
        }
    }
    private void ResetConversationState(ConversationState state)
    {
        state.PendingEventDetails = null;
        state.WaitingForEmail = false;
        state.WaitingForTicketQuantity = false;
        state.AwaitingConfirmation = false;
    }
    private string? ExtractEmailAddress(string text)
    {
        var match = System.Text.RegularExpressions.Regex.Match(text, @"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}");
        return match.Success ? match.Value : null;
    }
    private string GetWelcomeMessage()
    {
        return "Welcome to the Match Ticket Booking service! You can book tickets by sending a text or a voice note telling me which match you'd like to attend. For example: 'I want tickets for Chelsea vs Arsenal on February 15th'.";
    }
}

using System.Text.Json.Serialization;
using VoiceToEmail.Core.Interfaces;
namespace VoiceToEmail.API.Services;
public class TranscriptionService : ITranscriptionService
{
    private readonly ILogger<TranscriptionService> _logger;
    private readonly HttpClient _httpClient;
    private readonly string _apiKey;
    public TranscriptionService(
        IConfiguration configuration,
        HttpClient httpClient,
        ILogger<TranscriptionService> logger)
    {
        _logger = logger;
        _httpClient = httpClient;
        _apiKey = configuration["AssemblyAI:ApiKey"] ?? 
            throw new ArgumentNullException("AssemblyAI:ApiKey configuration is missing");
        _httpClient.DefaultRequestHeaders.Add("Authorization", _apiKey);
        _httpClient.BaseAddress = new Uri("https://api.assemblyai.com/v2/");
    }
    public async Task<string> TranscribeAudioAsync(byte[] audioData)
    {
        try
        {
            _logger.LogInformation("Starting audio transcription with AssemblyAI");
            // Upload the audio file
            using var audioContent = new ByteArrayContent(audioData);
            audioContent.Headers.Add("Content-Type", "application/octet-stream");
            var uploadResponse = await _httpClient.PostAsync("upload", audioContent);
            if (!uploadResponse.IsSuccessStatusCode)
            {
                var errorContent = await uploadResponse.Content.ReadAsStringAsync();
                _logger.LogError("Upload failed with status {Status}. Response: {Response}", 
                    uploadResponse.StatusCode, errorContent);
                throw new HttpRequestException($"Upload failed with status {uploadResponse.StatusCode}");
            }
            var uploadResult = await uploadResponse.Content.ReadFromJsonAsync<UploadResponse>();
            if (uploadResult?.upload_url == null)
            {
                _logger.LogError("Upload response missing upload_url. Response: {Response}", 
                    await uploadResponse.Content.ReadAsStringAsync());
                throw new InvalidOperationException("Failed to get upload URL from response");
            }
            _logger.LogInformation("Audio file uploaded successfully. Creating transcription request");
            // Create transcription request
            var transcriptionRequest = new TranscriptionRequest
            {
                audio_url = uploadResult.upload_url,
                language_detection = true
            };
            var transcriptionResponse = await _httpClient.PostAsJsonAsync("transcript", transcriptionRequest);
            if (!transcriptionResponse.IsSuccessStatusCode)
            {
                var errorContent = await transcriptionResponse.Content.ReadAsStringAsync();
                _logger.LogError("Transcription request failed with status {Status}. Response: {Response}", 
                    transcriptionResponse.StatusCode, errorContent);
                throw new HttpRequestException($"Transcription request failed with status {transcriptionResponse.StatusCode}");
            }
            var transcriptionResult = await transcriptionResponse.Content
                .ReadFromJsonAsync<TranscriptionResponse>();
            if (transcriptionResult?.id == null)
            {
                _logger.LogError("Transcription response missing ID. Response: {Response}", 
                    await transcriptionResponse.Content.ReadAsStringAsync());
                throw new InvalidOperationException("Failed to get transcript ID from response");
            }
            // Poll for completion
            int attempts = 0;
            const int maxAttempts = 60; // 1 minute timeout
            while (attempts < maxAttempts)
            {
                var pollingResponse = await _httpClient.GetAsync($"transcript/{transcriptionResult.id}");
                if (!pollingResponse.IsSuccessStatusCode)
                {
                    var errorContent = await pollingResponse.Content.ReadAsStringAsync();
                    _logger.LogError("Polling failed with status {Status}. Response: {Response}", 
                        pollingResponse.StatusCode, errorContent);
                    throw new HttpRequestException($"Polling failed with status {pollingResponse.StatusCode}");
                }
                var pollingResult = await pollingResponse.Content
                    .ReadFromJsonAsync<TranscriptionResponse>();
                if (pollingResult?.status == "completed")
                {
                    if (string.IsNullOrEmpty(pollingResult.text))
                    {
                        throw new InvalidOperationException("Received empty transcription text");
                    }
                    _logger.LogInformation("Transcription completed successfully");
                    return pollingResult.text;
                }
                if (pollingResult?.status == "error")
                {
                    var error = pollingResult.error ?? "Unknown error";
                    _logger.LogError("Transcription failed: {Error}", error);
                    throw new Exception($"Transcription failed: {error}");
                }
                _logger.LogInformation("Waiting for transcription to complete. Current status: {Status}", 
                    pollingResult?.status);
                attempts++;
                await Task.Delay(1000);
            }
            throw new TimeoutException("Transcription timed out after 60 seconds");
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error during transcription");
            throw;
        }
    }
    private class UploadResponse
    {
        [JsonPropertyName("upload_url")]
        public string? upload_url { get; set; }
    }
    private class TranscriptionRequest
    {
        [JsonPropertyName("audio_url")]
        public string? audio_url { get; set; }
        [JsonPropertyName("language_detection")]
        public bool language_detection { get; set; }
    }
    private class TranscriptionResponse
    {
        [JsonPropertyName("id")]
        public string? id { get; set; }
        [JsonPropertyName("status")]
        public string? status { get; set; }
        [JsonPropertyName("text")]
        public string? text { get; set; }
        [JsonPropertyName("error")]
        public string? error { get; set; }
    }
}

using System.Text.Json;
using System.Text.Json.Serialization;
using System.Net.Http.Headers;
using VoiceToEmail.Core.Interfaces;
using VoiceToEmail.Core.Models;

namespace VoiceToEmail.API.Services;

public class AIAgentService : IAIAgentService
{
    private readonly HttpClient _httpClient;
    private readonly IConfiguration _configuration;
    private readonly ILogger<AIAgentService> _logger;
    private readonly Dictionary<string, ConversationContext> _conversationContexts;
    private readonly JsonSerializerOptions _jsonOptions;

    public AIAgentService(
        HttpClient httpClient,
        IConfiguration configuration,
        ILogger<AIAgentService> logger)
    {
        _httpClient = httpClient ?? throw new ArgumentNullException(nameof(httpClient));
        _configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
        _conversationContexts = new Dictionary<string, ConversationContext>();

        var apiKey = _configuration["OpenAI:ApiKey"] ?? 
            throw new ArgumentNullException("OpenAI:ApiKey configuration is missing");
        
        _httpClient.BaseAddress = new Uri("https://api.openai.com/v1/");
        _httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
        _httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);

        _jsonOptions = new JsonSerializerOptions
        {
            PropertyNameCaseInsensitive = true,
            DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull
        };
    }

    public async Task<AIAgentResponse> ProcessMessageAsync(string message, string userId)
    {
        try
        {
            var context = await GetConversationContextAsync(userId);
            var messages = BuildConversationMessages(context, message);

            var requestBody = new
            {
                model = "gpt-4-turbo-preview",
                messages = messages,
                temperature = 0.7,
                max_tokens = 500,
                top_p = 1.0,
                frequency_penalty = 0.0,
                presence_penalty = 0.0
            };

            _logger.LogInformation("Sending request to OpenAI for user {UserId}", userId);

            using var response = await _httpClient.PostAsJsonAsync("chat/completions", requestBody, _jsonOptions);
            
            if (!response.IsSuccessStatusCode)
            {
                var errorContent = await response.Content.ReadAsStringAsync();
                _logger.LogError("OpenAI API error: {StatusCode} - {Error}", 
                    response.StatusCode, errorContent);
                throw new HttpRequestException($"OpenAI API error: {response.StatusCode}");
            }

            var responseContent = await response.Content.ReadAsStringAsync();
            var openAIResponse = JsonSerializer.Deserialize<OpenAIResponse>(responseContent, _jsonOptions);

            if (openAIResponse?.Choices == null || !openAIResponse.Choices.Any())
            {
                throw new Exception("No response choices received from OpenAI");
            }

            var aiResponse = await CreateAIResponse(openAIResponse, message);

            // Update conversation context
            await UpdateConversationContextAsync(userId, new ChatMessage 
            { 
                Role = "assistant",
                Content = aiResponse.Response 
            });

            return aiResponse;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error processing message with AI agent for user {UserId}", userId);
            throw;
        }
    }

    public async Task<string> TranslateMessageAsync(string message, string targetLanguage)
    {
        try
        {
            var requestBody = new
            {
                model = "gpt-4-turbo-preview",
                messages = new[]
                {
                    new { role = "system", content = $"You are a translator. Translate the following text to {targetLanguage}." },
                    new { role = "user", content = message }
                },
                temperature = 0.3,
                max_tokens = 500
            };

            using var response = await _httpClient.PostAsJsonAsync("chat/completions", requestBody, _jsonOptions);
            response.EnsureSuccessStatusCode();

            var responseContent = await response.Content.ReadAsStringAsync();
            var openAIResponse = JsonSerializer.Deserialize<OpenAIResponse>(responseContent, _jsonOptions);

            return openAIResponse?.Choices?.FirstOrDefault()?.Message.Content ?? message;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error translating message to {TargetLanguage}", targetLanguage);
            return message; // Return original message if translation fails
        }
    }

    public async Task<ConversationContext> GetConversationContextAsync(string userId)
    {
        return await Task.Run(() =>
        {
            lock (_conversationContexts)
            {
                if (!_conversationContexts.TryGetValue(userId, out var context))
                {
                    context = new ConversationContext
                    {
                        UserId = userId,
                        LastInteraction = DateTime.UtcNow,
                        History = new List<ChatMessage>(),
                        UserPreferences = new Dictionary<string, string>()
                    };
                    _conversationContexts[userId] = context;
                }
                return context;
            }
        });
    }

    public async Task UpdateConversationContextAsync(string userId, ChatMessage message)
    {
        try
        {
            lock (_conversationContexts)
            {
                if (_conversationContexts.TryGetValue(userId, out var context))
                {
                        // Keep only last 20 messages to manage memory
                    if (context.History.Count >= 20)
                    {
                        context.History.RemoveAt(0);
                    }
                    
                    context.History.Add(message);
                    context.LastInteraction = DateTime.UtcNow;
                }
            }
            await Task.CompletedTask;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error updating conversation context for user {UserId}", userId);
            throw;
        }
    }

    public async Task<Dictionary<string, string>> ExtractDataAsync(string message, List<string> dataPoints)
    {
        try
        {
            var promptContent = $"Extract the following information from the text: {string.Join(", ", dataPoints)}.\n\nText: {message}";
            
            var requestBody = new
            {
                model = "gpt-4-turbo-preview",
                messages = new[]
                {
                    new { role = "system", content = "You are a data extraction assistant. Respond only with extracted data in JSON format." },
                    new { role = "user", content = promptContent }
                },
                temperature = 0.0,
                max_tokens = 500
            };

            using var response = await _httpClient.PostAsJsonAsync("chat/completions", requestBody, _jsonOptions);
            response.EnsureSuccessStatusCode();

            var responseContent = await response.Content.ReadAsStringAsync();
            var openAIResponse = JsonSerializer.Deserialize<OpenAIResponse>(responseContent, _jsonOptions);

            var extractedDataJson = openAIResponse?.Choices?.FirstOrDefault()?.Message.Content;
            return JsonSerializer.Deserialize<Dictionary<string, string>>(extractedDataJson ?? "{}", _jsonOptions) 
                   ?? new Dictionary<string, string>();
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error extracting data points from message");
            return new Dictionary<string, string>();
        }
    }

    private List<object> BuildConversationMessages(ConversationContext context, string newMessage)
    {
        var messages = new List<object>
        {
            new { role = "system", content = GetSystemPrompt() }
        };

        // Add relevant conversation history
        foreach (var historyMessage in context.History.TakeLast(10))
        {
            messages.Add(new { role = historyMessage.Role, content = historyMessage.Content });
        }

        // Add new message
        messages.Add(new { role = "user", content = newMessage });

        return messages;
    }

    private string GetSystemPrompt()
    {
        return @"You are an AI assistant helping with WhatsApp messages. Your role is to:
1. Understand and respond to user queries
2. Help process voice notes and messages
3. Assist with categorizing and prioritizing messages
4. Provide helpful and concise responses
5. Maintain a professional and friendly tone

If you detect any sensitive information, flag it appropriately.";
    }

    private async Task<AIAgentResponse> CreateAIResponse(OpenAIResponse openAIResponse, string originalMessage)
    {
        var responseContent = openAIResponse.Choices[0].Message.Content;
        
        // Await all async operations
        var detectedLanguage = await DetectLanguage(originalMessage);       
        var category = await DetermineCategory(responseContent);
        var suggestedActions = await GenerateSuggestedActions(responseContent);
        
        return new AIAgentResponse
        {
            Response = responseContent,
            DetectedLanguage = detectedLanguage,            
            Category = category,
            ExtractedData = new Dictionary<string, string>(),
            SuggestedActions = suggestedActions
        };
    }


    private async Task<string> DetectLanguage(string text)
    {
        try
        {
            var requestBody = new
            {
                model = "gpt-4-turbo-preview",
                messages = new[]
                {
                    new { role = "system", content = "You are a language detection specialist. Respond only with the ISO 639-1 language code." },
                    new { role = "user", content = $"Detect the language of this text: {text}" }
                },
                temperature = 0.0,
                max_tokens = 10
            };

            using var response = await _httpClient.PostAsJsonAsync("chat/completions", requestBody, _jsonOptions);
            response.EnsureSuccessStatusCode();

            var responseContent = await response.Content.ReadAsStringAsync();
            var openAIResponse = JsonSerializer.Deserialize<OpenAIResponse>(responseContent, _jsonOptions);
            var languageCode = openAIResponse?.Choices?.FirstOrDefault()?.Message.Content.Trim().ToLower() ?? "en";

            return languageCode;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error detecting language");
            return "en"; // Default to English on error
        }
    }


    private async Task<string> DetermineCategory(string content)
    {
        try
        {
            var requestBody = new
            {
                model = "gpt-4-turbo-preview",
                messages = new[]
                {
                    new { role = "system", content = @"Categorize this message into ONE of these categories:
    - event: Any requests related to tickets, matches, games, or sporting events
    - support: Customer support or technical issues
    - sales: Sales-related inquiries or opportunities
    - billing: Payment or invoice related
    - feedback: Customer feedback or suggestions
    - inquiry: General questions or information requests
    - complaint: Customer complaints or issues
    - general: Other general communication
    Respond with only the category name in lowercase." },
                    new { role = "user", content = content }
                },
                temperature = 0.0,
                max_tokens = 10
            };

            using var response = await _httpClient.PostAsJsonAsync("chat/completions", requestBody, _jsonOptions);
            response.EnsureSuccessStatusCode();

            var responseContent = await response.Content.ReadAsStringAsync();
            var openAIResponse = JsonSerializer.Deserialize<OpenAIResponse>(responseContent, _jsonOptions);
            return openAIResponse?.Choices?.FirstOrDefault()?.Message.Content.Trim().ToLower() ?? "general";
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error determining category");
            return "general";
        }
    }

    public async Task<EventDetails> ExtractEventDetailsFromMessage(string content)
    {
        try
        {
            var promptContent = @"Extract the following information from the text. If any field is not found, leave it as null or empty:
        - eventName (look for team names, match names)
        - requestedDate
        - fanName
        - fanEmail
        - ticketQuantity (default to 1 if not specified)
        - specialRequirements

        Respond in JSON format matching the following structure:
        {
            ""eventName"": """",
            ""requestedDate"": """",
            ""fanName"": """",
            ""fanEmail"": """",
            ""ticketQuantity"": 1,
            ""specialRequirements"": """"
        }";

            var requestBody = new
            {
                model = "gpt-4-turbo-preview",
                messages = new[]
                {
                    new { role = "system", content = "You are a data extraction assistant. Extract event booking details from the text. Return only valid JSON with no markdown formatting." },
                    new { role = "user", content = $"{promptContent}\n\nText: {content}" }
                },
                temperature = 0.0,
                max_tokens = 500
            };

            using var response = await _httpClient.PostAsJsonAsync("chat/completions", requestBody, _jsonOptions);
            response.EnsureSuccessStatusCode();

            var responseContent = await response.Content.ReadAsStringAsync();
            var openAIResponse = JsonSerializer.Deserialize<OpenAIResponse>(responseContent, _jsonOptions);
            var extractedDataJson = openAIResponse?.Choices?.FirstOrDefault()?.Message.Content;
            
            // Clean up the JSON string if it contains markdown formatting
            if (!string.IsNullOrEmpty(extractedDataJson))
            {
                // Remove markdown code blocks if present
                extractedDataJson = extractedDataJson
                    .Replace("```json", "")
                    .Replace("```", "")
                    .Trim();
            }
            
            var eventDetails = JsonSerializer.Deserialize<EventDetails>(extractedDataJson ?? "{}", _jsonOptions) 
                            ?? new EventDetails();

            // Ensure default values
            eventDetails.TicketQuantity = eventDetails.TicketQuantity == 0 ? 1 : eventDetails.TicketQuantity;
            eventDetails.RequestedDate = string.IsNullOrWhiteSpace(eventDetails.RequestedDate)
                ? DateTime.Now.AddDays(1).ToString("yyyy-MM-dd")
                : eventDetails.RequestedDate;
            
            return eventDetails;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error extracting event details");
            return new EventDetails();
        }
    }

    private async Task<List<string>> GenerateSuggestedActions(string content)
    {
        try
        {
            var requestBody = new
            {
                model = "gpt-4-turbo-preview",
                messages = new[]
                {
                    new { role = "system", content = @"Generate 1-3 suggested actions based on the message content.
    Rules:
    1. Each action should start with a verb
    2. Keep actions concise and actionable
    3. Format as JSON array of strings
    4. Consider message context and priority
    Example: ['Schedule follow-up call', 'Send pricing document']" },
                    new { role = "user", content = content }
                },
                temperature = 0.7,
                max_tokens = 150
            };

            using var response = await _httpClient.PostAsJsonAsync("chat/completions", requestBody, _jsonOptions);
            response.EnsureSuccessStatusCode();

            var responseContent = await response.Content.ReadAsStringAsync();
            var openAIResponse = JsonSerializer.Deserialize<OpenAIResponse>(responseContent, _jsonOptions);
            var actionsJson = openAIResponse?.Choices?.FirstOrDefault()?.Message.Content ?? "[]";
            
            return JsonSerializer.Deserialize<List<string>>(actionsJson, _jsonOptions) ?? new List<string>();
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error generating suggested actions");
            return new List<string>();
        }
    }

    private class OpenAIResponse
    {
        [JsonPropertyName("id")]
        public string Id { get; set; } = string.Empty;

        [JsonPropertyName("object")]
        public string Object { get; set; } = string.Empty;

        [JsonPropertyName("created")]
        public int Created { get; set; }

        [JsonPropertyName("model")]
        public string Model { get; set; } = string.Empty;

        [JsonPropertyName("choices")]
        public List<Choice> Choices { get; set; } = new();

        [JsonPropertyName("usage")]
        public Usage Usage { get; set; } = new();
    }

    private class Choice
    {
        [JsonPropertyName("index")]
        public int Index { get; set; }

        [JsonPropertyName("message")]
        public ChatMessage Message { get; set; } = new();

        [JsonPropertyName("finish_reason")]
        public string FinishReason { get; set; } = string.Empty;
    }

    private class Usage
    {
        [JsonPropertyName("prompt_tokens")]
        public int PromptTokens { get; set; }

        [JsonPropertyName("completion_tokens")]
        public int CompletionTokens { get; set; }

        [JsonPropertyName("total_tokens")]
        public int TotalTokens { get; set; }
    }
}

using System.Net.Http.Headers;
using System.Text.Json;
using System.Text.Json.Serialization;
using VoiceToEmail.Core.Interfaces;
using VoiceToEmail.Core.Models;
using PdfSharpCore.Drawing;
using PdfSharpCore.Pdf;
using System.IO;
using SixLabors.ImageSharp; // For logo images
using SixLabors.ImageSharp.PixelFormats;
using SixLabors.ImageSharp.Formats.Png;

namespace VoiceToEmail.API.Services;

public class TicketService : ITicketService
{
    private readonly IConfiguration _configuration;
    private readonly HttpClient _httpClient;
    private readonly ILogger<TicketService> _logger;
    private readonly IEmailService _emailService;
    
    // Enhanced mock database with more matches and details
    private static readonly Dictionary<string, EventInfo> _matchDatabase = new()
    {
        { "Chelsea vs Arsenal", new EventInfo { 
            Date = DateTime.Parse("2025-02-15"), 
            AvailableSeats = 50,
            Venue = "Stamford Bridge",
            KickoffTime = "15:00",
            Category = "Premier League",
            TicketPrices = new Dictionary<string, decimal> {
                { "Standard", 60.00m },
                { "Premium", 120.00m }
            },
            SeatNumbers = new Queue<string>(Enumerable.Range(1, 50).Select(i => $"A{i}")) // Example: A1, A2, ..., A50
        }},
        { "Manchester United vs Liverpool", new EventInfo { 
            Date = DateTime.Parse("2025-03-12"), 
            AvailableSeats = 35,
            Venue = "Old Trafford",
            KickoffTime = "17:30",
            Category = "Premier League",
            TicketPrices = new Dictionary<string, decimal> {
                { "Standard", 70.00m },
                { "Premium", 150.00m }
            },
            SeatNumbers = new Queue<string>(Enumerable.Range(1, 35).Select(i => $"B{i}")) // Example: B1, B2, ..., B35
        }},
        { "Arsenal vs Tottenham", new EventInfo { 
            Date = DateTime.Parse("2025-04-05"), 
            AvailableSeats = 40,
            Venue = "Emirates Stadium",
            KickoffTime = "12:30",
            Category = "Premier League",
            TicketPrices = new Dictionary<string, decimal> {
                { "Standard", 65.00m },
                { "Premium", 130.00m }
            },
            SeatNumbers = new Queue<string>(Enumerable.Range(1, 40).Select(i => $"C{i}")) // Example: C1, C2, ..., C40
        }},
        { "Manchester City vs Chelsea", new EventInfo { 
            Date = DateTime.Parse("2025-03-22"), 
            AvailableSeats = 45,
            Venue = "Etihad Stadium",
            KickoffTime = "14:00",
            Category = "Premier League",
            TicketPrices = new Dictionary<string, decimal> {
                { "Standard", 68.00m },
                { "Premium", 140.00m }
            },
            SeatNumbers = new Queue<string>(Enumerable.Range(1, 45).Select(i => $"D{i}")) // Example: D1, D2, ..., D45
        }}
    };

    public class OpenAiResponse
    {
        public List<Choice> Choices { get; set; }
    }

    public class Choice
    {
        public Message Message { get; set; }
    }

    public class Message
    {
        public string Content { get; set; }
    }

    // Custom model for mapping OpenAI response properties to EventDetails
    public class EventDetailsDto
    {
        [JsonPropertyName("Event name")]
        public string EventName { get; set; }
        
        [JsonPropertyName("Requested date")]
        public string RequestedDate { get; set; }
        
        [JsonPropertyName("Fan's name")]
        public string FanName { get; set; }
        
        [JsonPropertyName("Fan's email")]
        public string FanEmail { get; set; }
        
        [JsonPropertyName("Number of tickets requested")]
        public int TicketQuantity { get; set; }
        
        [JsonPropertyName("Special requirements")]
        public string SpecialRequirements { get; set; }
        
        [JsonPropertyName("Ticket type")]
        public string TicketType { get; set; }
    }

    public TicketService(
        IConfiguration configuration,
        HttpClient httpClient,
        ILogger<TicketService> logger,
        IEmailService emailService)
    {
        _configuration = configuration;
        _httpClient = httpClient;
        _logger = logger;
        _emailService = emailService;
    }

    public async Task<EventDetails> ExtractEventDetailsAsync(string transcription)
    {
        try
        {
            var openAiKey = _configuration["OpenAI:ApiKey"];
            _httpClient.DefaultRequestHeaders.Authorization = 
                new AuthenticationHeaderValue("Bearer", openAiKey);

            var requestBody = new
            {
                model = "gpt-4-turbo-preview",
                messages = new[]
                {
                    new 
                    { 
                        role = "system",
                        content = "You are a helpful assistant that extracts information from text. Always respond with only valid JSON with no markdown formatting, code blocks, or explanations."
                    },
                    new 
                    { 
                        role = "user", 
                        content = $@"Extract the following information from this text for a football match ticket booking. Use the exact property names in the response JSON:
                        - ""Event name"": The match name with format 'Team A vs Team B'
                        - ""Requested date"": If specific date mentioned
                        - ""Fan's name"": The person's name
                        - ""Fan's email"": Email address if mentioned (ensure it has an @ symbol)
                        - ""Number of tickets requested"": Default to 1 if not specified
                        - ""Special requirements"": Any accessibility needs, seating preferences
                        - ""Ticket type"": Standard or premium, default to standard if not specified

                        Text: {transcription}" 
                    }
                }
            };

            var response = await _httpClient.PostAsJsonAsync(
                "https://api.openai.com/v1/chat/completions", 
                requestBody);

            response.EnsureSuccessStatusCode();
            
            var responseContent = await response.Content.ReadAsStringAsync();
            _logger.LogInformation("Raw OpenAI response: {response}", responseContent);
            
            var options = new JsonSerializerOptions { 
                PropertyNameCaseInsensitive = true,
                PropertyNamingPolicy = null // Use exact property names
            };
            
            var openAiResponse = JsonSerializer.Deserialize<OpenAiResponse>(responseContent, options);
            
            if (openAiResponse?.Choices == null || openAiResponse.Choices.Count == 0)
            {
                throw new Exception("No response content from OpenAI API");
            }
            
            var jsonContent = openAiResponse.Choices[0].Message.Content;
            _logger.LogInformation("OpenAI extracted content: {Content}", jsonContent);
            
            // Clean the content from any markdown code blocks if present
            jsonContent = CleanJsonContent(jsonContent);
            
            // Parse the JSON string from OpenAI's response with custom EventDetailsDto
            var dto = JsonSerializer.Deserialize<EventDetailsDto>(jsonContent, options);
            
            // Map to our EventDetails model
            var eventDetails = new EventDetails
            {
                EventName = dto?.EventName ?? string.Empty,
                RequestedDate = string.IsNullOrEmpty(dto?.RequestedDate) ? 
                    GetDefaultMatchDate(dto?.EventName ?? string.Empty).ToString("yyyy-MM-dd") : 
                    ParseDate(dto.RequestedDate).ToString("yyyy-MM-dd"),
                FanName = dto?.FanName ?? string.Empty,
                FanEmail = FixEmailFormat(dto?.FanEmail ?? string.Empty),
                TicketQuantity = dto?.TicketQuantity <= 0 ? 1 : dto.TicketQuantity,
                SpecialRequirements = dto?.SpecialRequirements ?? string.Empty,
                TicketType = string.IsNullOrEmpty(dto?.TicketType) ? "Standard" : dto.TicketType
            };
            
            return eventDetails;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error extracting event details from transcription");
            return new EventDetails();
        }
    }

    private DateTime ParseDate(string dateString)
    {
        if (DateTime.TryParse(dateString, out DateTime parsedDate))
        {
            return parsedDate;
        }
        
        // Try different formats if standard parsing fails
        string[] formats = { "MMM d yyyy", "MMMM d yyyy", "yyyy-MM-dd", "dd/MM/yyyy", "MM/dd/yyyy" };
        if (DateTime.TryParseExact(dateString, formats, null, System.Globalization.DateTimeStyles.None, out parsedDate))
        {
            return parsedDate;
        }
        
        return DateTime.Now.AddDays(7); // Default fallback
    }

    private string FixEmailFormat(string email)
    {
        if (string.IsNullOrEmpty(email))
            return string.Empty;
            
        // Check if @ is missing but there's a domain part
        if (!email.Contains("@") && (email.Contains(".com") || email.Contains(".net") || email.Contains(".org")))
        {
            // Find the domain part
            int domainStart = email.IndexOf('.') - 4; // Approximate position before .com/.net/etc.
            if (domainStart > 0)
            {
                return email.Insert(domainStart, "@");
            }
        }
        
        return email;
    }

    private DateTime GetDefaultMatchDate(string matchName)
    {
        if (_matchDatabase.TryGetValue(matchName, out var eventInfo))
        {
            return eventInfo.Date;
        }
        return DateTime.Now.AddDays(7);
    }

    private string CleanJsonContent(string content)
    {
        // Remove markdown code block formatting if present
        if (content.StartsWith("```") && content.EndsWith("```"))
        {
            // Extract content between first and last ``` markers
            var firstIndex = content.IndexOf('\n');
            var lastIndex = content.LastIndexOf("```");
            
            if (firstIndex > 0 && lastIndex > firstIndex)
            {
                content = content.Substring(firstIndex, lastIndex - firstIndex).Trim();
            }
        }
        
        // Remove any starting/ending ``` and json tag if present
        content = content.Replace("```json", "").Replace("```", "").Trim();

        
        return content;
    }

    public async Task<bool> CheckAvailabilityAsync(string eventName, DateTime date)
    {
        return await Task.Run(() => {
            if (_matchDatabase.TryGetValue(eventName, out var eventInfo))
            {
                return eventInfo.AvailableSeats > 0 && eventInfo.Date.Date == date.Date;
            }
            return false;
        });
    }

    public async Task<EventInfo> GetMatchInfoAsync(string eventName)
    {
        if (_matchDatabase.TryGetValue(eventName, out var eventInfo))
        {
            return eventInfo;
        }
        throw new Exception($"Match '{eventName}' not found");
    }

    public async Task<List<DateTime>> GetAlternativeDatesAsync(string eventName)
    {
        // In a real application, this would query a database for alternative dates
        // Here we're simulating with hardcoded alternatives
        return await Task.Run(() => {
            if (eventName.Contains("Chelsea") && eventName.Contains("Arsenal"))
            {
                return new List<DateTime> { 
                    DateTime.Parse("2025-05-10"), 
                    DateTime.Parse("2025-08-22") 
                };
            }
            else if (eventName.Contains("Manchester United") && eventName.Contains("Liverpool"))
            {
                return new List<DateTime> { 
                    DateTime.Parse("2025-04-15"), 
                    DateTime.Parse("2025-07-30") 
                };
            }
            return new List<DateTime>();
        });
    }

    public async Task<List<string>> GetAvailableMatchesAsync()
    {
        return await Task.Run(() => {
            return _matchDatabase.Where(m => m.Value.AvailableSeats > 0)
                                .Select(m => m.Key)
                                .ToList();
        });
    }

    public async Task<TicketBookingResult> BookTicketAsync(string eventName, DateTime date, string userEmail, int quantity = 1)
    {
        try
        {
            if (!_matchDatabase.TryGetValue(eventName, out var eventInfo))
            {
                return new TicketBookingResult
                {
                    Success = false,
                    Message = "Match not found"
                };
            }

            if (eventInfo.AvailableSeats < quantity)
            {
                return new TicketBookingResult
                {
                    Success = false,
                    Message = $"Not enough tickets available. Only {eventInfo.AvailableSeats} tickets left."
                };
            }

            if (!string.IsNullOrEmpty(userEmail) && !userEmail.Contains('@'))
            {
                return new TicketBookingResult
                {
                    Success = false,
                    Message = "Invalid email format. Please provide a valid email address."
                };
            }

            // Dummy payment check (simulate payment confirmation)
            bool paymentConfirmed = DummyPaymentService.ConfirmPayment(userEmail, eventName, quantity);
            if (!paymentConfirmed)
            {
                return new TicketBookingResult
                {
                    Success = false,
                    Message = "Payment not confirmed. Please complete your payment to receive your ticket."
                };
            }

            // Assign seat numbers
            var assignedSeats = new List<string>();
            for (int i = 0; i < quantity; i++)
            {
                if (eventInfo.SeatNumbers.Count > 0)
                    assignedSeats.Add(eventInfo.SeatNumbers.Dequeue());
                else
                    assignedSeats.Add("Unassigned");
            }

            eventInfo.AvailableSeats -= quantity;

            var bookingDetails = new BookingDetails
            {
                EventName = eventName,
                Date = date,
                Venue = eventInfo.Venue,
                KickoffTime = eventInfo.KickoffTime,
                TicketReference = GenerateTicketReference(),
                UserEmail = userEmail,
                Quantity = quantity,
                Category = eventInfo.Category,
                BookingTime = DateTime.UtcNow,
                TotalPrice = eventInfo.TicketPrices["Standard"] * quantity,
                SeatNumbers = assignedSeats // Add this property to BookingDetails
            };

            bookingDetails.RequestedDate = eventInfo.Date.ToString("yyyy-MM-dd");

            // Only send email if payment is confirmed
            await _emailService.SendSoccerTicketEmailAsync(
                userEmail,
                "Your Soccer Match Ticket",
                $"Please find your ticket attached. Amount paid: £{bookingDetails.TotalPrice:F2}. Seats: {string.Join(", ", assignedSeats)}",
                bookingDetails);

            return new TicketBookingResult
            {
                Success = true,
                Message = "Tickets booked successfully!",
                BookingDetails = bookingDetails
            };
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error booking ticket");
            throw;
        }
    }

    private string GenerateTicketReference()
    {
        return $"MATCH-{Guid.NewGuid().ToString("N").Substring(0, 8).ToUpper()}";
    }
}

public static class DummyPaymentService
{
    public static bool ConfirmPayment(string userEmail, string eventName, int quantity)
    {
        // Always returns true for demo; replace with real logic as needed
        return true;
    }
}

using SendGrid;
using SendGrid.Helpers.Mail;
using VoiceToEmail.Core.Interfaces;
using VoiceToEmail.Core.Models;
using PdfSharpCore.Drawing;
using PdfSharpCore.Pdf;
using System.IO;
public class EmailService : IEmailService
{
    private readonly SendGridClient _client;
    private readonly string _fromEmail;
    private readonly string _fromName;
    public EmailService(IConfiguration configuration)
    {
        var apiKey = configuration["SendGrid:ApiKey"] ?? 
            throw new ArgumentNullException("SendGrid:ApiKey configuration is missing");
        _client = new SendGridClient(apiKey);
        _fromEmail = configuration["SendGrid:FromEmail"] ?? 
            throw new ArgumentNullException("SendGrid:FromEmail configuration is missing");
        _fromName = configuration["SendGrid:FromName"] ?? 
            throw new ArgumentNullException("SendGrid:FromName configuration is missing");
    }
    public async Task SendEmailAsync(string to, string subject, string content)
    {
        await SendEmailAsync(to, subject, content, null);
    }
    public async Task SendEmailAsync(string to, string subject, string content, byte[]? pdfAttachment = null)
    {
        var from = new EmailAddress(_fromEmail, _fromName);
        var toAddress = new EmailAddress(to);
        var msg = MailHelper.CreateSingleEmail(
            from,
            toAddress,
            subject,
            content,
            $"<div style='font-family: Arial, sans-serif;'>{content}</div>"
        );
        // Attach PDF if provided
        if (pdfAttachment != null)
        {
            msg.AddAttachment("Ticket.pdf", Convert.ToBase64String(pdfAttachment), "application/pdf");
        }
        var response = await _client.SendEmailAsync(msg);
        if (!response.IsSuccessStatusCode)
        {
            throw new Exception($"Failed to send email: {response.StatusCode}");
        }
    }
    private byte[] GenerateSoccerTicketPdf(object bookingDetails)
    {
        var details = bookingDetails as BookingDetails;
        if (details == null)
            throw new ArgumentException("bookingDetails must be of type BookingDetails");
        using (var doc = new PdfDocument())
        {
            var page = doc.AddPage();
            page.Width = XUnit.FromMillimeter(170);
            page.Height = XUnit.FromMillimeter(70);
            var gfx = XGraphics.FromPdfPage(page);
            // Draw border
            gfx.DrawRectangle(XPens.Black, 5, 5, page.Width - 10, page.Height - 10);
            // Main Title
            var titleFont = new XFont("Arial", 18, XFontStyle.Bold);
            gfx.DrawString("SOCCER MATCH TICKET", titleFont, XBrushes.DarkBlue, new XRect(0, 15, page.Width, 30), XStringFormats.TopCenter);
            // Event Info
            var font = new XFont("Arial", 12, XFontStyle.Regular);
            gfx.DrawString($"Match: {details.EventName}", font, XBrushes.Black, new XRect(20, 45, page.Width - 40, 20), XStringFormats.TopLeft);
            gfx.DrawString($"Date: {details.Date:dd MMM yyyy}", font, XBrushes.Black, new XRect(20, 60, 200, 20), XStringFormats.TopLeft);
            gfx.DrawString($"Kickoff: {details.KickoffTime}", font, XBrushes.Black, new XRect(220, 60, 200, 20), XStringFormats.TopLeft);
            gfx.DrawString($"Venue: {details.Venue}", font, XBrushes.Black, new XRect(20, 75, page.Width - 40, 20), XStringFormats.TopLeft);
            gfx.DrawString($"Category: {details.Category}", font, XBrushes.Black, new XRect(20, 90, 200, 20), XStringFormats.TopLeft);
            gfx.DrawString($"Quantity: {details.Quantity}", font, XBrushes.Black, new XRect(220, 90, 200, 20), XStringFormats.TopLeft);
            gfx.DrawString($"Ticket Ref: {details.TicketReference}", font, XBrushes.Black, new XRect(20, 105, page.Width - 40, 20), XStringFormats.TopLeft);
            gfx.DrawString($"Issued to: {details.UserEmail}", font, XBrushes.Black, new XRect(20, 120, page.Width - 40, 20), XStringFormats.TopLeft);
            // Add seat numbers
            var seatNumbers = details.SeatNumbers != null ? string.Join(", ", details.SeatNumbers) : "Unassigned";
            gfx.DrawString($"Seats: {seatNumbers}", font, XBrushes.Black, new XRect(20, 135, page.Width - 40, 20), XStringFormats.TopLeft);
            // Add amount paid
            gfx.DrawString($"Amount Paid: £{details.TotalPrice:F2}", font, XBrushes.Black, new XRect(20, 150, page.Width - 40, 20), XStringFormats.TopLeft);
            // Fake barcode (for demo)
            var barcodeFont = new XFont("Arial", 20, XFontStyle.Bold);
            gfx.DrawString("|| ||| | || |||", barcodeFont, XBrushes.Black, new XRect(20, 170, page.Width - 40, 30), XStringFormats.TopLeft);
            // Save to byte array
            using (var ms = new MemoryStream())
            {
                doc.Save(ms, false);
                return ms.ToArray();
            }
        }
    }
    public async Task SendSoccerTicketEmailAsync(string userEmail, string subject, string body, BookingDetails bookingDetails)
    {
        // Enhance email body with seat numbers and amount paid
        var seatNumbers = bookingDetails.SeatNumbers != null ? string.Join(", ", bookingDetails.SeatNumbers) : "Unassigned";
        var enhancedBody = $"{body}<br/><br/><strong>Seats:</strong> {seatNumbers}<br/><strong>Amount Paid:</strong> £{bookingDetails.TotalPrice:F2}";
        var pdfBytes = GenerateSoccerTicketPdf(bookingDetails);
        await SendEmailAsync(userEmail, subject, enhancedBody, pdfBytes);
    }
    public async Task SendSoccerTicketEmailAsync(string userEmail, string subject, string body, object bookingDetails)
    {
        if (bookingDetails is BookingDetails details)
        {
            await SendSoccerTicketEmailAsync(userEmail, subject, body, details);
        }
        else
        {
            throw new ArgumentException("bookingDetails must be of type BookingDetails");
        }
    }
}

using Microsoft.AspNetCore.Mvc;
using System.Text;
using System.Xml.Linq;
using VoiceToEmail.Core.Models;
using VoiceToEmail.Core.Interfaces;
namespace VoiceToEmail.API.Controllers;
[ApiController]
[Route("api/[controller]")]
public class WhatsAppController : ControllerBase
{
    private readonly IWhatsAppService _whatsAppService;
    private readonly ILogger<WhatsAppController> _logger;
    public WhatsAppController(
        IWhatsAppService whatsAppService,
        ILogger<WhatsAppController> logger)
    {
        _whatsAppService = whatsAppService ?? throw new ArgumentNullException(nameof(whatsAppService));
        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
    }
    [HttpGet]
    public IActionResult Test()
    {
        _logger.LogInformation("Test endpoint hit at: {Time}", DateTime.UtcNow);
        return Ok(new { status = "success", message = "WhatsApp endpoint is working!" });
    }
    [HttpPost]
    [Consumes("application/x-www-form-urlencoded")]
    public async Task<IActionResult> Webhook([FromForm] Dictionary<string, string> form)
    {
        try
        {
            _logger.LogInformation("Webhook received at: {Time}", DateTime.UtcNow);
            if (form == null || !form.Any())
            {
                _logger.LogWarning("Empty or null form data received");
                return BadTwiMLResponse("Invalid request format.");
            }
            // Log incoming data securely (excluding sensitive information)
            LogFormData(form);
            // Validate required fields
            if (!ValidateRequiredFields(form, out string errorMessage))
            {
                _logger.LogWarning("Missing required fields: {ErrorMessage}", errorMessage);
                return BadTwiMLResponse(errorMessage);
            }
            var message = CreateWhatsAppMessage(form);
            try
            {
                // The response now comes from the WhatsAppService which should handle booking logic
                var response = await _whatsAppService.HandleIncomingMessageAsync(message);
                _logger.LogInformation("Message processed successfully for {From}", message.From);
                return TwiMLResponse(response);
            }
            catch (Exception ex) when (ex is HttpRequestException || ex is TimeoutException)
            {
                _logger.LogError(ex, "Service communication error for {From}", message.From);
                return BadTwiMLResponse("We're experiencing technical difficulties. Please try again shortly.");
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error processing message for {From}", message.From);
                return BadTwiMLResponse("Sorry, we couldn't process your message. Please try again.");
            }
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Unhandled error in webhook");
            return BadTwiMLResponse("An unexpected error occurred. Please try again later.");
        }
    }
    private WhatsAppMessage CreateWhatsAppMessage(Dictionary<string, string> form)
    {
        var message = new WhatsAppMessage
        {
            MessageSid = form.GetValueOrDefault("MessageSid", string.Empty),
            From = form.GetValueOrDefault("From", string.Empty),
            To = form.GetValueOrDefault("To", string.Empty),
            Body = form.GetValueOrDefault("Body", string.Empty)
        };
        if (int.TryParse(form.GetValueOrDefault("NumMedia", "0"), out int numMedia))
        {
            message.NumMedia = numMedia;
            ProcessMediaAttachments(form, message, numMedia);
        }
        return message;
    }
    private void ProcessMediaAttachments(Dictionary<string, string> form, WhatsAppMessage message, int numMedia)
    {
        for (int i = 0; i < numMedia; i++)
        {
            var mediaUrl = form.GetValueOrDefault($"MediaUrl{i}");
            var mediaContentType = form.GetValueOrDefault($"MediaContentType{i}");
            if (!string.IsNullOrEmpty(mediaUrl) && !string.IsNullOrEmpty(mediaContentType))
            {
                message.MediaUrls[mediaContentType] = mediaUrl;
                _logger.LogInformation("Media attachment processed - Type: {MediaType}, URL: {MediaUrl}", 
                    mediaContentType, mediaUrl);
            }
        }
    }
    private bool ValidateRequiredFields(Dictionary<string, string> form, out string errorMessage)
    {
        var requiredFields = new[] { "From", "To" };
        var missingFields = requiredFields.Where(field => !form.ContainsKey(field) || string.IsNullOrEmpty(form[field]));
        if (missingFields.Any())
        {
            errorMessage = $"Missing required fields: {string.Join(", ", missingFields)}";
            return false;
        }
        errorMessage = string.Empty;
        return true;
    }
    private void LogFormData(Dictionary<string, string> form)
    {
        var sensitiveKeys = new[] { "AccountSid", "ApiKey", "ApiSecret" };
        foreach (var item in form.Where(x => !sensitiveKeys.Contains(x.Key)))
        {
            _logger.LogInformation("Form data - {Key}: {Value}", 
                item.Key, 
                item.Key.Contains("Media") ? "[Media Content]" : item.Value);
        }
    }
    private IActionResult TwiMLResponse(string message)
    {
        var response = new XDocument(
            new XElement("Response",
                new XElement("Message", new XCData(message))
            ));
        return Content(response.ToString(), "application/xml", Encoding.UTF8);
    }
    private IActionResult BadTwiMLResponse(string errorMessage)
    {
        return TwiMLResponse(errorMessage);
    }
}

{
  "OpenAI": {
    "ApiKey": "OPENAI_API_KEY"
  },
  "SendGrid": {
    "ApiKey": "SENDGRID_API_KEY",
    "FromEmail": "SENDGRID_FROM_EMAIL",
    "FromName": "SENDGRID_FROM_NAME"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "Twilio": {
    "AccountSid": "TWILIO_ACCOUNT_SID",
    "AuthToken": "TWILIO_AUTH_TOKEN",
    "WhatsAppNumber": "TWILIO_WHATSAPP_NUMBER"
  },
  "AssemblyAI": {
    "ApiKey": "ASSEMBLYAI_API_KEY"
  },
  "AllowedHosts": "*"
}

using Microsoft.Extensions.DependencyInjection;
using VoiceToEmail.API.Services;
using VoiceToEmail.Core.Interfaces;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
// Register HttpClient
builder.Services.AddHttpClient();
builder.Services.AddHttpClient<IAIAgentService, AIAgentService>();
// Register services
builder.Services.AddScoped<ITranscriptionService, TranscriptionService>();
builder.Services.AddScoped<IEmailService, EmailService>();
builder.Services.AddScoped<ITicketService, TicketService>();
builder.Services.AddScoped<IAIAgentService, AIAgentService>();
builder.Services.AddScoped<IWhatsAppService, WhatsAppService>();
var app = builder.Build();
// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}
app.UseHttpsRedirection();
app.UseAuthorization();
// Use top-level route registration (fixing ASP0014 warning)
app.MapControllers();
app.Run();

cd VoiceToEmail.API
dotnet build
dotnet run

ngrok http 5168