using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json.Linq;
using ReZero.DependencyInjection;
using ReZero.SuperAPI;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using medical.transfomer.service;
using medical.transfomer.business;
using medical.transfomer.entity;
using SqlSugar;
using medical.insu.transfomer.Attributes;

namespace medical.insu.transfomer.Controllers
{
    [Api(200100, GroupName = "分组0")]

    public class MedicalInsuranceController:ControllerBase
    {
        [DI]
        public MedicalInsuranceTransactionService? MedicalInsuranceService { get; set; }

        [DI]
        public TransformerFactory? TransformerFactory { get; set; }

        [DI]
        public ISqlSugarClient? Db { get; set; }

        /// <summary>
        /// 执行医保交易
        /// </summary>
        /// <param name="value">包含交易参数的JSON对象</param>
        /// <returns>交易处理结果</returns>
        [ApiMethod("执行医保交易")]
        [HttpPost]
        [SkipAuth("医保交易接口，无需身份验证")]
        public async Task<object> ExecuteTransaction([FromBody] JObject value)
        {
            try
            {
                if (MedicalInsuranceService == null)
                {
                    return new { code = -1, msg = "医保交易服务未初始化" };
                }

                // 确保value不为null
                if (value == null)
                {
                    return new { code = -1, msg = "请求数据为空" };
                }

                string methodName = value["methodName"]?.ToString();
                if (string.IsNullOrEmpty(methodName))
                {
                    return new { code = -1, msg = "缺少methodName参数" };
                }

                // 获取数据部分
                JObject data = value["data"] as JObject ?? new JObject();
                
                // 使用医保交易服务处理
                return await MedicalInsuranceService.ExecuteTransaction(methodName, data);
            }
            catch (Exception ex)
            {
                return new { code = -1, msg = $"处理请求发生异常: {ex.Message}" };
            }
        }

        /// <summary>
        /// 获取可用的医保交易方法列表
        /// </summary>
        /// <returns>医保交易方法列表</returns>
        [HttpGet]
        public async Task<object> GetTransactionMethods()
        {
            try
            {
                if (Db == null)
                {
                    return new { code = -1, msg = "数据库服务未初始化" };
                }

                // 获取方法配置列表
                var methods = await Db.Queryable<STD_METHOD_CONFIG>()
                    .Select(m => new
                    {
                        id = m.METHOD_ID,
                        name = m.METHOD_NAME,
                        path = m.METHOD_VALUE,
                        saveInput = m.SAVE_INPUT,
                        saveOutput = m.SAVE_OUTPUT
                    })
                    .ToListAsync();

                return new { code = 0, msg = "获取成功", data = methods };
            }
            catch (Exception ex)
            {
                return new { code = -1, msg = $"获取医保交易方法列表异常: {ex.Message}" };
            }
        }

        /// <summary>
        /// 获取交易日志列表
        /// </summary>
        /// <param name="methodName">方法名称(可选)</param>
        /// <param name="status">状态(可选, 1:成功, 0:失败)</param>
        /// <param name="startTime">开始时间(可选)</param>
        /// <param name="endTime">结束时间(可选)</param>
        /// <param name="pageIndex">页索引(从1开始)</param>
        /// <param name="pageSize">页大小</param>
        /// <returns>交易日志列表</returns>
        [HttpGet]
        public async Task<object> GetTransactionLogs(
            string? methodName, 
            int? status, 
            DateTime? startTime, 
            DateTime? endTime, 
            int pageIndex = 1, 
            int pageSize = 20)
        {
            try
            {
                if (Db == null)
                {
                    return new { code = -1, msg = "数据库服务未初始化" };
                }

                // 构建查询条件
                var query = Db.Queryable<STD_TRANSACTION_LOG>();

                if (!string.IsNullOrEmpty(methodName))
                {
                    query = query.Where(l => l.METHOD_NAME == methodName);
                }

                if (status.HasValue)
                {
                    query = query.Where(l => l.STATUS == status.Value);
                }

                if (startTime.HasValue)
                {
                    query = query.Where(l => l.REQUEST_TIME >= startTime.Value);
                }

                if (endTime.HasValue)
                {
                    query = query.Where(l => l.REQUEST_TIME <= endTime.Value);
                }

                // 执行分页查询
                var result = await query
                    .OrderByDescending(l => l.REQUEST_TIME)
                    .Select(l => new
                    {
                        id = l.LOG_ID,
                        methodId = l.METHOD_ID,
                        methodName = l.METHOD_NAME,
                        requestTime = l.REQUEST_TIME,
                        responseTime = l.RESPONSE_TIME,
                        status = l.STATUS,
                        errorMessage = l.ERROR_MESSAGE,
                        elapsedTime = l.ELAPSED_TIME
                    })
                    .ToPageListAsync(pageIndex, pageSize);

                // 获取总记录数
                var total = await query.CountAsync();

                return new 
                { 
                    code = 0, 
                    msg = "获取成功", 
                    data = result,
                    total = total,
                    pageIndex = pageIndex,
                    pageSize = pageSize,
                    pageCount = (total + pageSize - 1) / pageSize
                };
            }
            catch (Exception ex)
            {
                return new { code = -1, msg = $"获取交易日志列表异常: {ex.Message}" };
            }
        }

        /// <summary>
        /// 获取交易日志详情
        /// </summary>
        /// <param name="logId">日志ID</param>
        /// <returns>交易日志详情</returns>
        [HttpGet]
        public async Task<object> GetTransactionLogDetail(decimal logId)
        {
            try
            {
                if (Db == null)
                {
                    return new { code = -1, msg = "数据库服务未初始化" };
                }

                // 获取日志详情
                var log = await Db.Queryable<STD_TRANSACTION_LOG>()
                    .FirstAsync(l => l.LOG_ID == logId);

                if (log == null)
                {
                    return new { code = -1, msg = $"未找到ID为{logId}的交易日志" };
                }

                return new 
                { 
                    code = 0, 
                    msg = "获取成功", 
                    data = new
                    {
                        id = log.LOG_ID,
                        methodId = log.METHOD_ID,
                        methodName = log.METHOD_NAME,
                        requestTime = log.REQUEST_TIME,
                        requestData = log.REQUEST_DATA,
                        responseTime = log.RESPONSE_TIME,
                        responseData = log.RESPONSE_DATA,
                        status = log.STATUS,
                        errorMessage = log.ERROR_MESSAGE,
                        elapsedTime = log.ELAPSED_TIME,
                        clientIp = log.CLIENT_IP,
                        userId = log.USER_ID
                    }
                };
            }
            catch (Exception ex)
            {
                return new { code = -1, msg = $"获取交易日志详情异常: {ex.Message}" };
            }
        }
    }
}