using MailKit;
using MailKit.Net.Imap;
using MailKit.Security;
using Microsoft.EntityFrameworkCore;
using MMail.Client.Data;
using MMail.Client.Models;

namespace MMail.Client.Services;

public sealed record DeleteResult(bool Success, string Error);

/// <summary>
/// 删除一封邮件:服务器上打 \Deleted 再 EXPUNGE,本地删掉记录与磁盘文件。
///
/// 「用完即断」与发送、同步一致:删完立即断开,不保活。
///
/// 两处都要删,缺一不可:
///   - 只删服务器:本地记录还在,界面上这封邮件阴魂不散,下一轮同步也不会
///     把它收走——同步只按 UID 增量新增,从不回收本地多余的行。
///   - 只删本地:草稿还留在服务器上,换个客户端(或在网页端)一看还在,
///     而用户这边已经发出去了,看着像「发了两遍」。
///
/// 服务器删除失败时不删本地:本地删了就没法重试了,而留在界面上至少还
/// 看得见、还删得动。
/// </summary>
public sealed class MessageDeleteService
{
    private readonly AppDbContext _db;
    private readonly CredentialVault _vault;
    private readonly OAuth2Service _oauth2;
    private readonly ILogger<MessageDeleteService> _logger;

    public MessageDeleteService(
        AppDbContext db,
        CredentialVault vault,
        OAuth2Service oauth2,
        ILogger<MessageDeleteService> logger)
    {
        _db = db;
        _vault = vault;
        _oauth2 = oauth2;
        _logger = logger;
    }

    public async Task<DeleteResult> DeleteAsync(int messageId, CancellationToken ct = default)
    {
        var message = await _db.Messages
            .Include(m => m.Attachments)
            .FirstOrDefaultAsync(m => m.Id == messageId, ct);

        if (message is null) return new DeleteResult(false, "邮件不存在");

        var folder = await _db.Folders.FirstOrDefaultAsync(f => f.Id == message.FolderId, ct);
        var account = await _db.Accounts.FirstOrDefaultAsync(a => a.Id == message.AccountId, ct);

        if (folder is null || account is null)
        {
            return new DeleteResult(false, "这封邮件所属的文件夹或账号已不存在");
        }

        string secret;
        try
        {
            secret = _vault.Unprotect(account.EncryptedSecret);
        }
        catch (Exception ex)
        {
            // 与存草稿同款处理:密钥丢失时库里那串密文已无解,
            // 给一句能照着做的提示,而不是一个 500
            _logger.LogWarning(ex, "无法解密账号 {Email} 的凭据", account.EmailAddress);
            return new DeleteResult(false,
                "无法解密该账号保存的密码(加密密钥可能已丢失,常见于重建容器时没保留数据目录)。"
                + "请在账号页重新填写密码或重新授权。");
        }

        // 与发送一致:OAuth2 允许多试一次(首次可能用到已作废的缓存令牌)
        var attempts = account.AuthType == AuthType.OAuth2 ? 2 : 1;
        string? failure = null;

        for (var attempt = 1; attempt <= attempts; attempt++)
        {
            var credential = await ResolveCredentialAsync(account, secret, attempt > 1, ct);

            try
            {
                using var imap = new ImapClient();
                await imap.ConnectAsync(
                    account.ImapHost,
                    account.ImapPort,
                    account.ImapUseSsl ? SecureSocketOptions.SslOnConnect : SecureSocketOptions.Auto,
                    ct);

                await AuthenticateAsync(imap, account, credential, ct);

                // 网易系要求客户端自报身份,否则等下 Open 会被判 Unsafe Login 拒掉
                await ImapIdentify.TrySendAsync(imap, account.EmailAddress, _logger, ct);

                var imapFolder = await imap.GetFolderAsync(folder.ImapName, ct);
                await imapFolder.OpenAsync(FolderAccess.ReadWrite, ct);

                // 邮件在别处已被删掉时,按这个 UID 打标记是空操作,服务器回 OK——
                // 于是「本地有、服务器没有」这种不一致也能被这一步收敛掉
                await imapFolder.AddFlagsAsync(
                    new UniqueId((uint)message.Uid), MessageFlags.Deleted, silent: true, ct);
                await imapFolder.ExpungeAsync(ct);

                await imapFolder.CloseAsync(false, ct);
                await imap.DisconnectAsync(true, ct);

                failure = null;
                break;
            }
            catch (Exception ex)
            {
                failure = $"从服务器删除失败:{ex.Message}";
                _logger.LogWarning(ex, "删除邮件失败(账号 {Email},UID {Uid})",
                    account.EmailAddress, message.Uid);

                if (attempt < attempts)
                {
                    _oauth2.InvalidateToken(account.Id);
                    await Task.Delay(200, ct);
                }
            }
        }

        if (failure is not null) return new DeleteResult(false, failure);

        DeleteLocalFiles(message);

        _db.Messages.Remove(message);
        await _db.SaveChangesAsync(ct);

        return new DeleteResult(true, "");
    }

    /// <summary>
    /// 落盘内容不跟着记录走就会变成孤儿文件,越攒越多。
    /// 删不掉(被占用、权限)只记日志:数据库记录已经没了,
    /// 为几个残文件让整次删除失败不值得。
    /// </summary>
    private void DeleteLocalFiles(Message message)
    {
        var paths = message.Attachments
            .Select(a => a.LocalPath)
            .Append(message.RawPath);

        foreach (var path in paths)
        {
            if (string.IsNullOrWhiteSpace(path)) continue;

            try
            {
                File.Delete(path);
            }
            catch (Exception ex)
            {
                _logger.LogWarning(ex, "删除文件失败:{Path}", path);
            }
        }
    }

    /// <summary>OAuth2 账号用现换的 access token,其余用密码。</summary>
    private async Task<string> ResolveCredentialAsync(
        Account account, string secret, bool forceRefresh, CancellationToken ct)
    {
        return account.AuthType != AuthType.OAuth2
            ? secret
            : await _oauth2.GetAccessTokenAsync(account, forceRefresh, ct);
    }

    private static Task AuthenticateAsync(ImapClient client, Account account, string credential, CancellationToken ct)
    {
        return account.AuthType == AuthType.OAuth2
            ? client.AuthenticateAsync(new SaslMechanismOAuth2(account.Username, credential), ct)
            : client.AuthenticateAsync(account.Username, credential, ct);
    }
}