OA2023/OASystem/OASystem.Api/Controllers/AITestController.cs

using Microsoft.AspNetCore.Mvc;
using OASystem.API.OAMethodLib.DeepSeekAPI;
using Flurl.Http.Configuration;
using Microsoft.Extensions.Options;
using OASystem.API.OAMethodLib.DoubaoAPI;
using OASystem.API.OAMethodLib.Hotmail;
using OASystem.API.OAMethodLib.HunYuanAPI;
using OASystem.API.OAMethodLib.MicrosoftGraphMailbox;
using OASystem.API.OAMethodLib.QiYeWeChatAPI;
using OASystem.API.OAMethodLib.Quartz.Business;
using OASystem.Domain.ViewModels.QiYeWeChat;
using OASystem.RedisRepository;
using System.IdentityModel.Tokens.Jwt;
using System.Text.Json;
using static OASystem.API.OAMethodLib.Hotmail.HotmailService;

namespace OASystem.API.Controllers
{
    /// <summary>
    /// AI测试控制器
    /// </summary>
    [Route("api/[controller]")]
    public class AITestController : ControllerBase
    {
        private readonly IHunyuanService _hunyuanService;
        private readonly IDoubaoService _doubaoService;
        private readonly ILogger<AITestController> _logger;
        private readonly IConfiguration _config;
        private readonly IQiYeWeChatApiService _qiYeWeChatApiService;
        private readonly System.Net.Http.IHttpClientFactory _httpClientFactory;
        private readonly HotmailService _hotmailService;
        private readonly IMicrosoftGraphMailboxService _microsoftGraphMailboxService;
        private readonly IOptionsMonitor<MicrosoftGraphMailboxOptions> _microsoftGraphMailboxOptions;

        private readonly IDeepSeekService _deepSeekService;

        public AITestController(
            IHunyuanService hunyuanService,
            IDoubaoService doubaoService,
            ILogger<AITestController> logger,
            IQiYeWeChatApiService qiYeWeChatApiService,
            HotmailService hotmailService,
            System.Net.Http.IHttpClientFactory httpClientFactory,
            IConfiguration config,
            IMicrosoftGraphMailboxService microsoftGraphMailboxService,
            IOptionsMonitor<MicrosoftGraphMailboxOptions> microsoftGraphMailboxOptions,
            IDeepSeekService deepSeekService
            )
        {
            _hunyuanService = hunyuanService;
            _doubaoService = doubaoService;
            _logger = logger;
            _qiYeWeChatApiService = qiYeWeChatApiService;
            _hotmailService = hotmailService;
            _httpClientFactory = httpClientFactory;
            _config = config;
            _microsoftGraphMailboxService = microsoftGraphMailboxService;
            _deepSeekService = deepSeekService;
            _microsoftGraphMailboxOptions = microsoftGraphMailboxOptions;
        }

        #region 企业微信发送邮件测试

        /// <summary>
        /// 企业微信发送邮件测试
        /// </summary>
        [HttpPost("sendEmail")]
        public async Task<ActionResult<string>> SendEmail([FromForm] IFormFile[] feils)
        {
            try
            {
                var req = new EmailRequestDto()
                {
                    ToEmails = new List<string> { "johnny.yang@pan-american-intl.com" },
                    CcEmails = new List<string> { "Roy.lei@pan-american-intl.com" },
                    BccEmails = new List<string> { "Roy.lei@pan-american-intl.com" },
                    Subject = "测试邮件 - 来自企业微信API",
                    Body = "这是一封通过企业微信API发送的测试邮件，包含附件。",
                    Files = feils
                };
                var response = await _qiYeWeChatApiService.EmailSendAsync(req);
                return Ok(response);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "调用企业微信邮件API失败。");
                return StatusCode(500, new { Message = "调用企业微信邮件API失败，请检查配置或网络。", Detail = ex.Message });
            }
        }
        #endregion

        #region 豆包 AI

