using System.Text.Json;
using AutoMapper;
using GreenHome.Application;
using GreenHome.Application.Dtos.Admin;
using GreenHome.Domain;
using GreenHome.Infrastructure.Data;
using GreenHome.Infrastructure.Services.Usage;
using GreenHome.Sms.Ippanel;
using GreenHome.VoiceCall.Avanak;
using Microsoft.AspNetCore.Hosting;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;

namespace GreenHome.Infrastructure.Services.Admin;

public sealed class AdminService : IAdminService
{
    private readonly GreenHomeDbContext _dbContext;
    private readonly IMapper _mapper;
    private readonly ISmsService _smsService;
    private readonly IVoiceCallService _voiceCallService;
    private readonly UsageTracker _usageTracker;
    private readonly IWebHostEnvironment _environment;
    private readonly IDeviceService _deviceService;
    private readonly IDeviceSettingsService _deviceSettingsService;
    private readonly int _onlineWindowMinutes;

    public AdminService(
        GreenHomeDbContext dbContext,
        IMapper mapper,
        IConfiguration configuration,
        ISmsService smsService,
        IVoiceCallService voiceCallService,
        UsageTracker usageTracker,
        IWebHostEnvironment environment,
        IDeviceService deviceService,
        IDeviceSettingsService deviceSettingsService)
    {
        _dbContext = dbContext;
        _mapper = mapper;
        _smsService = smsService;
        _voiceCallService = voiceCallService;
        _usageTracker = usageTracker;
        _environment = environment;
        _deviceService = deviceService;
        _deviceSettingsService = deviceSettingsService;
        _onlineWindowMinutes = configuration.GetValue("Admin:OnlineWindowMinutes", 15);
    }

    // ==================== Dashboard ====================

    public async Task<AdminDashboardDto> GetDashboardAsync(CancellationToken cancellationToken)
    {
        var now = DateTime.UtcNow;
        var onlineCutoff = now.AddMinutes(-_onlineWindowMinutes);
        var dayAgo = now.AddDays(-1);
        var weekAgo = now.AddDays(-7);

        var totalUsers = await _dbContext.Users.CountAsync(cancellationToken);
        var totalDevices = await _dbContext.Devices.CountAsync(cancellationToken);
        var onlineDevices = await _dbContext.TelemetryRecords
            .Where(t => t.ServerTimestampUtc >= onlineCutoff)
            .Select(t => t.DeviceId)
            .Distinct()
            .CountAsync(cancellationToken);
        var alertsLast24h = await _dbContext.AlertLogs
            .CountAsync(a => a.SentAt >= dayAgo, cancellationToken);
        var aiQueriesLast7Days = await _dbContext.AIQueries
            .CountAsync(q => q.CreatedAt >= weekAgo, cancellationToken);

        // ponytail: SMS count + sparkline come from UsageCounters (single source of truth,
        // matches the usage page); AlertLogs is no longer consulted here.
        var weekStart = DateOnly.FromDateTime(now.Date.AddDays(-6));
        var smsCounters = await _dbContext.UsageCounters
            .AsNoTracking()
            .Where(u => u.Date >= weekStart)
            .GroupBy(u => u.Date)
            .Select(g => new { Date = g.Key, Count = g.Sum(x => x.SmsCount) })
            .ToListAsync(cancellationToken);

        var smsLast7Days = smsCounters.Sum(x => x.Count);

        var daily = new List<UsageDayDto>(7);
        for (var i = 6; i >= 0; i--)
        {
            var day = DateOnly.FromDateTime(now.Date.AddDays(-i));
            daily.Add(new UsageDayDto
            {
                Date = day.ToDateTime(new TimeOnly(0, 0)),
                SmsCount = smsCounters.FirstOrDefault(x => x.Date == day)?.Count ?? 0
            });
        }

        return new AdminDashboardDto
        {
            TotalUsers = totalUsers,
            TotalDevices = totalDevices,
            OnlineDevices = onlineDevices,
            OfflineDevices = totalDevices - onlineDevices,
            AlertsLast24h = alertsLast24h,
            SmsLast7Days = smsLast7Days,
            AiQueriesLast7Days = aiQueriesLast7Days,
            SmsDailyLast7Days = daily
        };
    }

    // ==================== Users ====================

    public async Task<PagedResult<AdminUserListItemDto>> GetUsersAsync(AdminUserFilter filter, CancellationToken cancellationToken)
    {
        if (filter.Page <= 0) filter.Page = 1;
        if (filter.PageSize <= 0) filter.PageSize = 20;

        IQueryable<Domain.User> query = _dbContext.Users.AsNoTracking();

        if (!string.IsNullOrWhiteSpace(filter.Search))
        {
            // normalize Persian/Arabic digits so «۰۹...» finds the stored «09...»
            var search = NormalizeDigits(filter.Search.Trim());
            query = query.Where(u => u.Name.Contains(search) || u.Family.Contains(search) || u.Mobile.Contains(search));
        }

        var totalCount = await query.CountAsync(cancellationToken);

        var items = await query
            .OrderByDescending(u => u.LastLoginAt)
            .ThenByDescending(u => u.Id)
            .Skip((filter.Page - 1) * filter.PageSize)
            .Take(filter.PageSize)
            .ToListAsync(cancellationToken);

        var ids = items.Select(u => u.Id).ToList();
        var deviceCounts = await _dbContext.Devices
            .Where(d => ids.Contains(d.UserId))
            .GroupBy(d => d.UserId)
            .Select(g => new { UserId = g.Key, Count = g.Count() })
            .ToDictionaryAsync(x => x.UserId, x => x.Count, cancellationToken);

        return new PagedResult<AdminUserListItemDto>
        {
            Items = items.Select(u => new AdminUserListItemDto
            {
                Id = u.Id,
                Name = u.Name,
                Family = u.Family,
                Mobile = u.Mobile,
                Role = u.Role,
                IsDisabled = u.IsDisabled,
                DeviceCount = deviceCounts.TryGetValue(u.Id, out var c) ? c : 0,
                LastLoginAt = u.LastLoginAt,
                CreatedAt = u.CreatedAt
            }).ToList(),
            TotalCount = totalCount,
            Page = filter.Page,
            PageSize = filter.PageSize
        };
    }

