using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Quartz;

namespace WebApi.Controllers;

/// <summary>
/// 定时任务管理控制器
/// </summary>
[ApiController]
[Route("api/[controller]")]
public class JobController(
    ISchedulerFactory schedulerFactory,
    ILogger<JobController> logger) : ControllerBase
{
    /// <summary>
    /// 手动触发邮件同步任务
    /// </summary>
    [HttpPost("sync-email")]
    [Authorize]
    public async Task<IActionResult> TriggerEmailSync()
    {
        try
        {
            var scheduler = await schedulerFactory.GetScheduler();
            var jobKey = new JobKey("EmailSyncJob");
            
            // 立即触发任务
            await scheduler.TriggerJob(jobKey);
            
            logger.LogInformation("手动触发邮件同步任务成功");
            return Ok(new { message = "邮件同步任务已触发" });
        }
        catch (Exception ex)
        {
            logger.LogError(ex, "触发邮件同步任务失败");
            return StatusCode(500, new { message = "触发任务失败", error = ex.Message });
        }
    }

    /// <summary>
    /// 手动触发周期性账单任务
    /// </summary>
    [HttpPost("periodic-bill")]
    [Authorize]
    public async Task<IActionResult> TriggerPeriodicBill()
    {
        try
        {
            var scheduler = await schedulerFactory.GetScheduler();
            var jobKey = new JobKey("PeriodicBillJob");
            
            // 立即触发任务
            await scheduler.TriggerJob(jobKey);
            
            logger.LogInformation("手动触发周期性账单任务成功");
            return Ok(new { message = "周期性账单任务已触发" });
        }
        catch (Exception ex)
        {
            logger.LogError(ex, "触发周期性账单任务失败");
            return StatusCode(500, new { message = "触发任务失败", error = ex.Message });
        }
    }

    /// <summary>
    /// 获取所有任务的状态
    /// </summary>
    [HttpGet("status")]
    [Authorize]
    public async Task<IActionResult> GetJobStatus()
    {
        try
        {
            var scheduler = await schedulerFactory.GetScheduler();
            var jobGroups = await scheduler.GetJobGroupNames();
            var jobStatuses = new List<object>();

            foreach (var group in jobGroups)
            {
                var jobKeys = await scheduler.GetJobKeys(Quartz.Impl.Matchers.GroupMatcher<JobKey>.GroupEquals(group));
                
                foreach (var jobKey in jobKeys)
                {
                    var triggers = await scheduler.GetTriggersOfJob(jobKey);
                    var jobDetail = await scheduler.GetJobDetail(jobKey);
                    
                    foreach (var trigger in triggers)
                    {
                        var triggerState = await scheduler.GetTriggerState(trigger.Key);
                        var nextFireTime = trigger.GetNextFireTimeUtc();
                        var previousFireTime = trigger.GetPreviousFireTimeUtc();
                        
                        jobStatuses.Add(new
                        {
                            jobName = jobKey.Name,
                            jobGroup = jobKey.Group,
                            triggerName = trigger.Key.Name,
                            triggerState = triggerState.ToString(),
                            nextFireTime = nextFireTime?.LocalDateTime,
                            previousFireTime = previousFireTime?.LocalDateTime,
                            description = trigger.Description,
                            jobType = jobDetail?.JobType.Name
                        });
                    }
                }
            }

            return Ok(jobStatuses);
        }
        catch (Exception ex)
        {
            logger.LogError(ex, "获取任务状态失败");
            return StatusCode(500, new { message = "获取任务状态失败", error = ex.Message });
        }
    }

    /// <summary>
    /// 暂停指定任务
    /// </summary>
    [HttpPost("pause/{jobName}")]
    [Authorize]
    public async Task<IActionResult> PauseJob(string jobName)
    {
        try
        {
            var scheduler = await schedulerFactory.GetScheduler();
            var jobKey = new JobKey(jobName);
            
            if (!await scheduler.CheckExists(jobKey))
            {
                return NotFound(new { message = $"任务 {jobName} 不存在" });
            }
            
            await scheduler.PauseJob(jobKey);
            logger.LogInformation("任务 {JobName} 已暂停", jobName);
            
            return Ok(new { message = $"任务 {jobName} 已暂停" });
        }
        catch (Exception ex)
        {
            logger.LogError(ex, "暂停任务 {JobName} 失败", jobName);
            return StatusCode(500, new { message = "暂停任务失败", error = ex.Message });
        }
    }

    /// <summary>
    /// 恢复指定任务
    /// </summary>
    [HttpPost("resume/{jobName}")]
    [Authorize]
    public async Task<IActionResult> ResumeJob(string jobName)
    {
        try
        {
            var scheduler = await schedulerFactory.GetScheduler();
            var jobKey = new JobKey(jobName);
            
            if (!await scheduler.CheckExists(jobKey))
            {
                return NotFound(new { message = $"任务 {jobName} 不存在" });
            }
            
            await scheduler.ResumeJob(jobKey);
            logger.LogInformation("任务 {JobName} 已恢复", jobName);
            
            return Ok(new { message = $"任务 {jobName} 已恢复" });
        }
        catch (Exception ex)
        {
            logger.LogError(ex, "恢复任务 {JobName} 失败", jobName);
            return StatusCode(500, new { message = "恢复任务失败", error = ex.Message });
        }
    }
}