using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Haoliang.Models.System;

namespace Haoliang.Core.Services
{
    public interface IAlarmService
    {
        Task<Alarm> CreateAlarmAsync(Alarm alarm);
        Task<Alarm> UpdateAlarmAsync(int alarmId, Alarm alarm);
        Task<bool> DeleteAlarmAsync(int alarmId);
        Task<Alarm> GetAlarmByIdAsync(int alarmId);
        Task<IEnumerable<Alarm>> GetAllAlarmsAsync();
        Task<IEnumerable<Alarm>> GetAlarmsByDeviceAsync(int deviceId);
        Task<IEnumerable<Alarm>> GetAlarmsByTypeAsync(AlarmType type);
        Task<IEnumerable<Alarm>> GetActiveAlarmsAsync();
        Task<IEnumerable<Alarm>> GetAlarmsByDateRangeAsync(DateTime startDate, DateTime endDate);
        Task<bool> ResolveAlarmAsync(int alarmId, string resolutionNote);
        Task<bool> AcknowledgeAlarmAsync(int alarmId, string acknowledgeNote);
        Task<AlarmStatistics> GetAlarmStatisticsAsync(DateTime date);
        Task<IEnumerable<Alarm>> GetCriticalAlarmsAsync();
        Task<IEnumerable<Alarm>> GetDeviceAlarmsAsync(int deviceId, int days = 7);
    }

    public interface IAlarmRuleService
    {
        Task<AlarmRule> CreateAlarmRuleAsync(AlarmRule rule);
        Task<AlarmRule> UpdateAlarmRuleAsync(int ruleId, AlarmRule rule);
        Task<bool> DeleteAlarmRuleAsync(int ruleId);
        Task<AlarmRule> GetAlarmRuleByIdAsync(int ruleId);
        Task<IEnumerable<AlarmRule>> GetAllAlarmRulesAsync();
        Task<IEnumerable<AlarmRule>> GetActiveAlarmRulesAsync();
        Task<IEnumerable<AlarmRule>> GetRulesByDeviceAsync(int deviceId);
        Task<bool> EvaluateAlarmRuleAsync(AlarmRule rule, DeviceCurrentStatus status);
        Task<Alarm> GenerateAlarmFromRuleAsync(AlarmRule rule, DeviceCurrentStatus status);
        Task TestAlarmRuleAsync(int ruleId);
    }

    public interface IAlarmNotificationService
    {
        Task SendAlarmNotificationAsync(Alarm alarm);
        Task SendBulkAlarmNotificationsAsync(IEnumerable<Alarm> alarms);
        Task<bool> SendSmsNotificationAsync(string phoneNumber, string message);
        Task<bool> SendEmailNotificationAsync(string email, string subject, string message);
        Task<bool> SendWechatNotificationAsync(string openId, string message);
        Task<IEnumerable<AlarmNotification>> GetNotificationHistoryAsync(DateTime startDate, DateTime endDate);
        Task<bool> ConfigureNotificationChannelAsync(NotificationChannel channel);
        Task<IEnumerable<NotificationChannel>> GetAvailableChannelsAsync();
    }

    public class AlarmManager : IAlarmService
    {
        private readonly IAlarmRepository _alarmRepository;
        private readonly IAlarmRuleService _alarmRuleService;
        private readonly IAlarmNotificationService _notificationService;

        public AlarmManager(
            IAlarmRepository alarmRepository,
            IAlarmRuleService alarmRuleService,
            IAlarmNotificationService notificationService)
        {
            _alarmRepository = alarmRepository;
            _alarmRuleService = alarmRuleService;
            _notificationService = notificationService;
        }

        public async Task<Alarm> CreateAlarmAsync(Alarm alarm)
        {
            // 设置初始状态
            alarm.AlarmStatus = AlarmStatus.Active;
            alarm.CreateTime = DateTime.Now;
            alarm.UpdateTime = DateTime.Now;
            
            var createdAlarm = await _alarmRepository.AddAsync(alarm);
            
            // 发送告警通知
            await _notificationService.SendAlarmNotificationAsync(createdAlarm);
            
            return createdAlarm;
        }