    public async Task<AdminUserDetailDto?> GetUserAsync(int id, CancellationToken cancellationToken)
    {
        var user = await _dbContext.Users.AsNoTracking()
            .FirstOrDefaultAsync(u => u.Id == id, cancellationToken);
        if (user == null) return null;

        var deviceIds = await _dbContext.Devices
            .Where(d => d.UserId == id)
            .Select(d => d.Id)
            .ToListAsync(cancellationToken);

        var (latestMap, _) = await GetDeviceMetaAsync(deviceIds, cancellationToken);

        return new AdminUserDetailDto
        {
            Id = user.Id,
            Name = user.Name,
            Family = user.Family,
            Mobile = user.Mobile,
            Role = user.Role,
            IsDisabled = user.IsDisabled,
            CreatedAt = user.CreatedAt,
            LastLoginAt = user.LastLoginAt,
            Devices = await BuildDeviceListAsync(deviceIds, latestMap, cancellationToken)
        };
    }

    public async Task<UserMutationOutcome> SetUserRoleAsync(int id, UserRole role, int currentAdminId, CancellationToken cancellationToken)
    {
        var user = await _dbContext.Users.FirstOrDefaultAsync(u => u.Id == id, cancellationToken);
        if (user == null) return UserMutationOutcome.NotFound;

        if (id == currentAdminId) return UserMutationOutcome.ConflictSelf;

        // don't allow demoting/removing the last active admin
        if (user.Role == UserRole.Admin && role != UserRole.Admin)
        {
            var activeAdmins = await _dbContext.Users
                .CountAsync(u => u.Role == UserRole.Admin && !u.IsDisabled, cancellationToken);
            if (activeAdmins <= 1) return UserMutationOutcome.ConflictLastAdmin;
        }

        user.Role = role;
        AddAuditLog(currentAdminId, "User.SetRole", id.ToString(),
            JsonSerializer.Serialize(new { role = role.ToString(), roleId = (int)role }));
        await _dbContext.SaveChangesAsync(cancellationToken);
        return UserMutationOutcome.Ok;
    }

    public async Task<UserMutationOutcome> SetUserStatusAsync(int id, bool isEnabled, int currentAdminId, CancellationToken cancellationToken)
    {
        var user = await _dbContext.Users.FirstOrDefaultAsync(u => u.Id == id, cancellationToken);
        if (user == null) return UserMutationOutcome.NotFound;

        if (id == currentAdminId) return UserMutationOutcome.ConflictSelf;

        // disabling the last active admin would lock the panel out
        if (!isEnabled && user.Role == UserRole.Admin && !user.IsDisabled)
        {
            var activeAdmins = await _dbContext.Users
                .CountAsync(u => u.Role == UserRole.Admin && !u.IsDisabled, cancellationToken);
            if (activeAdmins <= 1) return UserMutationOutcome.ConflictLastAdmin;
        }

        user.IsDisabled = !isEnabled;
        AddAuditLog(currentAdminId, isEnabled ? "User.Enable" : "User.Disable", id.ToString());
        await _dbContext.SaveChangesAsync(cancellationToken);
        return UserMutationOutcome.Ok;
    }

    // ==================== Devices ====================

    public async Task<PagedResult<AdminDeviceListItemDto>> GetDevicesAsync(AdminDeviceFilter filter, CancellationToken cancellationToken)
    {
        if (filter.Page <= 0) filter.Page = 1;
        if (filter.PageSize <= 0) filter.PageSize = 20;

        IQueryable<Domain.Device> query = _dbContext.Devices.AsNoTracking().Include(d => d.User);

        if (!string.IsNullOrWhiteSpace(filter.Search))
        {
            var search = NormalizeDigits(filter.Search.Trim());
            query = query.Where(d =>
                d.DeviceName.Contains(search) ||
                d.Location.Contains(search) ||
                d.User.Name.Contains(search) ||
                d.User.Family.Contains(search) ||
                d.User.Mobile.Contains(search));
        }

        var totalCount = await query.CountAsync(cancellationToken);

        var page = await query
            .OrderBy(d => d.DeviceName)
            .Skip((filter.Page - 1) * filter.PageSize)
            .Take(filter.PageSize)
            .ToListAsync(cancellationToken);

        var deviceIds = page.Select(d => d.Id).ToList();
        var (latestMap, _) = await GetDeviceMetaAsync(deviceIds, cancellationToken);

        var items = page.Select(d => ToDeviceListItem(d, latestMap)).ToList();

        return new PagedResult<AdminDeviceListItemDto>
        {
            Items = items,
            TotalCount = totalCount,
            Page = filter.Page,
            PageSize = filter.PageSize
        };
    }

