using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Haoliang.Models.DataCollection;
using Haoliang.Data.Repositories;

namespace Haoliang.Data.Repositories
{
    public interface ICollectionTaskRepository : IRepository<CollectionTask>
    {
        Task<IEnumerable<CollectionTask>> GetPendingTasksAsync();
        Task<IEnumerable<CollectionTask>> GetFailedTasksAsync();
        Task<CollectionTask> GetByDeviceAsync(int deviceId);
        Task<bool> MarkTaskCompletedAsync(int taskId, bool isSuccess, string result);
        Task<IEnumerable<CollectionTask>> GetTasksByDateAsync(DateTime date);
        Task<IEnumerable<CollectionTask>> GetRunningTasksAsync();
        Task<CollectionTaskStatistics> GetTaskStatisticsAsync(DateTime date);
        Task<bool> HasPendingTasksAsync(int deviceId);
        Task<IEnumerable<CollectionTask>> GetTasksByStatusAsync(string status);
    }

    public class CollectionTaskRepository : Repository<CollectionTask>, ICollectionTaskRepository
    {
        private readonly CNCDbContext _context;

        public CollectionTaskRepository(CNCDbContext context) : base(context)
        {
            _context = context;
        }

        public async Task<IEnumerable<CollectionTask>> GetPendingTasksAsync()
        {
            return await _context.CollectionTasks
                .Where(t => t.Status == "Pending")
                .OrderBy(t => t.ScheduledTime)
                .ToListAsync();
        }

        public async Task<IEnumerable<CollectionTask>> GetFailedTasksAsync()
        {
            return await _context.CollectionTasks
                .Where(t => t.Status == "Failed")
                .OrderByDescending(t => t.CreatedAt)
                .ToListAsync();
        }

        public async Task<CollectionTask> GetByDeviceAsync(int deviceId)
        {
            return await _context.CollectionTasks
                .Where(t => t.DeviceId == deviceId)
                .OrderByDescending(t => t.CreatedAt)
                .FirstOrDefaultAsync();
        }

        public async Task<bool> MarkTaskCompletedAsync(int taskId, bool isSuccess, string result)
        {
            var task = await GetByIdAsync(taskId);
            if (task == null)
            {
                return false;
            }

            task.Status = isSuccess ? "Completed" : "Failed";
            task.Result = result;
            task.CompletedAt = DateTime.Now;

            await SaveAsync();
            return true;
        }

        public async Task<IEnumerable<CollectionTask>> GetTasksByDateAsync(DateTime date)
        {
            var startOfDay = date.Date;
            var endOfDay = startOfDay.AddDays(1);

            return await _context.CollectionTasks
                .Where(t => t.CreatedAt >= startOfDay && 
                           t.CreatedAt < endOfDay)
                .OrderBy(t => t.ScheduledTime)
                .ToListAsync();
        }

        public async Task<IEnumerable<CollectionTask>> GetRunningTasksAsync()
        {
            return await _context.CollectionTasks
                .Where(t => t.Status == "Running")
                .OrderBy(t => t.ScheduledTime)
                .ToListAsync();
        }

        public async Task<CollectionTaskStatistics> GetTaskStatisticsAsync(DateTime date)
        {
            var startOfDay = date.Date;
            var endOfDay = startOfDay.AddDays(1);

            var tasks = await _context.CollectionTasks
                .Where(t => t.CreatedAt >= startOfDay && 
                           t.CreatedAt < endOfDay)
                .ToListAsync();

            var stats = new CollectionTaskStatistics
            {
                Date = date,
                TotalTasks = tasks.Count,
                PendingTasks = tasks.Count(t => t.Status == "Pending"),
                RunningTasks = tasks.Count(t => t.Status == "Running"),
                CompletedTasks = tasks.Count(t => t.Status == "Completed"),
                FailedTasks = tasks.Count(t => t.Status == "Failed"),
                DeviceTasks = tasks.GroupBy(t => t.DeviceId)
                    .ToDictionary(g => g.Key, g => g.Count())
            };

            return stats;
        }

        public async Task<bool> HasPendingTasksAsync(int deviceId)
        {
            return await _context.CollectionTasks
                .AnyAsync(t => t.DeviceId == deviceId && t.Status == "Pending");
        }

        public async Task<IEnumerable<CollectionTask>> GetTasksByStatusAsync(string status)
        {
            return await _context.CollectionTasks
                .Where(t => t.Status == status)
                .OrderBy(t => t.ScheduledTime)
                .ToListAsync();
        }
    }
}