using System.Text.Json;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Tiku.Application.PlatformAdmin;
using Tiku.Application.Security;
using Tiku.Application.Tenancy;
using Tiku.Domain.Common;
using Tiku.Domain.Growth;
using Tiku.Domain.Operations;
using Tiku.Domain.Platform;
using Tiku.Domain.Tenancy;
using Tiku.Infrastructure.Persistence;

namespace Tiku.Infrastructure.PlatformAdmin;

internal sealed class PlatformSmsAdminService(ITenantExecutionScope tenantExecutionScope) : IPlatformSmsAdminService
{
    public Task<PlatformTenantCapabilityList<PlatformSmsChannelItem>> GetChannelsAsync(PlatformCapabilityActor actor,
        PlatformCapabilityQuery query, CancellationToken cancellationToken = default)
    {
        return ExecuteAsync("platform sms channels list", async (services, token) =>
        {
            var db = services.GetRequiredService<IPlatformTenantCapabilitiesPersistence>();
            var monthStart = new DateTimeOffset(DateTimeOffset.UtcNow.Year, DateTimeOffset.UtcNow.Month, 1, 0, 0, 0,
                TimeSpan.Zero);
            var sentCounts = await db.SmsSendLogs.AsNoTracking()
                .Where(value => value.CreatedAt >= monthStart && value.Status == SmsSendLogStatus.Sent &&
                                value.ChannelId.HasValue)
                .GroupBy(value => value.ChannelId!.Value)
                .Select(group => new { ChannelId = group.Key, Count = group.Count() })
                .ToDictionaryAsync(value => value.ChannelId, value => value.Count, token);
            var values =
                from channel in db.SmsChannels.AsNoTracking()
                join tenant in db.Tenants.AsNoTracking() on channel.TenantId equals tenant.Id
                select new { channel, tenant.Name };
            if (query.TenantId.HasValue) values = values.Where(value => value.channel.TenantId == query.TenantId);
            if (!string.IsNullOrWhiteSpace(query.Status))
                values = values.Where(value =>
                    value.channel.Status == ParseEnum(query.Status, TenantExternalProviderStatus.Active));
            var rows = await values.OrderBy(value => value.channel.Priority)
                .ThenByDescending(value => value.channel.UpdatedAt).Take(Limit(query.Limit)).ToArrayAsync(token);
            return new PlatformTenantCapabilityList<PlatformSmsChannelItem>(rows.Select(value =>
                ToChannelItem(value.channel, value.Name, sentCounts.GetValueOrDefault(value.channel.Id))).ToArray());
        }, cancellationToken);
    }

    public Task<PlatformSmsChannelItem> UpsertChannelAsync(PlatformCapabilityActor actor,
        UpsertPlatformSmsChannelCommand command, CancellationToken cancellationToken = default)
    {
        return ExecuteAsync("platform sms channel upsert", async (services, token) =>
        {
            var db = services.GetRequiredService<IPlatformTenantCapabilitiesPersistence>();
            var tenantName = await TenantNameAsync(db, command.TenantId, token);
            var provider = NormalizeCode(command.Provider);
            var scene = NormalizeCode(command.Scene);
            var item = command.Id.HasValue
                ? await db.SmsChannels.SingleOrDefaultAsync(
                    value => value.Id == command.Id.Value && value.TenantId == command.TenantId, token)
                : await db.SmsChannels.SingleOrDefaultAsync(
                    value => value.TenantId == command.TenantId && value.Provider == provider && value.Scene == scene,
                    token);
            if (item is null)
            {
                item = new SmsChannel { TenantId = command.TenantId };
                db.SmsChannels.Add(item);
            }

            item.Provider = provider;
            item.Name = command.Name.Trim();
            item.Signature = command.Signature.Trim();
            item.Scene = scene;
            item.Status = command.Status;
            item.SecretRef = Normalize(command.SecretRef);
            item.Priority = command.Priority ?? item.Priority;
            item.MonthlyQuota = Math.Max(0, command.MonthlyQuota ?? item.MonthlyQuota);
            item.ConfigPublic = command.ConfigPublic;
            item.Metadata = command.Metadata;
            item.UpdatedAt = DateTimeOffset.UtcNow;
            AddAudit(db, actor, command.TenantId, "platform.sms.channel.upserted", "sms_channels", item.Id,
                new { item.Provider, item.Scene, item.Status });
            await db.SaveChangesAsync(token);
            return ToChannelItem(item, tenantName, 0);
        }, cancellationToken);
    }