    public async Task<AdminDeviceDetailDto?> GetDeviceAsync(int id, CancellationToken cancellationToken)
    {
        var device = await _dbContext.Devices.AsNoTracking()
            .Include(d => d.User)
            .FirstOrDefaultAsync(d => d.Id == id, cancellationToken);
        if (device == null) return null;

        var settings = await _dbContext.DeviceSettings
            .AsNoTracking()
            .FirstOrDefaultAsync(s => s.DeviceId == id, cancellationToken);

        var memberCount = await _dbContext.DeviceUsers
            .CountAsync(du => du.DeviceId == id, cancellationToken);

        var lastTelemetry = await _dbContext.TelemetryRecords
            .AsNoTracking()
            .Where(t => t.DeviceId == id)
            .OrderByDescending(t => t.ServerTimestampUtc)
            .Take(10)
            .ToListAsync(cancellationToken);

        var (latestMap, _) = await GetDeviceMetaAsync([id], cancellationToken);

        return new AdminDeviceDetailDto
        {
            Id = device.Id,
            DeviceName = device.DeviceName,
            Location = device.Location,
            OwnerName = device.User.Name,
            OwnerFamily = device.User.Family,
            OwnerMobile = device.User.Mobile,
            IsOnline = latestMap.TryGetValue(id, out var last) && last.ServerTimestampUtc >= DateTime.UtcNow.AddMinutes(-_onlineWindowMinutes),
            MemberCount = memberCount,
            ProductType = settings?.ProductType,
            Province = settings?.Province,
            City = settings?.City,
            DevicePhoneNumber = settings?.DevicePhoneNumber,
            UploadIntervalMin = settings?.UploadIntervalMin,
            RelayCount = settings?.RelayCount,
            NeshanLocation = string.IsNullOrWhiteSpace(device.NeshanLocation) ? null : device.NeshanLocation,
            Latitude = settings?.Latitude,
            Longitude = settings?.Longitude,
            MinimumSmsIntervalMinutes = settings?.MinimumSmsIntervalMinutes,
            MinimumCallIntervalMinutes = settings?.MinimumCallIntervalMinutes,
            AreaSquareMeters = settings?.AreaSquareMeters,
            SimCardType = settings?.SimCardType,
            SmsRecievers = settings?.SmsRecievers,
            LastTelemetry = _mapper.Map<IReadOnlyList<TelemetryDto>>(lastTelemetry)
        };
    }

    // ==================== Devices: create / settings / members ====================

    public async Task<AdminDeviceCreateResult> CreateDeviceAsync(AdminDeviceCreateRequest request, int currentAdminId, CancellationToken cancellationToken)
    {
        var deviceName = request.DeviceName?.Trim() ?? string.Empty;
        if (deviceName.Length == 0 || deviceName.Length > 10)
            return new AdminDeviceCreateResult { Outcome = AdminDeviceCreateOutcome.Validation, Message = "نام دستگاه باید بین ۱ تا ۱۰ کاراکتر باشد" };

        var user = await _dbContext.Users.FirstOrDefaultAsync(u => u.Id == request.UserId, cancellationToken);
        if (user == null)
            return new AdminDeviceCreateResult { Outcome = AdminDeviceCreateOutcome.UserNotFound };

        if (await _dbContext.Devices.AnyAsync(d => d.DeviceName == deviceName, cancellationToken))
            return new AdminDeviceCreateResult { Outcome = AdminDeviceCreateOutcome.ConflictDuplicateName, Message = $"دستگاهی با نام «{deviceName}» از قبل وجود دارد" };

        var deviceId = await _deviceService.AddDeviceAsync(new DeviceDto
        {
            DeviceName = deviceName,
            UserId = request.UserId,
            Location = request.Location?.Trim() ?? string.Empty,
            NeshanLocation = request.NeshanLocation?.Trim() ?? string.Empty
        }, cancellationToken);

        // default settings (mirrors the app's default device-settings shape)
        await _deviceSettingsService.CreateAsync(new DeviceSettingsDto
        {
            DeviceId = deviceId,
            DeviceName = deviceName,
            MinimumSmsIntervalMinutes = 15,
            MinimumCallIntervalMinutes = 60,
            UploadIntervalMin = 5,
            RelayCount = 4,
            Relays = Enumerable.Range(1, 4).Select(i => new DeviceRelayDto
            {
                RelayIndex = i,
                Name = string.Empty,
                IsEnabled = true,
                RelayKind = Domain.RelayKind.Generic,
                RuleGroups = new List<DeviceRelayRuleGroupDto>()
            }).ToList()
        }, cancellationToken);

        AddAuditLog(currentAdminId, "Device.Create", deviceId.ToString(),
            JsonSerializer.Serialize(new { userId = request.UserId, deviceName }));
        await _dbContext.SaveChangesAsync(cancellationToken);

        return new AdminDeviceCreateResult
        {
            Outcome = AdminDeviceCreateOutcome.Ok,
            DeviceId = deviceId,
            DeviceName = deviceName
        };
    }

