using GreenHome.VoiceCall.Avanak;
using Microsoft.AspNetCore.Mvc;

namespace GreenHome.Api.Controllers;

/// <summary>
/// Controller for testing Voice Call service (Avanak)
/// </summary>
[ApiController]
[Route("api/[controller]")]
public class VoiceCallTestController : ControllerBase
{
    private readonly IVoiceCallService voiceCallService;
    private readonly ILogger<VoiceCallTestController> logger;

    public VoiceCallTestController(IVoiceCallService voiceCallService, ILogger<VoiceCallTestController> logger)
    {
        this.voiceCallService = voiceCallService;
        this.logger = logger;
    }

    /// <summary>
    /// Test getting account status
    /// </summary>
    /// <returns>Account status response</returns>
    [HttpGet("account-status")]
    public async Task<IActionResult> GetAccountStatus()
    {
        try
        {
            logger.LogInformation("Testing AccountStatus");
            
            var result = await voiceCallService.GetAccountStatusAsync();
            
            logger.LogInformation("AccountStatus retrieved successfully");
            
            return Ok(new
            {
                success = true,
                message = "وضعیت حساب با موفقیت دریافت شد",
                data = result
            });
        }
        catch (Exception ex)
        {
            logger.LogError(ex, "Error getting account status");
            return StatusCode(500, new
            {
                success = false,
                message = "خطا در دریافت وضعیت حساب",
                error = ex.Message
            });
        }
    }

    /// <summary>
    /// Test generating TTS (Text-to-Speech)
    /// </summary>
    /// <param name="request">TTS generation request</param>
    /// <returns>TTS generation response</returns>
    [HttpPost("generate-tts")]
    public async Task<IActionResult> GenerateTTS([FromBody] GenerateTTSRequest request)
    {
        try
        {
            logger.LogInformation("Testing GenerateTTS for text: {Text}", request.Text);
            
            var result = await voiceCallService.GenerateTTSAsync(request);
            
            logger.LogInformation("TTS generated successfully");
            
            return Ok(new
            {
                success = true,
                message = "تولید صوت با موفقیت انجام شد",
                data = result
            });
        }
        catch (Exception ex)
        {
            logger.LogError(ex, "Error generating TTS");
            return StatusCode(500, new
            {
                success = false,
                message = "خطا در تولید صوت",
                error = ex.Message
            });
        }
    }

    /// <summary>
    /// Test QuickSend (sending voice call with uploaded audio file)
    /// </summary>
    /// <param name="request">QuickSend request</param>
    /// <returns>QuickSend response</returns>
    [HttpPost("quick-send")]
    public async Task<IActionResult> QuickSend([FromBody] QuickSendRequest request)
    {
        try
        {
            logger.LogInformation("Testing QuickSend to {Recipient} with MessageId {MessageId}", 
                request.Recipient, request.MessageId);
            
            var result = await voiceCallService.QuickSendAsync(request);
            
            logger.LogInformation("QuickSend completed successfully");
            
            return Ok(new
            {
                success = true,
                message = "تماس صوتی با موفقیت ارسال شد",
                data = result
            });
        }
        catch (Exception ex)
        {
            logger.LogError(ex, "Error sending quick voice call");
            return StatusCode(500, new
            {
                success = false,
                message = "خطا در ارسال تماس صوتی",
                error = ex.Message
            });
        }
    }