    public Task<PlatformSmsChannelItem> DisableChannelAsync(PlatformCapabilityActor actor, Guid channelId,
        CancellationToken cancellationToken = default)
    {
        return ExecuteAsync("platform sms channel disable", async (services, token) =>
        {
            var db = services.GetRequiredService<IPlatformTenantCapabilitiesPersistence>();
            var item = await db.SmsChannels.SingleOrDefaultAsync(value => value.Id == channelId, token)
                       ?? throw Error("SMS channel was not found.", "sms_channel_not_found");
            item.Status = TenantExternalProviderStatus.Disabled;
            item.UpdatedAt = DateTimeOffset.UtcNow;
            AddAudit(db, actor, item.TenantId, "platform.sms.channel.disabled", "sms_channels", item.Id,
                new { item.Provider, item.Scene });
            await db.SaveChangesAsync(token);
            return ToChannelItem(item, await TenantNameAsync(db, item.TenantId, token), 0);
        }, cancellationToken);
    }

    public Task<PlatformTenantCapabilityList<PlatformSmsTemplateItem>> GetTemplatesAsync(PlatformCapabilityActor actor,
        PlatformCapabilityQuery query, CancellationToken cancellationToken = default)
    {
        return ExecuteAsync("platform sms templates list", async (services, token) =>
        {
            var db = services.GetRequiredService<IPlatformTenantCapabilitiesPersistence>();
            var sentCounts = await db.SmsSendLogs.AsNoTracking()
                .Where(value => value.TemplateId.HasValue)
                .GroupBy(value => value.TemplateId!.Value)
                .Select(group => new
                {
                    TemplateId = group.Key,
                    Sent = group.Count(value => value.Status == SmsSendLogStatus.Sent),
                    Failed = group.Count(value => value.Status == SmsSendLogStatus.Failed)
                })
                .ToDictionaryAsync(value => value.TemplateId, token);
            var values =
                from template in db.SmsTemplates.AsNoTracking()
                join channel in db.SmsChannels.AsNoTracking() on new { template.TenantId, template.ChannelId } equals
                    new { channel.TenantId, ChannelId = channel.Id }
                join tenant in db.Tenants.AsNoTracking() on template.TenantId equals tenant.Id
                select new { template, channel.Name, TenantName = tenant.Name };
            if (query.TenantId.HasValue) values = values.Where(value => value.template.TenantId == query.TenantId);
            if (!string.IsNullOrWhiteSpace(query.Status))
                values = values.Where(value =>
                    value.template.Status == ParseEnum(query.Status, SmsTemplateStatus.Active));
            var rows = await values.OrderByDescending(value => value.template.UpdatedAt).Take(Limit(query.Limit))
                .ToArrayAsync(token);
            return new PlatformTenantCapabilityList<PlatformSmsTemplateItem>(rows.Select(value =>
            {
                var counts = sentCounts.GetValueOrDefault(value.template.Id);
                return ToTemplateItem(value.template, value.TenantName, value.Name, counts?.Sent ?? 0,
                    counts?.Failed ?? 0);
            }).ToArray());
        }, cancellationToken);
    }