    public async Task<AdminSettingsUpdateResult> UpdateDeviceSettingsAsync(int deviceId, AdminDeviceSettingsUpdateRequest request, int currentAdminId, CancellationToken cancellationToken)
    {
        var device = await _dbContext.Devices
            .Include(d => d.User)
            .FirstOrDefaultAsync(d => d.Id == deviceId, cancellationToken);
        if (device == null)
            return new AdminSettingsUpdateResult { NotFound = true };

        var deviceName = request.DeviceName?.Trim() ?? string.Empty;
        if (deviceName.Length == 0 || deviceName.Length > 10)
            return new AdminSettingsUpdateResult { Message = "نام دستگاه باید بین ۱ تا ۱۰ کاراکتر باشد" };

        if (await _dbContext.Devices.AnyAsync(d => d.DeviceName == deviceName && d.Id != deviceId, cancellationToken))
            return new AdminSettingsUpdateResult { Message = $"دستگاهی با نام «{deviceName}» از قبل وجود دارد" };

        if (request.MinimumSmsIntervalMinutes < 1 || request.MinimumCallIntervalMinutes < 1 || request.UploadIntervalMin < 1)
            return new AdminSettingsUpdateResult { Message = "فاصله‌های زمانی باید بزرگ‌تر یا مساوی ۱ دقیقه باشند" };

        if (request.RelayCount < 1 || request.RelayCount > 16)
            return new AdminSettingsUpdateResult { Message = "تعداد رله باید بین ۱ تا ۱۶ باشد" };

        // keep existing location on the device entity (not part of this form)
        var settings = await _dbContext.DeviceSettings
            .Include(s => s.Relays)
                .ThenInclude(r => r.RuleGroups)
                    .ThenInclude(g => g.Conditions)
            .FirstOrDefaultAsync(s => s.DeviceId == deviceId, cancellationToken);

        var dto = new DeviceSettingsDto
        {
            DeviceId = deviceId,
            DeviceName = deviceName,
            Province = request.Province?.Trim() ?? string.Empty,
            City = request.City?.Trim() ?? string.Empty,
            Latitude = request.Latitude,
            Longitude = request.Longitude,
            ProductType = request.ProductType?.Trim() ?? string.Empty,
            MinimumSmsIntervalMinutes = request.MinimumSmsIntervalMinutes,
            MinimumCallIntervalMinutes = request.MinimumCallIntervalMinutes,
            AreaSquareMeters = request.AreaSquareMeters,
            UploadIntervalMin = request.UploadIntervalMin,
            DevicePhoneNumber = request.DevicePhoneNumber?.Trim() ?? string.Empty,
            SimCardType = request.SimCardType,
            RelayCount = request.RelayCount,
            SmsRecievers = request.SmsRecievers?.Trim() ?? string.Empty
        };

        if (settings == null)
        {
            dto.Id = 0;
            dto.CreatedAt = DateTime.UtcNow;
            dto.UpdatedAt = DateTime.UtcNow;
            dto.Relays = Enumerable.Range(1, request.RelayCount).Select(i => new DeviceRelayDto
            {
                RelayIndex = i,
                Name = string.Empty,
                IsEnabled = true,
                RelayKind = Domain.RelayKind.Generic,
                RuleGroups = new List<DeviceRelayRuleGroupDto>()
            }).ToList();
            await _deviceSettingsService.CreateAsync(dto, cancellationToken);
        }
        else
        {
            // keep existing relays so SyncRelays only adjusts count without wiping rules
            dto.Id = settings.Id;
            dto.Relays = settings.Relays
                .OrderBy(r => r.RelayIndex)
                .Select(r => new DeviceRelayDto
                {
                    Id = r.Id,
                    DeviceSettingsId = settings.Id,
                    RelayIndex = r.RelayIndex,
                    Name = r.Name,
                    IsEnabled = r.IsEnabled,
                    RelayKind = r.RelayKind,
                    RuleGroups = r.RuleGroups
                        .OrderBy(g => g.Order)
                        .Select(g => new DeviceRelayRuleGroupDto
                        {
                            Id = g.Id,
                            Action = g.Action,
                            Label = g.Label,
                            Order = g.Order,
                            Conditions = g.Conditions
                                .OrderBy(c => c.Order)
                                .Select(c => new DeviceRelayRuleConditionDto
                                {
                                    Id = c.Id,
                                    ConditionType = c.ConditionType,
                                    SensorType = c.SensorType,
                                    ComparisonType = c.ComparisonType,
                                    Value1 = c.Value1,
                                    Value2 = c.Value2,
                                    StartMinutes = c.StartMinutes,
                                    EndMinutes = c.EndMinutes,
                                    Order = c.Order
                                }).ToList()
                        }).ToList()
                }).ToList();
            await _deviceSettingsService.UpdateAsync(dto, cancellationToken);
        }

        AddAuditLog(currentAdminId, "Device.Update", deviceId.ToString(),
            JsonSerializer.Serialize(new
            {
                deviceName,
                relayCount = request.RelayCount,
                smsInterval = request.MinimumSmsIntervalMinutes,
                callInterval = request.MinimumCallIntervalMinutes,
                uploadInterval = request.UploadIntervalMin
            }));
        await _dbContext.SaveChangesAsync(cancellationToken);

        return new AdminSettingsUpdateResult();
    }

    public async Task<IReadOnlyList<AdminDeviceMemberDto>?> GetDeviceMembersAsync(int deviceId, CancellationToken cancellationToken)
    {
        var device = await _dbContext.Devices.AsNoTracking()
            .Include(d => d.User)
            .FirstOrDefaultAsync(d => d.Id == deviceId, cancellationToken);
        if (device == null) return null;

        var members = await _dbContext.DeviceUsers.AsNoTracking()
            .Include(du => du.User)
            .Where(du => du.DeviceId == deviceId)
            .OrderBy(du => du.Role)
            .ThenBy(du => du.UserId)
            .ToListAsync(cancellationToken);

        var result = new List<AdminDeviceMemberDto>(members.Count + 1);

        // owner row first (owner is NOT in DeviceUsers)
        result.Add(new AdminDeviceMemberDto
        {
            UserId = device.User.Id,
            Name = device.User.Name,
            Family = device.User.Family,
            Mobile = device.User.Mobile,
            MemberName = device.User.Name,
            MemberFamily = device.User.Family,
            Role = Domain.DeviceMemberRole.Manager,
            ReceiveAlerts = true,
            AvatarPath = null,
            IsOwner = true
        });

        result.AddRange(members.Select(du => new AdminDeviceMemberDto
        {
            UserId = du.UserId,
            Name = du.User.Name,
            Family = du.User.Family,
            Mobile = du.User.Mobile,
            MemberName = string.IsNullOrWhiteSpace(du.Name) ? du.User.Name : du.Name,
            MemberFamily = string.IsNullOrWhiteSpace(du.Family) ? du.User.Family : du.Family,
            Role = du.Role,
            ReceiveAlerts = du.ReceiveAlerts,
            AvatarPath = du.AvatarPath,
            IsOwner = false
        }));

        return result;
    }