    /// <summary>
    /// Test QuickSendWithTTS (sending voice call with TTS)
    /// </summary>
    /// <param name="request">QuickSendWithTTS request</param>
    /// <returns>QuickSendWithTTS response</returns>
    [HttpPost("quick-send-with-tts")]
    public async Task<IActionResult> QuickSendWithTTS([FromBody] QuickSendWithTTSRequest request)
    {
        try
        {
            logger.LogInformation("Testing QuickSendWithTTS to {Number} with text: {Text}", 
                request.Number, request.Text);
            
            var result = await voiceCallService.QuickSendWithTTSAsync(request);
            
            if (result != null && result.IsSuccess)
            {
                logger.LogInformation("QuickSendWithTTS completed successfully. QuickSendId: {QuickSendId}", 
                    result.QuickSendId);
            }
            else
            {
                logger.LogWarning("QuickSendWithTTS failed with ReturnValue: {ReturnValue}", 
                    result?.ReturnValue ?? 0);
            }
            
            return Ok(new
            {
                success = result?.IsSuccess ?? false,
                message = result?.IsSuccess == true 
                    ? "تماس صوتی با موفقیت ارسال شد" 
                    : $"خطا در ارسال تماس صوتی (کد خطا: {result?.ReturnValue})",
                data = result,
                quickSendId = result?.QuickSendId ?? 0
            });
        }
        catch (Exception ex)
        {
            logger.LogError(ex, "Error sending quick voice call with TTS");
            return StatusCode(500, new
            {
                success = false,
                message = "خطا در ارسال تماس صوتی",
                error = ex.Message
            });
        }
    }

    /// <summary>
    /// Test getting QuickSend status
    /// </summary>
    /// <param name="request">GetQuickSend request</param>
    /// <returns>QuickSend status response</returns>
    [HttpPost("quick-send-status")]
    public async Task<IActionResult> GetQuickSendStatus([FromBody] GetQuickSendRequest request)
    {
        try
        {
            logger.LogInformation("Testing GetQuickSendStatus for QuickSendId: {QuickSendId}", 
                request.QuickSendId);
            
            var result = await voiceCallService.GetQuickSendStatusAsync(request);
            
            logger.LogInformation("QuickSendStatus retrieved successfully");
            
            return Ok(new
            {
                success = true,
                message = "وضعیت تماس صوتی با موفقیت دریافت شد",
                data = result
            });
        }
        catch (Exception ex)
        {
            logger.LogError(ex, "Error getting quick send status");
            return StatusCode(500, new
            {
                success = false,
                message = "خطا در دریافت وضعیت تماس صوتی",
                error = ex.Message
            });
        }
    }

    /// <summary>
    /// Quick test with default values (for easy testing)
    /// </summary>
    /// <param name="phoneNumber">Phone number to send voice call to</param>
    /// <param name="text">Text to convert to speech (optional)</param>
    /// <returns>QuickSendWithTTS response</returns>
    [HttpPost("quick-test/{phoneNumber}")]
    public async Task<IActionResult> QuickTest(string phoneNumber, [FromQuery] string? text = null)
    {
        try
        {
            var testText = text ?? $"سلام. این یک تماس صوتی تست از سرویس GreenHome است. زمان تست: {DateTime.Now:yyyy/MM/dd HH:mm:ss}";
            
            logger.LogInformation("Quick test voice call to {PhoneNumber} with text: {Text}", 
                phoneNumber, testText);
            
            var request = new QuickSendWithTTSRequest
            {
                Number = phoneNumber,
                Text = testText,
                ServerID = 0 // Default
            };
            
            var result = await voiceCallService.QuickSendWithTTSAsync(request);
            
            if (result != null && result.IsSuccess)
            {
                logger.LogInformation("Quick test voice call sent successfully. QuickSendId: {QuickSendId}", 
                    result.QuickSendId);
            }
            
            return Ok(new
            {
                success = result?.IsSuccess ?? false,
                message = result?.IsSuccess == true 
                    ? "تماس صوتی تست با موفقیت ارسال شد" 
                    : $"خطا در ارسال تماس صوتی تست (کد خطا: {result?.ReturnValue})",
                data = result,
                quickSendId = result?.QuickSendId ?? 0,
                testInfo = new
                {
                    phoneNumber,
                    text = testText,
                    sentAt = DateTime.Now
                }
            });
        }
        catch (Exception ex)
        {
            logger.LogError(ex, "Error in quick test voice call");
            return StatusCode(500, new
            {
                success = false,
                message = "خطا در ارسال تماس صوتی تست",
                error = ex.Message
            });
        }
    }
}