    public Task<PlatformSmsTemplateItem> UpsertTemplateAsync(PlatformCapabilityActor actor,
        UpsertPlatformSmsTemplateCommand command, CancellationToken cancellationToken = default)
    {
        return ExecuteAsync("platform sms template upsert", async (services, token) =>
        {
            var db = services.GetRequiredService<IPlatformTenantCapabilitiesPersistence>();
            var channel = await db.SmsChannels.AsNoTracking()
                              .SingleOrDefaultAsync(
                                  value => value.Id == command.ChannelId && value.TenantId == command.TenantId, token)
                          ?? throw Error("SMS channel was not found.", "sms_channel_not_found");
            var item = command.Id.HasValue
                ? await db.SmsTemplates.SingleOrDefaultAsync(
                    value => value.Id == command.Id.Value && value.TenantId == command.TenantId, token)
                : await db.SmsTemplates.SingleOrDefaultAsync(
                    value => value.TenantId == command.TenantId && value.Code == NormalizeCode(command.Code), token);
            if (item is null)
            {
                item = new SmsTemplate { TenantId = command.TenantId };
                db.SmsTemplates.Add(item);
            }

            item.ChannelId = command.ChannelId;
            item.Code = NormalizeCode(command.Code);
            item.Name = command.Name.Trim();
            item.Type = command.Type;
            item.AuditStatus = command.AuditStatus;
            item.Status = command.Status;
            item.ProviderTemplateCode = Normalize(command.ProviderTemplateCode);
            item.Content = command.Content.Trim();
            item.Remark = Normalize(command.Remark);
            item.Metadata = command.Metadata;
            item.UpdatedAt = DateTimeOffset.UtcNow;
            AddAudit(db, actor, command.TenantId, "platform.sms.template.upserted", "sms_templates", item.Id,
                new { item.Code, item.AuditStatus, item.Status });
            await db.SaveChangesAsync(token);
            return ToTemplateItem(item, await TenantNameAsync(db, item.TenantId, token), channel.Name, 0, 0);
        }, cancellationToken);
    }

    public Task<PlatformSmsTemplateItem> SubmitTemplateReviewAsync(PlatformCapabilityActor actor, Guid templateId,
        CancellationToken cancellationToken = default)
    {
        return ChangeTemplateAsync(actor, templateId, SmsTemplateAuditStatus.PendingReview, null,
            "platform.sms.template.review_submitted", cancellationToken);
    }

    public Task<PlatformSmsTemplateItem> DisableTemplateAsync(PlatformCapabilityActor actor, Guid templateId,
        CancellationToken cancellationToken = default)
    {
        return ChangeTemplateAsync(actor, templateId, null, SmsTemplateStatus.Disabled,
            "platform.sms.template.disabled", cancellationToken);
    }

    public Task<PlatformTenantCapabilityList<SmsSendLog>> GetLogsAsync(PlatformCapabilityActor actor,
        PlatformCapabilityQuery query, CancellationToken cancellationToken = default)
    {
        return ExecuteAsync("platform sms logs list", async (services, token) =>
        {
            var db = services.GetRequiredService<IPlatformTenantCapabilitiesPersistence>();
            var values = db.SmsSendLogs.AsNoTracking();
            if (query.TenantId.HasValue) values = values.Where(value => value.TenantId == query.TenantId);
            if (!string.IsNullOrWhiteSpace(query.Status))
                values = values.Where(value => value.Status == ParseEnum(query.Status, SmsSendLogStatus.Sent));
            return new PlatformTenantCapabilityList<SmsSendLog>(await values.OrderByDescending(value => value.CreatedAt)
                .Take(Limit(query.Limit)).ToArrayAsync(token));
        }, cancellationToken);
    }