    // ==================== Usage ====================

    public async Task<IReadOnlyList<UsageDayDto>> GetUsageAsync(DateTime? from, DateTime? to, int? userId, CancellationToken cancellationToken)
    {
        // default window: last 30 days
        var fromDate = DateOnly.FromDateTime((from ?? DateTime.UtcNow.AddDays(-30)).Date);
        var toDate = DateOnly.FromDateTime(to?.Date ?? DateTime.UtcNow.Date);

        IQueryable<Domain.UsageCounter> query = _dbContext.UsageCounters.AsNoTracking()
            .Where(u => u.Date >= fromDate && u.Date <= toDate);

        if (userId.HasValue)
            query = query.Where(u => u.UserId == userId.Value);

        var rows = await query
            .GroupBy(u => u.Date)
            .Select(g => new
            {
                Date = g.Key,
                Sms = g.Sum(x => x.SmsCount),
                Voice = g.Sum(x => x.VoiceCallCount),
                AiQueries = g.Sum(x => x.AiQueryCount),
                AiTokens = g.Sum(x => x.AiTokenCount)
            })
            .OrderBy(r => r.Date)
            .ToListAsync(cancellationToken);

        return rows.Select(r => new UsageDayDto
        {
            Date = r.Date.ToDateTime(new TimeOnly(0, 0)),
            SmsCount = r.Sms,
            VoiceCallCount = r.Voice,
            AiQueryCount = r.AiQueries,
            AiTokenCount = r.AiTokens
        }).ToList();
    }

    // ==================== Alerts ====================

    public async Task<PagedResult<AdminAlertItemDto>> GetAlertsAsync(AdminAlertFilter filter, CancellationToken cancellationToken)
    {
        if (filter.Page <= 0) filter.Page = 1;
        if (filter.PageSize <= 0) filter.PageSize = 20;

        IQueryable<Domain.AlertLog> query = _dbContext.AlertLogs.AsNoTracking()
            .Include(a => a.Device).ThenInclude(d => d.User);

        if (filter.DeviceId.HasValue)
            query = query.Where(a => a.DeviceId == filter.DeviceId.Value);
        if (filter.Status.HasValue)
            query = query.Where(a => a.Status == filter.Status.Value);
        if (filter.From.HasValue)
            query = query.Where(a => a.SentAt >= filter.From.Value);
        if (filter.To.HasValue)
            query = query.Where(a => a.SentAt <= filter.To.Value);

        var totalCount = await query.CountAsync(cancellationToken);

        var items = await query
            .OrderByDescending(a => a.SentAt)
            .ThenByDescending(a => a.Id)
            .Skip((filter.Page - 1) * filter.PageSize)
            .Take(filter.PageSize)
            .ToListAsync(cancellationToken);

        return new PagedResult<AdminAlertItemDto>
        {
            Items = items.Select(a => new AdminAlertItemDto
            {
                Id = a.Id,
                DeviceId = a.DeviceId,
                DeviceName = a.Device.DeviceName,
                OwnerName = a.Device.User.Name + " " + a.Device.User.Family,
                Message = a.Message,
                NotificationType = a.NotificationType,
                Status = a.Status,
                ErrorMessage = a.ErrorMessage,
                SentAt = a.SentAt
            }).ToList(),
            TotalCount = totalCount,
            Page = filter.Page,
            PageSize = filter.PageSize
        };
    }

    // ==================== Posts ====================

    public async Task<PagedResult<AdminPostItemDto>> GetPostsAsync(AdminPostFilter filter, CancellationToken cancellationToken)
    {
        if (filter.Page <= 0) filter.Page = 1;
        if (filter.PageSize <= 0) filter.PageSize = 20;

        IQueryable<Domain.DevicePost> query = _dbContext.DevicePosts.AsNoTracking()
            .Include(p => p.Device)
            .Include(p => p.AuthorUser)
            .Include(p => p.Images);

        if (filter.DeviceId.HasValue)
            query = query.Where(p => p.DeviceId == filter.DeviceId.Value);
        if (filter.AuthorUserId.HasValue)
            query = query.Where(p => p.AuthorUserId == filter.AuthorUserId.Value);
        if (filter.PostType.HasValue)
            query = query.Where(p => p.PostType == filter.PostType.Value);
        if (filter.From.HasValue)
            query = query.Where(p => p.CreatedAt >= filter.From.Value);
        if (filter.To.HasValue)
            query = query.Where(p => p.CreatedAt <= filter.To.Value);

        var totalCount = await query.CountAsync(cancellationToken);

        var items = await query
            .OrderByDescending(p => p.CreatedAt)
            .ThenByDescending(p => p.Id)
            .Skip((filter.Page - 1) * filter.PageSize)
            .Take(filter.PageSize)
            .ToListAsync(cancellationToken);

        return new PagedResult<AdminPostItemDto>
        {
            // ponytail: like/reply count intentionally omitted — DevicePost has no such fields yet.
            Items = items.Select(p => new AdminPostItemDto
            {
                Id = p.Id,
                DeviceId = p.DeviceId,
                DeviceName = p.Device.DeviceName,
                AuthorUserId = p.AuthorUserId,
                AuthorName = p.AuthorUser.Name + " " + p.AuthorUser.Family,
                Content = p.Content,
                PostType = p.PostType,
                ImageCount = p.Images.Count,
                HasVoice = !string.IsNullOrWhiteSpace(p.VoiceFilePath),
                VoiceDurationSeconds = p.VoiceDurationSeconds,
                CreatedAt = p.CreatedAt
            }).ToList(),
            TotalCount = totalCount,
            Page = filter.Page,
            PageSize = filter.PageSize
        };
    }