        public async Task<Alarm> UpdateAlarmAsync(int alarmId, Alarm alarm)
        {
            var existingAlarm = await _alarmRepository.GetByIdAsync(alarmId);
            if (existingAlarm == null)
            {
                throw new KeyNotFoundException($"Alarm with ID {alarmId} not found");
            }

            // 更新字段
            alarm.AlarmId = alarmId;
            alarm.UpdateTime = DateTime.Now;
            
            var updatedAlarm = await _alarmRepository.UpdateAsync(alarm);
            return updatedAlarm;
        }

        public async Task<bool> DeleteAlarmAsync(int alarmId)
        {
            return await _alarmRepository.DeleteAsync(alarmId);
        }

        public async Task<Alarm> GetAlarmByIdAsync(int alarmId)
        {
            return await _alarmRepository.GetByIdAsync(alarmId);
        }

        public async Task<IEnumerable<Alarm>> GetAllAlarmsAsync()
        {
            return await _alarmRepository.GetAllAsync();
        }

        public async Task<IEnumerable<Alarm>> GetAlarmsByDeviceAsync(int deviceId)
        {
            return await _alarmRepository.GetByDeviceIdAsync(deviceId);
        }

        public async Task<IEnumerable<Alarm>> GetAlarmsByTypeAsync(AlarmType type)
        {
            return await _alarmRepository.GetByAlarmTypeAsync(type);
        }

        public async Task<IEnumerable<Alarm>> GetActiveAlarmsAsync()
        {
            return await _alarmRepository.GetByStatusAsync(AlarmStatus.Active);
        }

        public async Task<IEnumerable<Alarm>> GetAlarmsByDateRangeAsync(DateTime startDate, DateTime endDate)
        {
            return await _alarmRepository.GetByDateRangeAsync(startDate, endDate);
        }

        public async Task<bool> ResolveAlarmAsync(int alarmId, string resolutionNote)
        {
            var alarm = await _alarmRepository.GetByIdAsync(alarmId);
            if (alarm == null)
            {
                return false;
            }

            alarm.AlarmStatus = AlarmStatus.Resolved;
            alarm.ResolutionNote = resolutionNote;
            alarm.ResolvedTime = DateTime.Now;
            alarm.UpdateTime = DateTime.Now;

            return await _alarmRepository.UpdateAsync(alarm) != null;
        }

        public async Task<bool> AcknowledgeAlarmAsync(int alarmId, string acknowledgeNote)
        {
            var alarm = await _alarmRepository.GetByIdAsync(alarmId);
            if (alarm == null)
            {
                return false;
            }

            alarm.AlarmStatus = AlarmStatus.Acknowledged;
            alarm.AcknowledgeNote = acknowledgeNote;
            alarm.AcknowledgedTime = DateTime.Now;
            alarm.UpdateTime = DateTime.Now;

            return await _alarmRepository.UpdateAsync(alarm) != null;
        }

        public async Task<AlarmStatistics> GetAlarmStatisticsAsync(DateTime date)
        {
            return await _alarmRepository.GetAlarmStatisticsAsync(date);
        }

        public async Task<IEnumerable<Alarm>> GetCriticalAlarmsAsync()
        {
            return await _alarmRepository.GetBySeverityAsync(AlarmSeverity.Critical);
        }

        public async Task<IEnumerable<Alarm>> GetDeviceAlarmsAsync(int deviceId, int days = 7)
        {
            var startDate = DateTime.Now.AddDays(-days);
            var endDate = DateTime.Now;
            return await _alarmRepository.GetByDeviceAndDateRangeAsync(deviceId, startDate, endDate);
        }
    }
}