    private Task<PlatformSmsTemplateItem> ChangeTemplateAsync(PlatformCapabilityActor actor, Guid templateId,
        SmsTemplateAuditStatus? auditStatus, SmsTemplateStatus? status, string action,
        CancellationToken cancellationToken)
    {
        return ExecuteAsync(action, async (services, token) =>
        {
            var db = services.GetRequiredService<IPlatformTenantCapabilitiesPersistence>();
            var item = await db.SmsTemplates.SingleOrDefaultAsync(value => value.Id == templateId, token)
                       ?? throw Error("SMS template was not found.", "sms_template_not_found");
            var channelName = await db.SmsChannels.AsNoTracking()
                .Where(value => value.TenantId == item.TenantId && value.Id == item.ChannelId)
                .Select(value => value.Name).SingleAsync(token);
            if (auditStatus.HasValue)
            {
                item.AuditStatus = auditStatus.Value;
                item.SubmittedAt = DateTimeOffset.UtcNow;
            }

            if (status.HasValue)
            {
                item.Status = status.Value;
                item.DisabledAt = DateTimeOffset.UtcNow;
            }

            item.UpdatedAt = DateTimeOffset.UtcNow;
            AddAudit(db, actor, item.TenantId, action, "sms_templates", item.Id,
                new { item.Code, item.AuditStatus, item.Status });
            await db.SaveChangesAsync(token);
            return ToTemplateItem(item, await TenantNameAsync(db, item.TenantId, token), channelName, 0, 0);
        }, cancellationToken);
    }

    private Task<TResult> ExecuteAsync<TResult>(string reason,
        Func<IServiceProvider, CancellationToken, Task<TResult>> operation, CancellationToken cancellationToken)
    {
        return tenantExecutionScope.ExecuteAsync(
            new SystemScopeRequest(null, SystemScopeCallerType.Platform, nameof(PlatformSmsAdminService), reason,
                Guid.NewGuid().ToString("N"), true), operation, cancellationToken);
    }

    private static PlatformSmsChannelItem ToChannelItem(SmsChannel channel, string tenantName, int sentThisMonth)
    {
        return new PlatformSmsChannelItem(channel.Id, channel.TenantId, tenantName, channel.Provider, channel.Name,
            channel.Signature,
            channel.Scene, channel.Status,
            channel.SecretRef, channel.Priority, channel.MonthlyQuota, sentThisMonth, channel.ConfigPublic,
            channel.Metadata, channel.UpdatedAt);
    }

    private static PlatformSmsTemplateItem ToTemplateItem(SmsTemplate template, string tenantName, string channelName,
        int sent, int failed)
    {
        return new PlatformSmsTemplateItem(template.Id, template.TenantId, tenantName, template.ChannelId, channelName,
            template.Code,
            template.Name, template.Type,
            template.AuditStatus, template.Status, template.ProviderTemplateCode, template.Content, template.Remark,
            sent, failed, template.UpdatedAt);
    }

    private static async Task<string> TenantNameAsync(IPlatformTenantCapabilitiesPersistence db, Guid tenantId, CancellationToken token)
    {
        return await db.Tenants.Where(value => value.Id == tenantId).Select(value => value.Name)
                   .SingleOrDefaultAsync(token)
               ?? throw Error("Tenant was not found.", "tenant_not_found");
    }

    private static PlatformCapabilityException Error(string message, string code)
    {
        return new PlatformCapabilityException(message, code);
    }

    private static int Limit(int value)
    {
        return Math.Clamp(value, 1, 500);
    }

    private static string NormalizeCode(string value)
    {
        return value.Trim().ToLowerInvariant().Replace("-", "_", StringComparison.Ordinal);
    }

    private static string? Normalize(string? value)
    {
        return string.IsNullOrWhiteSpace(value) ? null : value.Trim();
    }

    private static T ParseEnum<T>(string? value, T fallback) where T : struct, Enum
    {
        return Enum.TryParse<T>(value?.Trim().Replace("-", "_", StringComparison.Ordinal), true, out var parsed)
            ? parsed
            : fallback;
    }

    private static void AddAudit(IPlatformTenantCapabilitiesPersistence db, PlatformCapabilityActor actor, Guid tenantId, string action,
        string targetType, Guid targetId, object details)
    {
        db.AuditLogs.Add(new AuditLog
        {
            TenantId = tenantId,
            ActorUserId = actor.UserId,
            Action = action,
            TargetType = targetType,
            TargetId = targetId.ToString(),
            Details = JsonSerializer.SerializeToElement(details)
        });
    }
}