    public async Task<AdminPostDetailDto?> GetPostAsync(int id, CancellationToken cancellationToken)
    {
        var post = await _dbContext.DevicePosts.AsNoTracking()
            .Include(p => p.Device)
            .Include(p => p.AuthorUser)
            .Include(p => p.Images)
            .FirstOrDefaultAsync(p => p.Id == id, cancellationToken);
        if (post == null) return null;

        return new AdminPostDetailDto
        {
            Id = post.Id,
            DeviceId = post.DeviceId,
            DeviceName = post.Device.DeviceName,
            AuthorName = post.AuthorUser.Name,
            AuthorFamily = post.AuthorUser.Family,
            PostType = post.PostType,
            Content = post.Content,
            CreatedAt = post.CreatedAt,
            Images = post.Images.Select(i => new AdminPostImageDto
            {
                Id = i.Id,
                FileName = i.FileName,
                FilePath = i.FilePath
            }).ToList(),
            VoiceFilePath = post.VoiceFilePath,
            VoiceDurationSeconds = post.VoiceDurationSeconds
        };
    }

    public async Task<bool> DeletePostAsync(int id, int currentAdminId, CancellationToken cancellationToken)
    {
        var post = await _dbContext.DevicePosts
            .Include(p => p.Images)
            .FirstOrDefaultAsync(p => p.Id == id, cancellationToken);
        if (post == null) return false;

        // remove image files from disc (best effort — a missing file must not block the delete)
        var webRoot = _environment.WebRootPath ?? "wwwroot";
        foreach (var image in post.Images)
        {
            try
            {
                var fullPath = Path.Combine(webRoot, image.FilePath.TrimStart('/'));
                if (File.Exists(fullPath)) File.Delete(fullPath);
            }
            catch
            {
                // file cleanup is best-effort
            }
        }
        if (!string.IsNullOrWhiteSpace(post.VoiceFilePath))
        {
            try
            {
                var voicePath = Path.Combine(webRoot, post.VoiceFilePath.TrimStart('/'));
                if (File.Exists(voicePath)) File.Delete(voicePath);
            }
            catch
            {
                // file cleanup is best-effort
            }
        }

        AddAuditLog(currentAdminId, "Post.Delete", id.ToString());
        _dbContext.DevicePosts.Remove(post);
        await _dbContext.SaveChangesAsync(cancellationToken);
        return true;
    }

    // ==================== Device Debug ====================

    public async Task<AdminDeviceTestResultDto> TestDeviceSmsAsync(int deviceId, int currentAdminId, CancellationToken cancellationToken)
    {
        var device = await _dbContext.Devices.AsNoTracking()
            .Include(d => d.User)
            .FirstOrDefaultAsync(d => d.Id == deviceId, cancellationToken);
        if (device == null)
            return new AdminDeviceTestResultDto { Success = false, Message = "دستگاه یافت نشد" };

        var mobile = MobileNormalizer.Normalize(device.User.Mobile);
        if (mobile.Length == 0)
            return new AdminDeviceTestResultDto { Success = false, Message = "شماره موبایل مالک معتبر نیست" };

        // persist the audit row up-front so it is recorded no matter how the send attempt ends
        AddAuditLog(currentAdminId, "Device.TestSms", deviceId.ToString(),
            JsonSerializer.Serialize(new { mobile }));
        await _dbContext.SaveChangesAsync(cancellationToken);

        try
        {
            var result = await _smsService.SendWebserviceSmsAsync(new WebserviceSmsRequest
            {
                Recipient = mobile,
                Message = $"پیامک تست GreenHome برای دستگاه {device.DeviceName} — {DateTime.UtcNow:yyyy/MM/dd HH:mm} UTC"
            }, cancellationToken);

            if (result?.Meta.Status == true)
            {
                await _usageTracker.RecordAsync(device.User.Id, UsageKind.Sms, cancellationToken: cancellationToken);
                return new AdminDeviceTestResultDto { Success = true, Message = $"پیامک تست برای {mobile} ارسال شد" };
            }

            var reason = result?.Meta.Message ?? "خطای نامشخص سرویس پیامک";
            return new AdminDeviceTestResultDto { Success = false, Message = reason };
        }
        catch (Exception ex)
        {
            return new AdminDeviceTestResultDto { Success = false, Message = $"خطا در ارسال: {ex.Message}" };
        }
    }

    public async Task<AdminDeviceTestResultDto> TestDeviceVoiceAsync(int deviceId, int currentAdminId, CancellationToken cancellationToken)
    {
        var device = await _dbContext.Devices.AsNoTracking()
            .Include(d => d.User)
            .FirstOrDefaultAsync(d => d.Id == deviceId, cancellationToken);
        if (device == null)
            return new AdminDeviceTestResultDto { Success = false, Message = "دستگاه یافت نشد" };

        var mobile = MobileNormalizer.Normalize(device.User.Mobile);
        if (mobile.Length == 0)
            return new AdminDeviceTestResultDto { Success = false, Message = "شماره موبایل مالک معتبر نیست" };

        // persist the audit row up-front so it is recorded no matter how the send attempt ends
        AddAuditLog(currentAdminId, "Device.TestVoice", deviceId.ToString(),
            JsonSerializer.Serialize(new { mobile }));
        await _dbContext.SaveChangesAsync(cancellationToken);

        try
        {
            var result = await _voiceCallService.QuickSendWithTTSAsync(new QuickSendWithTTSRequest
            {
                Text = $"پیام صوتی تست از پنل مدیریت گری‌هوم برای دستگاه {device.DeviceName}",
                Number = mobile,
                ServerID = 0
            }, cancellationToken);

            if (result?.IsSuccess == true)
            {
                // ponytail: ثبت مصرف فقط وقتی call واقعی ارسال می‌شود (هماهنگ با AlertNotificationSender)
                await _usageTracker.RecordAsync(device.User.Id, UsageKind.VoiceCall, cancellationToken: cancellationToken);
                return new AdminDeviceTestResultDto { Success = true, Message = $"تماس صوتی تست برای {mobile} انجام شد" };
            }

            var reason = result == null ? "پاسخی از سرویس صوتی دریافت نشد"
                : $"کد خطا: {result.ReturnValue}";
            return new AdminDeviceTestResultDto { Success = false, Message = reason };
        }
        catch (Exception ex)
        {
            return new AdminDeviceTestResultDto { Success = false, Message = $"خطا در تماس صوتی: {ex.Message}" };
        }
    }