        /// <summary>
        /// 豆包基础对话
        /// </summary>
        [HttpPost("doubao-chat")]
        public async Task<ActionResult<string>> DoubaoChat(string question, bool isThinking = false)
        {
            try
            {
                var messages = new List<DouBaoChatMessage>
                {
                    new DouBaoChatMessage { Role = DouBaoRole.user, Content = question }
                };
                var options = new CompleteChatOptions
                {
                    ThinkingOptions = new thinkingOptions { IsThinking = isThinking }
                };
                var response = await _doubaoService.CompleteChatAsync(messages, options);
                return Ok(response);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "调用豆包API失败。");
                return StatusCode(500, new { Message = "调用豆包API失败", Detail = ex.Message });
            }
        }


        /// <summary>
        /// 豆包上传文件
        /// </summary>
        [HttpPost("doubao-upload")]
        public async Task<ActionResult<DoubaoFileResponse>> DoubaoUpload(IFormFile file, string purpose = "user_data")
        {
            if (file == null || file.Length == 0)
                return BadRequest("请选择要上传的文件");

            try
            {
                var stream = file.OpenReadStream();

                var existsFileExpand = new List<string> { "pdf", "docx" };

                if (!existsFileExpand.Contains(file.FileName.Split('.').Last().ToLower()))
                {
                    return BadRequest("请上传pdf、docx文件!不支持其他文件");
                }

                if (file.FileName.Split('.').Last().ToLower() == "docx")
                {
                    using var docxStream = file.OpenReadStream();
                    var pdfStream = DoubaoService.ConvertDocxStreamToPdfStream(docxStream);
                    stream = pdfStream;
                }

                var response = await _doubaoService.UploadFileAsync(stream, file.FileName, purpose);
                stream.Dispose();

                return Ok(response);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "豆包上传文件失败");
                return StatusCode(500, new { Message = "上传失败", Detail = ex.Message });
            }
        }

        /// <summary>
        /// 豆包获取文件列表
        /// </summary>
        [HttpGet("doubao-files")]
        public async Task<ActionResult<DoubaoFileListResponse>> DoubaoListFiles()
        {
            try
            {
                var response = await _doubaoService.ListFilesAsync();
                return Ok(response);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "获取豆包文件列表失败");
                return StatusCode(500, new { Message = "获取失败", Detail = ex.Message });
            }
        }

        /// <summary>
        /// 豆包删除文件
        /// </summary>
        [HttpDelete("doubao-file/{fileId}")]
        public async Task<ActionResult<bool>> DoubaoDeleteFile(string fileId)
        {
            try
            {
                var response = await _doubaoService.DeleteFileAsync(fileId);
                return Ok(response);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "删除豆包文件失败");
                return StatusCode(500, new { Message = "删除失败", Detail = ex.Message });
            }
        }

        /// <summary>
        /// 豆包多模态对话（支持文本+图片）
        /// </summary>
        /// <param name="request">表单请求参数</param>
        [HttpPost("doubao-multimodal-chat")]
        public async Task<ActionResult<string>> DoubaoMultimodalChat([FromForm] DoubaoMultimodalChatRequest request)
        {
            if (string.IsNullOrWhiteSpace(request.Question))
                return BadRequest("问题不能为空");

            try
            {
                var contentItems = new List<DoubaoMultimodalContentItem>
                {
                    new DoubaoMultimodalContentItem { Type = "text", Text = request.Question.Trim() }
                };

                if (!string.IsNullOrWhiteSpace(request.FileId))
                {
                    contentItems.Add(new DoubaoMultimodalContentItem
                    {
                        Type = "file",
                        FileId = request.FileId.Trim(),
                    });
                }

                if (request.Image != null && request.Image.Length > 0)
                {
                    using var ms = new MemoryStream();
                    await request.Image.CopyToAsync(ms);
                    var base64 = Convert.ToBase64String(ms.ToArray());
                    var mimeType = request.Image.ContentType ?? "image/jpeg";
                    var dataUrl = $"data:{mimeType};base64,{base64}";
                    contentItems.Add(new DoubaoMultimodalContentItem
                    {
                        Type = "image_url",
                        ImageUrl = new DoubaoMultimodalImageUrl { Url = dataUrl }
                    });
                }

                var messages = new List<DoubaoMultimodalChatMessage>
                {
                    new DoubaoMultimodalChatMessage
                    {
                        Role = "user",
                        Content = contentItems
                    }
                };

                var options = new CompleteMultimodalChatOptions
                {
                    ThinkingOptions = new DoubaoMultimodalThinkingOptions
                    {
                        IsThinking = request.IsThinking,
                        ReasoningEffort = "medium"
                    }
                };

                var response = await _doubaoService.CompleteMultimodalChatAsync(messages, options);
                return Ok(response ?? string.Empty);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "调用豆包多模态API失败。");
                return StatusCode(500, new { Message = "调用豆包多模态API失败", Detail = ex.Message });
            }
        }

        #endregion

        #region 混元 AI
        /// <summary>
        /// 基础对话示例
        /// </summary>
        [HttpPost("chat")]
        public async Task<ActionResult<string>> BasicChat(string question)
        {
            try
            {
                var response = await _hunyuanService.ChatCompletionsHunyuan_t1_latestAsync(question);
                return Ok(response);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "调用腾讯云混元API失败。");
                return StatusCode(500, new { Message = "调用腾讯云API失败，请检查配置或网络。", Detail = ex.Message });
            }
        }

        /// <summary>
        /// 模拟“根据文件提问”的API端点
        /// 注意：此示例中，文件内容通过请求体传入。
        /// 实际场景中，文件内容可能来自用户上传并解析（如PDF、TXT解析为文本）后的结果。
        /// </summary>
        [HttpPost("ask-with-file")]
        public async Task<ActionResult<string>> AskBasedOnFile([FromBody] AskWithFileRequest request)
        {
            if (string.IsNullOrEmpty(request.FileContent) || string.IsNullOrEmpty(request.Question))
            {
                return BadRequest(new { Message = "FileContent和Question字段不能为空。" });
            }

            try
            {
                var answer = await _hunyuanService.AskWithFileContextAsync(request.FileContent, request.Question, request.Model);
                return Ok(answer);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "处理基于文件的提问失败。");
                return StatusCode(500, new { Message = "处理请求失败。", Detail = ex.Message });
            }
        }

        /// <summary>
        /// 用于测试的GET端点，快速验证服务可用性（使用示例数据）
        /// </summary>
        [HttpGet("test-file-query")]
        public async Task<ActionResult<string>> TestFileQuery()
        {
            // 示例文件内容和问题
            var sampleFileContent = "在软件开发中，依赖注入(Dependency Injection)是一种设计模式，用于实现控制反转(Inversion of Control, IoC)。它允许在类外部创建依赖对象，并通过构造函数、属性或方法将其‘注入’到类中，从而降低类之间的耦合度。";
            var sampleQuestion = "依赖注入的主要目的是什么？";
            var model = "hunyuan-lite"; // 可使用 "hunyuan-pro" 等

            try
            {
                var answer = await _hunyuanService.AskWithFileContextAsync(sampleFileContent, sampleQuestion, model);
                return Ok($"测试成功。问题：'{sampleQuestion}'\n回答：{answer}");
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "测试文件提问失败。");
                return StatusCode(500, new { Message = "测试失败。", Detail = ex.Message });
            }
        }

        /// <summary>
        /// 用于“根据文件提问”的请求体
        /// </summary>
        public class AskWithFileRequest
        {
            public string FileContent { get; set; } = string.Empty;
            public string Question { get; set; } = string.Empty;
            public string Model { get; set; } = "hunyuan-lite";
        }

        /// <summary>
        /// 豆包多模态对话请求体（form-data）
        /// </summary>
        public class DoubaoMultimodalChatRequest
        {
            public string Question { get; set; } = string.Empty;
            public IFormFile? Image { get; set; }
            public bool IsThinking { get; set; } = false;
            public string FileId { get; set; } = string.Empty;
        }
        #endregion

        #region DeepSeek 测试

        /// <summary>
        /// DeepSeek 带上下文的流式对话测试。响应为 NDJSON：每行一条 JSON，phase 为 reasoning、content 或 error。
        /// system | user | assistant 角色。
        /// </summary>
        [HttpPost("deepseek-chat-stream-with-history")]
        public async Task<IActionResult> DeepSeekChatStreamWithHistory(
            [FromBody] DeepSeekChatStreamHistoryTestRequest request,
            CancellationToken cancellationToken = default)
        {
            if (request?.Messages == null || request.Messages.Count == 0)
                return BadRequest(new { message = "Messages 不能为空，且至少包含一条 user/system/assistant 消息。" });

            Response.ContentType = "application/x-ndjson; charset=utf-8";
            Response.Headers["Cache-Control"] = "no-cache";

            static string NdjsonLine(DeepSeekStreamChunk c) => JsonConvert.SerializeObject(new
            {
                phase = c.Phase == DeepSeekStreamPhase.Reasoning ? "reasoning" : "content",
                text = c.Text
            });

            try
            {
                await foreach (var chunk in _deepSeekService.ChatStreamWithHistoryAsync(
                    request.Messages,
                    string.IsNullOrWhiteSpace(request.Model) ? "deepseek-chat" : request.Model!.Trim(),
                    request.Temperature,
                    request.MaxTokens))
                {
                    cancellationToken.ThrowIfCancellationRequested();
                    await Response.WriteAsync(NdjsonLine(chunk) + "\n", cancellationToken);
                    await Response.Body.FlushAsync(cancellationToken);
                }

                await Response.WriteAsync(JsonConvert.SerializeObject(new { phase = "success", text = "结束" }) + "\n", cancellationToken);
                await Response.Body.FlushAsync(cancellationToken);
            }
            catch (OperationCanceledException)
            {
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "DeepSeek 带历史流式对话失败");
                await Response.WriteAsync(
                    JsonConvert.SerializeObject(new { phase = "error", text = ex.Message }) + "\n",
                    cancellationToken);
            }

            return new EmptyResult();
        }

        /// <summary>
        /// DeepSeek 流式对话（含多轮）请求体
        /// </summary>
        public class DeepSeekChatStreamHistoryTestRequest
        {
            public List<DeepSeekHistoryMessage> Messages { get; set; } = new();

            public string? Model { get; set; } = "deepseek-chat";

            public float Temperature { get; set; } = 0.7f;

            public int MaxTokens { get; set; } = 4000;
        }

        #endregion

        /// <summary>
        /// hotmail 发送邮件
        /// </summary>
        [HttpPost("hotmailSeed")]
        public async Task<ActionResult<string>> HotmailSeed()
        {
            await _hotmailService.SendMailAsync(
                //"Roy.Lei.Atom@hotmail.com",
                "925554512@qq.com",
                //"johnny.yang@pan-american-intl.com",
                new HotmailService.MailDto()
                {
                    Subject = "系统提醒",
                    Content = "<p>这是一封Homail 发送的测试邮件</p>",
                    //To = "Roy.lei@pan-american-intl.com"
                    To = "johnny.yang@pan-american-intl.com"
                });

            return StatusCode(200, new { Message = "操作成功。" });
        }

        /// <summary>
        /// hotmail 发送邮件
        /// </summary>
        [HttpPost("HotmailMerged")]
        public async Task<ActionResult<string>> HotmailMerged()
        {

            // 1. 获取当前北京时间 (CST)
            var cstZone = CommonFun.GetCstZone();
            var nowInCst = TimeZoneInfo.ConvertTimeFromUtc(DateTime.UtcNow, cstZone);

            // 2. 构造昨天的北京时间范围：00:00:00 到 23:59:59
            var yesterdayStart = nowInCst.Date.AddDays(-1); // 昨天的 00:00:00
            var yesterdayEnd = yesterdayStart.AddDays(1).AddTicks(-1); // 昨天的 23:59:59


            var res = await _hotmailService.GetMergedMessagesAsync(
                new List<string>() { "925554512@qq.com" },
                yesterdayStart,
                yesterdayEnd
                );

            return StatusCode(200, res);
        }

        /// <summary>
        /// hotmail 定时发送邮件 汇总 测试
        /// </summary>
        [HttpPost("hotmailSummarySeedQW")]
        public async Task<ActionResult<string>> HotmailSummary()
        {
            ProcessAndNotifySummary.ProcessAndNotifySummaryAsync();

            return StatusCode(200, "发送成功");
        }

        #region Microsoft Graph 邮箱测试（仅访问令牌）

        private const string GraphAccessTokenHeader = "X-Graph-Access-Token";

        /// <summary>
        /// 优先级：请求头 X-Graph-Access-Token → 查询 graphAccessToken → bodyToken（发信）。
        /// </summary>
        private string? ResolveGraphAccessToken(string? queryToken = null, string? bodyToken = null)
        {
            var header = Request.Headers[GraphAccessTokenHeader].FirstOrDefault();
            if (!string.IsNullOrWhiteSpace(header))
                return header.Trim();
            if (!string.IsNullOrWhiteSpace(queryToken))
                return queryToken.Trim();
            if (!string.IsNullOrWhiteSpace(bodyToken))
                return bodyToken.Trim();
            return null;
        }

        /// <summary>
        /// 查询当前用户 GET /v1.0/me。必须提供 Graph 访问令牌。
        /// </summary>
        [HttpGet("graph-mail/me")]
        public async Task<IActionResult> GraphMailMe(
            [FromQuery] string? graphAccessToken = null,
            CancellationToken cancellationToken = default)
        {
            var bearer = ResolveGraphAccessToken(graphAccessToken);
            if (string.IsNullOrWhiteSpace(bearer))
                return Unauthorized(new { message = "必须提供 Microsoft Graph 访问令牌：请求头 X-Graph-Access-Token 或查询参数 graphAccessToken" });

            try
            {
                var json = await _microsoftGraphMailboxService.GetMeRawJsonAsync(bearer, cancellationToken);
                if (string.IsNullOrEmpty(json))
                    return StatusCode(502, new { message = "Graph 返回空正文" });

                return Content(json, "application/json");
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Graph Mail /me 失败");
                return StatusCode(500, new { message = ex.Message });
            }
        }

        /// <summary>
        /// 查询收件箱。必须提供 Graph 访问令牌（需 Mail.Read）。默认 sinceUtc 为 UTC 近 24 小时。
        /// </summary>
        /// <param name="sinceUtc">起始时间（UTC），ISO8601</param>
        /// <param name="graphAccessToken">或使用请求头 X-Graph-Access-Token</param>
        /// <param name="cancellationToken">取消标记</param>
        [HttpGet("graph-mail/inbox")]
        public async Task<IActionResult> GraphMailInbox(
            [FromQuery] DateTime? sinceUtc = null,
            [FromQuery] string? graphAccessToken = null,
            CancellationToken cancellationToken = default)
        {
            var bearer = ResolveGraphAccessToken(graphAccessToken);
            if (string.IsNullOrWhiteSpace(bearer))
                return Unauthorized(new { message = "必须提供 Microsoft Graph 访问令牌：请求头 X-Graph-Access-Token 或查询参数 graphAccessToken" });

            var since = sinceUtc ?? DateTime.UtcNow.AddHours(-24);

            try
            {
                var json = await _microsoftGraphMailboxService.GetInboxMessagesJsonSinceAsync(since, bearer, cancellationToken);
                if (string.IsNullOrEmpty(json))
                    return StatusCode(502, new { message = "Graph 返回空正文" });

                return Content(json, "application/json");
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Graph Mail inbox 失败");
                return StatusCode(500, new { message = ex.Message });
            }
        }

        /// <summary>
        /// Graph sendMail 纯文本。必须提供令牌（需 Mail.Send）：头 / 查询 / Body.graphAccessToken。
        /// </summary>
        [HttpPost("graph-mail/send")]
        public async Task<IActionResult> GraphMailSend(
            [FromBody] GraphMailSendTestRequest request,
            [FromQuery] string? graphAccessToken = null,
            CancellationToken cancellationToken = default)
        {
            if (request == null || string.IsNullOrWhiteSpace(request.ToEmail))
                return BadRequest(new { message = "ToEmail 不能为空" });

            var bearer = ResolveGraphAccessToken(graphAccessToken, request.GraphAccessToken);
            if (string.IsNullOrWhiteSpace(bearer))
                return Unauthorized(new { message = "必须提供 Microsoft Graph 访问令牌：X-Graph-Access-Token、?graphAccessToken 或 Body.graphAccessToken" });

            var subject = string.IsNullOrWhiteSpace(request.Subject)
                ? $"OASystem Graph 测试邮件 {DateTime.Now:yyyy-MM-dd HH:mm:ss}"
                : request.Subject!;

            var body = request.Body ?? string.Empty;

            try
            {
                await _microsoftGraphMailboxService.SendMailAsync(request.ToEmail.Trim(), subject, body, bearer, cancellationToken);
                return Ok(new { ok = true, message = "sendMail 已提交", to = request.ToEmail.Trim(), subject });
            }
            catch (HttpRequestException ex)
            {
                return StatusCode(502, new { message = "Graph HTTP 错误", detail = ex.Message });
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Graph Mail send 失败");
                return StatusCode(500, new { message = ex.Message });
            }
        }

        public class EmailAuthRedisCache
        {
            public string? AccessToken { get; set; }
            public string? HomeAccountId { get; set; }
            public string? UserTokenCacheBase64 { get; set; }
            public string? ClientId { get; set; }
        }

        /// <summary>
        /// 从 Redis 读取 MSAL 缓存与 HomeAccountId，静默刷新 Graph access_token。
        /// </summary>
        [HttpGet("graph-mail/refresh-token")]
        public async Task<IActionResult> RefreshAccessToken([FromQuery] string? redisKey = null)
        {
            var key = string.IsNullOrWhiteSpace(redisKey) ? "Email:AuthCache:345" : redisKey.Trim();

            var redis = RedisFactory.CreateRedisRepository();
            var json = await redis.StringGetRawAsync(key);
            if (string.IsNullOrWhiteSpace(json))
            {
                return BadRequest(new { message = $"Redis 键 {key} 不存在或为空" });
            }

            EmailAuthRedisCache? cacheEntry;
            try
            {
                cacheEntry = JsonConvert.DeserializeObject<EmailAuthRedisCache>(json);
            }
            catch (System.Text.Json.JsonException ex)
            {
                _logger.LogWarning(ex, "Redis 键 {Key} 内容不是合法 JSON（应用 StringGetRawAsync + JSON，勿用 StringGetAsync<T>，后者为 BinaryFormatter）", key);
                return BadRequest(new { message = "Redis 值为 JSON 文本时须用 StringGetRawAsync 再反序列化；StringGetAsync<T> 仅适用于 BinaryFormatter 写入的数据", detail = ex.Message });
            }

            if (cacheEntry == null
                || string.IsNullOrWhiteSpace(cacheEntry.UserTokenCacheBase64)
                || string.IsNullOrWhiteSpace(cacheEntry.HomeAccountId))
            {
                return BadRequest(new { message = "JSON 中缺少 UserTokenCacheBase64 或 HomeAccountId" });
            }

            var accessToken = await _microsoftGraphMailboxService.RefreshAccessTokenAsync(
                cacheEntry.ClientId,
                "common",
                new[] { "Mail.Read", "User.Read", "Mail.Send" },
                cacheEntry.UserTokenCacheBase64,
                cacheEntry.HomeAccountId);

            return Ok(new { accessToken });
        }

        /// <summary>
        /// Graph 发信测试请求体
        /// </summary>
        public class GraphMailSendTestRequest
        {
            public string ToEmail { get; set; } = string.Empty;
            public string? Subject { get; set; }
            public string? Body { get; set; }
            /// <summary>Microsoft Graph 访问令牌（也可用请求头 X-Graph-Access-Token）</summary>
            public string? GraphAccessToken { get; set; }
        }

        #endregion

    }
}