    // ==================== Reports ====================

    public async Task<IReadOnlyList<AdminUserGrowthRowDto>> GetUserGrowthReportAsync(DateTime from, DateTime to, CancellationToken cancellationToken)
    {
        var fromDate = DateOnly.FromDateTime(from.Date);
        var toDate = DateOnly.FromDateTime(to.Date);

        var newUsers = await _dbContext.Users.AsNoTracking()
            .Where(u => DateOnly.FromDateTime(u.CreatedAt) >= fromDate && DateOnly.FromDateTime(u.CreatedAt) <= toDate)
            .Select(u => new { Date = DateOnly.FromDateTime(u.CreatedAt) })
            .GroupBy(x => x.Date)
            .Select(g => new { Date = g.Key, Count = g.Count() })
            .ToDictionaryAsync(x => x.Date, x => x.Count, cancellationToken);

        var activeUsers = await _dbContext.Users.AsNoTracking()
            .Where(u => u.LastLoginAt != null
                && DateOnly.FromDateTime(u.LastLoginAt!.Value) >= fromDate
                && DateOnly.FromDateTime(u.LastLoginAt!.Value) <= toDate)
            .Select(u => new { Date = DateOnly.FromDateTime(u.LastLoginAt!.Value) })
            .GroupBy(x => x.Date)
            .Select(g => new { Date = g.Key, Count = g.Count() })
            .ToDictionaryAsync(x => x.Date, x => x.Count, cancellationToken);

        var rows = new List<AdminUserGrowthRowDto>();
        for (var day = fromDate; day <= toDate; day = day.AddDays(1))
        {
            rows.Add(new AdminUserGrowthRowDto
            {
                Date = day,
                NewUsers = newUsers.GetValueOrDefault(day),
                ActiveUsers = activeUsers.GetValueOrDefault(day)
            });
        }
        return rows;
    }

    public async Task<IReadOnlyList<AdminDeviceUptimeRowDto>> GetDeviceUptimeReportAsync(DateTime from, DateTime to, CancellationToken cancellationToken)
    {
        // ponytail: per-day distinct scan of TelemetryRecords is O(total rows in window);
        // fine for a few dozen devices — swap for a pre-aggregated daily table if it grows.
        var fromDate = DateOnly.FromDateTime(from.Date);
        var toDate = DateOnly.FromDateTime(to.Date);
        var totalDays = toDate.DayNumber - fromDate.DayNumber + 1;

        var devices = await _dbContext.Devices.AsNoTracking()
            .Include(d => d.User)
            .OrderBy(d => d.DeviceName)
            .ToListAsync(cancellationToken);

        var onlineDays = await _dbContext.TelemetryRecords.AsNoTracking()
            .Where(t => t.ServerTimestampUtc >= from.Date && t.ServerTimestampUtc < to.Date.AddDays(1))
            .GroupBy(t => t.DeviceId)
            .Select(g => new
            {
                DeviceId = g.Key,
                Days = g.Select(t => DateOnly.FromDateTime(t.ServerTimestampUtc)).Distinct().Count()
            })
            .ToDictionaryAsync(x => x.DeviceId, x => x.Days, cancellationToken);

        return devices.Select(d =>
        {
            var online = onlineDays.GetValueOrDefault(d.Id, 0);
            return new AdminDeviceUptimeRowDto
            {
                DeviceId = d.Id,
                DeviceName = d.DeviceName,
                OwnerName = d.User.Name + " " + d.User.Family,
                TotalDays = totalDays,
                OnlineDays = online,
                OnlinePercent = totalDays > 0 ? (int)Math.Round(online * 100.0 / totalDays) : 0
            };
        }).ToList();
    }

    public async Task<IReadOnlyList<AdminUsageByUserRowDto>> GetUsageByUserReportAsync(DateTime from, DateTime to, CancellationToken cancellationToken)
    {
        var fromDate = DateOnly.FromDateTime(from.Date);
        var toDate = DateOnly.FromDateTime(to.Date);

        var rows = await _dbContext.UsageCounters.AsNoTracking()
            .Where(u => u.Date >= fromDate && u.Date <= toDate)
            .GroupBy(u => u.UserId)
            .Select(g => new
            {
                UserId = g.Key,
                Sms = g.Sum(x => x.SmsCount),
                Voice = g.Sum(x => x.VoiceCallCount),
                AiQueries = g.Sum(x => x.AiQueryCount),
                AiTokens = g.Sum(x => x.AiTokenCount)
            })
            .ToListAsync(cancellationToken);

        var userIds = rows.Select(r => r.UserId).ToList();
        var users = await _dbContext.Users.AsNoTracking()
            .Where(u => userIds.Contains(u.Id))
            .ToDictionaryAsync(u => u.Id, cancellationToken);

        return rows
            .Where(r => users.ContainsKey(r.UserId))
            .OrderByDescending(r => r.Sms + r.Voice + r.AiQueries)
            .Select(r => new AdminUsageByUserRowDto
            {
                UserId = r.UserId,
                Name = users[r.UserId].Name,
                Family = users[r.UserId].Family,
                Mobile = users[r.UserId].Mobile,
                Sms = r.Sms,
                VoiceCall = r.Voice,
                AiQueries = r.AiQueries,
                AiTokens = r.AiTokens
            })
            .ToList();
    }

    // ==================== Audit Log ====================

    public async Task<PagedResult<AdminAuditLogDto>> GetAuditLogsAsync(AdminAuditLogFilter filter, CancellationToken cancellationToken)
    {
        if (filter.Page <= 0) filter.Page = 1;
        if (filter.PageSize <= 0) filter.PageSize = 20;

        IQueryable<Domain.AdminAuditLog> query = _dbContext.AdminAuditLogs.AsNoTracking()
            .Include(a => a.AdminUser);

        if (filter.AdminId.HasValue)
            query = query.Where(a => a.AdminUserId == filter.AdminId.Value);

        var totalCount = await query.CountAsync(cancellationToken);

        var items = await query
            .OrderByDescending(a => a.At)
            .ThenByDescending(a => a.Id)
            .Skip((filter.Page - 1) * filter.PageSize)
            .Take(filter.PageSize)
            .ToListAsync(cancellationToken);

        return new PagedResult<AdminAuditLogDto>
        {
            Items = items.Select(a => new AdminAuditLogDto
            {
                Id = a.Id,
                AdminUserId = a.AdminUserId,
                AdminName = a.AdminUser.Name + " " + a.AdminUser.Family,
                Action = a.Action,
                TargetId = a.TargetId,
                Details = a.Details,
                At = a.At
            }).ToList(),
            TotalCount = totalCount,
            Page = filter.Page,
            PageSize = filter.PageSize
        };
    }

    // ==================== Helpers ====================

    /// <summary>
    /// یک ردیف audit log به change tracker اضافه می‌کند؛ با همان SaveChanges عملیات اصلی ذخیره می‌شود.
    /// </summary>
    private void AddAuditLog(int adminUserId, string action, string targetId, string details = "")
    {
        _dbContext.AdminAuditLogs.Add(new Domain.AdminAuditLog
        {
            AdminUserId = adminUserId,
            Action = action,
            TargetId = targetId,
            Details = details,
            At = DateTime.UtcNow
        });
    }

    /// <summary>
    /// آخرین تلیمتری هر دستگاه + نام مالک (برای لیست‌های admin).
    /// </summary>
    private async Task<(Dictionary<int, Domain.TelemetryRecord> Latest, Dictionary<int, string> OwnerNames)> GetDeviceMetaAsync(
        IReadOnlyList<int> deviceIds, CancellationToken cancellationToken)
    {
        if (deviceIds.Count == 0)
            return (new Dictionary<int, Domain.TelemetryRecord>(), new Dictionary<int, string>());

        var latestRows = await _dbContext.TelemetryRecords
            .AsNoTracking()
            .Where(t => deviceIds.Contains(t.DeviceId))
            .GroupBy(t => t.DeviceId)
            .Select(g => g.OrderByDescending(t => t.ServerTimestampUtc).First())
            .ToListAsync(cancellationToken);

        var latest = latestRows.ToDictionary(t => t.DeviceId);

        var owners = await _dbContext.Devices
            .Where(d => deviceIds.Contains(d.Id))
            .Select(d => new { d.Id, Owner = d.User.Name + " " + d.User.Family })
            .ToDictionaryAsync(x => x.Id, x => x.Owner, cancellationToken);

        return (latest, owners);
    }

    private async Task<IReadOnlyList<AdminDeviceListItemDto>> BuildDeviceListAsync(
        IReadOnlyList<int> deviceIds,
        Dictionary<int, Domain.TelemetryRecord> latestMap,
        CancellationToken cancellationToken)
    {
        if (deviceIds.Count == 0) return [];

        var devices = await _dbContext.Devices.AsNoTracking()
            .Include(d => d.User)
            .Where(d => deviceIds.Contains(d.Id))
            .ToListAsync(cancellationToken);

        return devices.Select(d => ToDeviceListItem(d, latestMap)).ToList();
    }

    /// <summary>
    /// Persian (۰-۹) و Arabic (٠-٩) digits را به آستانه‌ای انگلیسی تبدیل می‌کند تا search با ارقام فارسی هم کار کند.
    /// (MobileNormalizer برای فرمت یکپارچه موبایل است و برای رشته‌ی general search قابل استفاده نیست.)
    /// </summary>
    private static string NormalizeDigits(string input)
    {
        var chars = input.ToCharArray();
        for (var i = 0; i < chars.Length; i++)
        {
            var c = chars[i];
            if (c is >= '۰' and <= '۹') chars[i] = (char)('0' + c - '۰');
            else if (c is >= '٠' and <= '٩') chars[i] = (char)('0' + c - '٠');
        }
        return new string(chars);
    }

    private AdminDeviceListItemDto ToDeviceListItem(Domain.Device device, Dictionary<int, Domain.TelemetryRecord> latestMap)
    {
        latestMap.TryGetValue(device.Id, out var last);
        var online = last != null && last.ServerTimestampUtc >= DateTime.UtcNow.AddMinutes(-_onlineWindowMinutes);

        return new AdminDeviceListItemDto
        {
            Id = device.Id,
            DeviceName = device.DeviceName,
            Location = device.Location,
            OwnerName = device.User.Name + " " + device.User.Family,
            OwnerMobile = device.User.Mobile,
            IsOnline = online,
            LastTelemetryAt = last?.ServerTimestampUtc,
            TemperatureC = last?.TemperatureC,
            HumidityPercent = last?.HumidityPercent
        };
    }
}