uEmailService.pas

unit uEmailService;

interface

uses
  SysUtils, Classes, IdSMTP, IdMessage, IdMessageParts, IdText, IdAttachmentFile,
  IdSSLOpenSSL, IdSASL, IdSASLCollection, IdSASLPlain, IdSASLLogin, IdSASLOAuth, IdUserPassProvider,
  IdSASLUserPass, IdLogFile, IdComponent, IdAntiFreeze, Rtti, JSON, IOUtils,
  uOAuthTypes, uOAuthService, {uIdLogMemo,} StdCtrls, IdExplicitTLSClientServerBase,
  TypInfo, Generics.Collections, IdHTTP, IdCoderMIME;

type
  TSecurityType = (stSSL_TLS, stSTARTTLS);
  TSSLVersion = (svSSLv2, svSSLv23, svSSLv3, svTLSv1, svTLSv1_1, svTLSv1_2, svTLSv1_3);

  TEmailConfig = record
    FromEmail: string;
    FromName: string;
    SMTPHost: string;
    SMTPPort: Integer;
    SMTPUser: string;
    SMTPPass: string;
    ToEmail: string;
    ToName: string;
    IMAPHost: string;
    IMAPPort: Integer;
    POPHost: string;
    POPPort: Integer;
    SecurityType: TSecurityType;
    SSLVersion: TSSLVersion;
    OAuthConfig: TOAuthConfig;
    OAuthMethod: TOAuthMethod;
  end;

  TMensagem = record
    Subject: String;
    ContentType: String;
    Body: String;
    Attachments: TArray<string>; // Adicionado para suportar múltiplos anexos
  end;

  TEmailService = class
  private
    FLogMemo: TMemo;
    FOAuthService: TOAuthService;
    FCurrentToken: TOAuthToken;
    procedure ConfigureSSL(ASmtp: TIdSMTP; ASSLIO: TIdSSLIOHandlerSocketOpenSSL; AConfig: TEmailConfig);
    procedure ConfigureAuth(ASmtp: TIdSMTP; AUserPass: TIdUserPassProvider; AConfig: TEmailConfig);
    procedure InternalLog(const ALog: string);
    procedure SMTPStatus(ASender: TObject; const AStatus: TIdStatus; const AStatusText: string);
  public
    constructor Create(AMemo: TMemo);
    destructor Destroy; override;
    function SendEmail(AConfig: TEmailConfig; AMensagem: TMensagem): Boolean;
    procedure SendEmailViaGraphAPI(const AConfig: TEmailConfig; const AToken: TOAuthToken; const AMensagem: TMensagem);
  end;

  function ComponentToJSONObject(AObj: TObject): TJSONObject;

implementation

function ComponentToJSONObject(AObj: TObject): TJSONObject;

  // Função auxiliar interna para gerenciar a recursão e a lista de objetos visitados
  function InternalToJSON(Obj: TObject; VisitedList: TList<TObject>): TJSONValue;
  var
    Context: TRttiContext;
    RttiType: TRttiType;
    Prop: TRttiProperty;
    Val: TValue;
    ChildObj: TObject;
    ChildArray: TJSONArray;
    Collection: TCollection;
    Item: TCollectionItem;
    I: Integer;
  begin
    if not Assigned(Obj) then
      Exit(TJSONNull.Create);

    // Evita loop infinito por referência circular (ex: Owner / Parent)
    if VisitedList.Contains(Obj) then
      Exit(TJSONString.Create('<Circular Reference>'));

    // Registra o objeto atual na lista de visitados
    VisitedList.Add(Obj);
    try
      // Se for uma TCollection (ex: Items de um ListView, colunas, etc.)
      if Obj is TCollection then
      begin
        ChildArray := TJSONArray.Create;
        Collection := TCollection(Obj);
        for I := 0 to Collection.Count - 1 do
        begin
          Item := Collection.Items[I];
          ChildArray.AddElement(InternalToJSON(Item, VisitedList));
        end;
        Exit(ChildArray);
      end;

      // Cria o objeto JSON padrão para instâncias normais
      Result := TJSONObject.Create;
      Context := TRttiContext.Create;
      RttiType := Context.GetType(Obj.ClassType);

      for Prop in RttiType.GetProperties do
      begin
        if not Prop.IsReadable then Continue;

        try
          Val := Prop.GetValue(Obj);

          // 1. Tipos primitivos e simples
          if Prop.PropertyType.TypeKind in [tkInteger, tkChar, tkEnumeration, tkFloat, tkString, tkUString, tkWChar, tkLString, tkInt64] then
          begin
            TJSONObject(Result).AddPair(Prop.Name.Trim, Val.ToString.Trim);
          end

          // 2. Objetos aninhados ou Coleções
          else if Prop.PropertyType.TypeKind = tkClass then
          begin
            if not Val.IsEmpty and (Val.AsObject <> nil) then
            begin
              ChildObj := Val.AsObject;
              // Chama recursivamente e adiciona fazendo o cast correto para TJSONObject
              TJSONObject(Result).AddPair(Prop.Name.Trim, InternalToJSON(ChildObj, VisitedList));
            end
            else
            begin
              TJSONObject(Result).AddPair(Prop.Name.Trim, TJSONNull.Create);
            end;
          end;

        except
          // Ignora propriedades que geram exceção na leitura
        end;
      end;

    finally
      // Remove o objeto da lista ao sair do escopo para permitir instâncias iguais em galhos diferentes
      VisitedList.Remove(Obj);
    end;
  end;

var
  Visited: TList<TObject>;
begin
  Visited := TList<TObject>.Create;
  try
    Result := InternalToJSON(AObj, Visited) as TJSONObject;
    if not Assigned(Result) then
      Result := TJSONObject.Create; // Garante retorno válido caso a raiz seja nula
  finally
    Visited.Free;
  end;
end;

constructor TEmailService.Create(AMemo: TMemo);
begin
  inherited Create;
  FLogMemo := AMemo;
  FOAuthService := TOAuthService.Create;
  FOAuthService.OnLog := InternalLog;
  FOAuthService.OnDeviceCodeRequested := procedure(const AUserCode, AVerificationURI: string)
  begin
    InternalLog(Format('DEVICE CODE: Acesse %s e digite o código: %s', [AVerificationURI.Trim, AUserCode.Trim]));
  end;
end;

destructor TEmailService.Destroy;
begin
  FreeAndNil(FOAuthService);
  inherited;
end;

procedure TEmailService.InternalLog(const ALog: string);
begin
  TThread.Queue(nil, procedure
  begin
    if Assigned(FLogMemo) then
      FLogMemo.Lines.Add(ALog.Trim);
  end);
end;

procedure TEmailService.ConfigureSSL(ASmtp: TIdSMTP; ASSLIO: TIdSSLIOHandlerSocketOpenSSL; AConfig: TEmailConfig);
begin
  // Exemplo conceitual se houvesse stNone
  //if AConfig.SecurityType = stNone then
  //begin
  //  ASmtp.IOHandler := nil; // Ou um TIdIOHandlerStack padrão
  //  ASmtp.UseTLS := utNoTLSSupport;
  //end
  //else
  //begin
  //  // ... (o código restante abaixo)
  //end;

  // 1. PRIMEIRO: Conectar o IOHandler SSL ao SMTP.
  // O Indy precisa saber que o canal suporta SSL antes de aceitar configurações de TLS.
  ASSLIO.SSLOptions.Mode := sslmClient;
  ASSLIO.SSLOptions.SSLVersions := [sslvTLSv1, sslvTLSv1_1, sslvTLSv1_2];
  ASmtp.IOHandler := ASSLIO;

  // 2. SEGUNDO: Definir o modo de conexão (Agora o Indy aceita, pois o IOHandler é SSL)
  if AConfig.SecurityType = stSTARTTLS then
    ASmtp.UseTLS := utUseExplicitTLS
  else
    ASmtp.UseTLS := utUseImplicitTLS;

  // 3. TERCEIRO: Definir a versão do protocolo (TLS 1.2, 1.3, etc.)
  case AConfig.SSLVersion of
    svSSLv2:   ASSLIO.SSLOptions.Method := sslvSSLv2;
    svSSLv23:  ASSLIO.SSLOptions.Method := sslvSSLv23;
    svSSLv3:   ASSLIO.SSLOptions.Method := sslvSSLv3;
    svTLSv1:   ASSLIO.SSLOptions.Method := sslvTLSv1;
    svTLSv1_1: ASSLIO.SSLOptions.Method := sslvTLSv1_1;
    svTLSv1_2: ASSLIO.SSLOptions.Method := sslvTLSv1_2;
    // svTLSv1_3: ASSLIO.SSLOptions.Method := sslvTLSv1_3; // Requer DLLs da OpenSSL 1.1.1+
  end;
end;

procedure TEmailService.ConfigureAuth(ASmtp: TIdSMTP; AUserPass: TIdUserPassProvider; AConfig: TEmailConfig);
var
  LSASL: TIdSASLUserPass;
begin
  ASmtp.SASLMechanisms.Clear;

  // 1. O Provedor Central é a "Fonte da Verdade"
  AUserPass.Username := AConfig.SMTPUser.Trim;

  if AConfig.OAuthMethod = omTraditional then
  begin
    AUserPass.Password := AConfig.SMTPPass.Trim;

    // Mecanismos Tradicionais (O Indy negociará o melhor com o servidor via EHLO)
    LSASL := TIdSASLPlain.Create(ASmtp);
    LSASL.UserPassProvider := AUserPass;
    ASmtp.SASLMechanisms.Add.SASL := LSASL;

    // Opcional: Adicionar Login para compatibilidade com servidores mais antigos
    LSASL := TIdSASLLogin.Create(ASmtp);
    LSASL.UserPassProvider := AUserPass;
    ASmtp.SASLMechanisms.Add.SASL := LSASL;
  end
  else
  begin
    // 2. A Sacada de Mestre: O Token vira a "Senha" no Provedor.
    // O TIdSASLXOAuth2 internamente chama GetPassword, que resolve para o Token!
    AUserPass.Password := FCurrentToken.AccessToken.Trim;

    // Adicionamos APENAS o XOAUTH2 para evitar que o Indy tente usar o Token num login PLAIN/LOGIN
    LSASL := TIdSASLXOAuth2.Create(ASmtp);
    LSASL.UserPassProvider := AUserPass;
    ASmtp.SASLMechanisms.Add.SASL := LSASL;
  end;

  // 3. Força o uso da camada SASL
  ASmtp.AuthType := satSASL;
end;

function TEmailService.SendEmail(AConfig: TEmailConfig; AMensagem: TMensagem): Boolean;
var
  LSMTP: TIdSMTP;
  LMsg: TIdMessage;
  LSSLIO: TIdSSLIOHandlerSocketOpenSSL;
  //LLog: TIdLogMemo;
  LLogFile: TIdLogFile;
  LUserPass: TIdUserPassProvider; // <-- ADICIONADO
  //LAntiFreeze: TIdAntiFreeze;
  LogJSON: TJSONOBject;
  LogPath: string;
  I: Integer;
begin
  Result := False;

  // 1. Obter Token se for OAuth
  if AConfig.OAuthMethod <> omTraditional then
  begin
    InternalLog('Starting OAuth Flow...');
    case AConfig.OAuthMethod of
      omAuthCode: FCurrentToken := FOAuthService.AuthCodeFlow(AConfig.OAuthConfig);
      omAuthCodePKCE: FCurrentToken := FOAuthService.AuthCodePKCEFlow(AConfig.OAuthConfig);
      omDeviceCode: FCurrentToken := FOAuthService.DeviceCodeFlow(AConfig.OAuthConfig);
      omImplicit: FCurrentToken := FOAuthService.ImplicitFlow(AConfig.OAuthConfig);
      omROPC: FCurrentToken := FOAuthService.ROPCFlow(AConfig.OAuthConfig);
      omClientCredentials: FCurrentToken := FOAuthService.ClientCredentialsFlow(AConfig.OAuthConfig);
      omRefreshToken: FCurrentToken := FOAuthService.RefreshTokenFlow(AConfig.OAuthConfig, 'SEU_REFRESH_TOKEN_AQUI');
    end;

    if FCurrentToken.AccessToken = '' then
    begin
      InternalLog('ERRO: Falha ao obter Access Token.');
      Exit;
    end;
    InternalLog('OAuth Token Acquired: ' + FCurrentToken.AccessToken.Trim + '...');

    // =====================================================================
    // BIFURCAÇÃO: Modo Daemon (App-Only) via Microsoft Graph API
    // =====================================================================
    if AConfig.OAuthMethod = omClientCredentials then //E ainda poderia fazer para todos cairem aqui exceto o traditional!
    begin
      InternalLog('Modo App-Only detectado. Desviando para Microsoft Graph API...');
      try
        SendEmailViaGraphAPI(AConfig, FCurrentToken, AMensagem);
        Result := True; // Sucesso
      except
        on E: Exception do
        begin
          InternalLog('ERRO NA GRAPH API: ' + E.Message);
          Result := False;
        end;
      end;
      Exit; // Sai do método, ignorando o bloco SMTP abaixo
    end;
    // =====================================================================
  end;

  // 2. Preparar Componentes Indy
  //If not assigned(LAntiFreeze) then
  //  LAntiFreeze := TIdAntiFreeze.Create(nil); // ADICIONE AQUI

  LSMTP := TIdSMTP.Create(nil);
  LMsg := TIdMessage.Create(nil);
  LSSLIO := TIdSSLIOHandlerSocketOpenSSL.Create(nil);
  //LLog := TIdLogMemo.Create(FLogMemo);

  // Cria o Log em Arquivo
  LLogFile := TIdLogFile.Create(nil);
  LLogFile.Filename := ExtractFilePath(ParamStr(0)).Trim + 'smtp_debug.txt';
  LLogFile.ReplaceCRLF := True; // Formata CRLF para ficar legível
  LLogFile.Active := True;

  // O Provider é criado tendo o SMTP como Owner.
  // Quando o SMTP for destruído, o Provider e os mecanismos SASL vão junto.
  LUserPass := TIdUserPassProvider.Create(LSMTP);
  try
    // Configurações de Conexão e SSL
    LSMTP.Host := AConfig.SMTPHost.Trim;
    LSMTP.Port := AConfig.SMTPPort;
    LSMTP.Username := AConfig.SMTPUser.Trim;
    //LSMTP.Intercept := LLogFile;
    ConfigureSSL(LSMTP, LSSLIO, AConfig);

    LSSLIO.Intercept := LLogFile;

    // Injeção de dependência do Provider na configuração de Auth
    ConfigureAuth(LSMTP, LUserPass, AConfig);

    // Também podemos adicionar eventos de status para logs mais detalhados
    LSMTP.OnStatus := SMTPStatus;

    // Configurações da Mensagem
    LMsg.From.Address := AConfig.FromEmail.Trim;
    LMsg.From.Name := AConfig.FromName.Trim;
    LMsg.Recipients.Add.Address := AConfig.ToEmail.Trim;
    LMsg.Recipients.Add.Name := AConfig.ToName.Trim;
    LMsg.Recipients.Add.User := AConfig.SMTPUser.Trim;
    LMsg.Recipients.EmailAddresses := AConfig.ToEmail.Trim;
    LMsg.Subject := 'E-mail de Teste via Delphi + Indy ' + AMensagem.Subject.Trim;
    //LMsg.ContentType := 'text/plain; charset=utf-8';
    LMsg.ContentType := AMensagem.ContentType.Trim;
    LMsg.Body.Text := 'Este é um e-mail de teste disparado por uma arquitetura desacoplada usando Indy.' + #13#10#13#10 +
                      'Mensagem: ' +  AMensagem.Body.Trim + #13#10#13#10 +
                      'Autenticação: ' + GetEnumName(TypeInfo(TOAuthMethod), Integer(AConfig.OAuthMethod));

    // --- BLOCO DE ANEXOS (SMTP) ---
    if Length(AMensagem.Attachments) > 0 then
    begin
      // 1. Muda o tipo da mensagem para suportar múltiplas partes
      LMsg.ContentType := 'multipart/mixed; charset=utf-8';

      // 2. O corpo do e-mail vira uma parte de texto (TIdText)
      with TIdText.Create(LMsg.MessageParts, nil) do
      begin
        ContentType := AMensagem.ContentType.Trim;
        Body.Text := LMsg.Body.Text;
      end;
      LMsg.Body.Clear; // Limpa o body principal para não duplicar no envio

      // 3. Adiciona os anexos
      for I := 0 to High(AMensagem.Attachments) do
      begin
        if FileExists(AMensagem.Attachments[I]) then
          TIdAttachmentFile.Create(LMsg.MessageParts, AMensagem.Attachments[I]);
      end;
    end;

    // Envio
    //LAntiFreeze.IdleTimeOut := 50;
    //LAntiFreeze.OnlyWhenIdle := False;
    //LogJSON := ComponentToJSONObject(LSMTP);
    //LogPath := TPath.Combine(ExtractFilePath(ParamStr(0)).Trim, 'LSMTP_JSON.json').Trim;
    //TFile.WriteAllText(LogPath.Trim, LogJSON.ToJSON.Trim, TEncoding.UTF8);
    LSMTP.Connect;
    try
      LogJSON := ComponentToJSONObject(LSMTP);
      LogPath := TPath.Combine(ExtractFilePath(ParamStr(0)).Trim, 'LSMTP_JSON.json').Trim;
      TFile.WriteAllText(LogPath.Trim, LogJSON.ToJSON.Trim, TEncoding.UTF8);
      LSMTP.Authenticate;
      LSMTP.Send(LMsg);
      Result := True;
      InternalLog('E-mail enviado com sucesso!');
    finally
      //LAntiFreeze.IdleTimeOut := 50;
      //LAntiFreeze.OnlyWhenIdle := False;
      LSMTP.Disconnect;
    end;
  finally
    FreeAndNIL(LLogFile);
    FreeAndNIL(LSSLIO);
    FreeAndNIL(LMsg);
    FreeAndNIL(LSMTP);
    FreeAndNIL(LogJSON);
    //FreeAndNIL(LAntiFreeze);
  end;
end;

procedure TEmailService.SendEmailViaGraphAPI(const AConfig: TEmailConfig; const AToken: TOAuthToken; const AMensagem: TMensagem);
var
  LHTTP: TIdHTTP;
  LSSL: TIdSSLIOHandlerSocketOpenSSL;
  LBody: TStringStream;
  LJsonRoot, LMessage, LBodyObj, LFromObj, LFromEmailObj, LRecipient, LAddress, LogJSON, LAttachObj: TJSONObject;
  LToArr, LAttachmentsArr: TJSONArray;
  LEndpoint, LogPath, LFile, LBase64: string;
  LStream: TFileStream;
  LEncoder: TIdEncoderMIME;
  I: Integer;
begin
  LHTTP := TIdHTTP.Create(nil);
  LSSL := TIdSSLIOHandlerSocketOpenSSL.Create(LHTTP);

  //Tratamento de Erros na Graph API: Se o token expirar, faltar permissão ou a mailbox estiver bloqueada, a Graph API retorna um JSON com o erro detalhado (diferente do SMTP que cospe exceção de socket genérica). Você pode capturar o EIdHTTPProtocolException e ler o ErrorMessage para exibir o motivo real para o seu usuário.
  //Anexos: Para enviar anexos pela Graph API, basta adicionar uma TJSONArray chamada attachments no JSON do message, contendo os arquivos codificados em Base64 (com a propriedade "@odata.type": "#microsoft.graph.fileAttachment").
  //Envio em Massa: A Graph API tem um limite de rateamento (throttling). Se no futuro você for disparar milhares de e-mails de uma vez, considere usar o endpoint de Batch da Graph (POST https://graph.microsoft.com/v1.0/$batch) para agrupar até 20 envios em uma única requisição HTTP.

  try
    // Configuração SSL para a chamada HTTPS à Microsoft
    LSSL.SSLOptions.SSLVersions := [sslvTLSv1_1, sslvTLSv1_2];
    LSSL.SSLOptions.Mode := sslmClient;
    LHTTP.IOHandler := LSSL;
    LHTTP.HandleRedirects := True;
    LHTTP.Request.UserAgent := 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)';

    // 1. Injeta o Token Bearer no Header
    LHTTP.Request.CustomHeaders.AddValue('Authorization', 'Bearer ' + AToken.AccessToken.Trim);
    LHTTP.Request.ContentType := 'application/json; charset=utf-8';

    // 2. Monta o Payload JSON de forma segura e hierárquica
    LJsonRoot := TJSONObject.Create;
    try
      LMessage := TJSONObject.Create;
      LMessage.AddPair('subject', 'E-mail de Teste via Graph API + Delphi '+AMensagem.Subject.Trim);

      // Corpo do E-mail
      LBodyObj := TJSONObject.Create;
      LBodyObj.AddPair('contentType', 'Text'); // Use 'HTML' se o corpo tiver tags
      LBodyObj.AddPair('content', 'Este é um e-mail de teste disparado por um Daemon App (Client Credentials) usando a Microsoft Graph API.' + #13#10#13#10 +
                                  'Mensagem: ' + AMensagem.Body.Trim + #13#10#13#10 +
                                  'A autenticação App-Only foi bem sucedida!');
      LMessage.AddPair('body', LBodyObj);

      // Remetente (From)
      LFromEmailObj := TJSONObject.Create;
      LFromEmailObj.AddPair('address', AConfig.FromEmail.Trim);
      LFromEmailObj.AddPair('name', AConfig.FromName.Trim);

      LFromObj := TJSONObject.Create;
      LFromObj.AddPair('emailAddress', LFromEmailObj);
      LMessage.AddPair('from', LFromObj);

      // Destinatário (To)
      LAddress := TJSONObject.Create;
      LAddress.AddPair('address', AConfig.ToEmail.Trim);
      LAddress.AddPair('name', AConfig.ToName.Trim);

      LRecipient := TJSONObject.Create;
      LRecipient.AddPair('emailAddress', LAddress);

      LToArr := TJSONArray.Create;
      LToArr.AddElement(LRecipient);
      LMessage.AddPair('toRecipients', LToArr);

      // --- BLOCO DE ANEXOS (GRAPH API) ---
      if Length(AMensagem.Attachments) > 0 then
      begin
        LAttachmentsArr := TJSONArray.Create;
        for I := 0 to High(AMensagem.Attachments) do
        begin
          LFile := AMensagem.Attachments[I];
          if FileExists(LFile) then
          begin
            LAttachObj := TJSONObject.Create;
            LAttachObj.AddPair('@odata.type', '#microsoft.graph.fileAttachment');
            LAttachObj.AddPair('name', ExtractFileName(LFile));
            LAttachObj.AddPair('contentType', 'application/octet-stream'); // Padrão genérico

            // Lê o arquivo e converte para Base64
            LStream := TFileStream.Create(LFile, fmOpenRead or fmShareDenyWrite);
            try
              LEncoder := TIdEncoderMIME.Create(nil);
              try
                // Remove quebras de linha para garantir compatibilidade total com o JSON da Microsoft
                LBase64 := StringReplace(LEncoder.Encode(LStream), #13#10, '', [rfReplaceAll]);
              finally
                LEncoder.Free;
              end;
            finally
              LStream.Free;
            end;

            LAttachObj.AddPair('contentBytes', LBase64);
            LAttachmentsArr.AddElement(LAttachObj);
          end;
        end;
        LMessage.AddPair('attachments', LAttachmentsArr);
      end;

      // Monta a raiz
      LJsonRoot.AddPair('message', LMessage);
      LJsonRoot.AddPair('saveToSentItems', 'true'); // Salva na pasta "Itens Enviados"

      // 3. Executa o POST
      // A URL da Graph API exige o User Principal Name (e-mail da mailbox autorizada)
      //LEndpoint := Format('https://graph.microsoft.com/v1.0/users/%s/sendMail', [AConfig.FromEmail.Trim]);

      // Escolhe a URL correta: Delegado (/me) ou App-Only (/users/{email})
      if AConfig.OAuthMethod = omClientCredentials then
        LEndpoint := Format('https://graph.microsoft.com/v1.0/users/%s/sendMail', [AConfig.FromEmail.Trim])
      else
        LEndpoint := 'https://graph.microsoft.com/v1.0/me/sendMail';

      InternalLog('Enviando POST para: ' + LEndpoint.Trim);

      LBody := TStringStream.Create(LJsonRoot.ToJSON.Trim, TEncoding.UTF8);
      try
        LogJSON := ComponentToJSONObject(LBody);
        LogPath := TPath.Combine(ExtractFilePath(ParamStr(0)).Trim, 'IDHTTP_JSON.json').Trim;
        TFile.WriteAllText(LogPath.Trim, LogJSON.ToJSON.Trim, TEncoding.UTF8);
        LHTTP.Post(LEndpoint, LBody);

        // A Graph API retorna 202 Accepted quando o e-mail é enfileirado com sucesso
        if LHTTP.ResponseCode in [200,201,202] then
          InternalLog('SUCESSO: E-mail entregue à Microsoft Graph! (Status: ' + IntToStr(LHTTP.ResponseCode).Trim + ')')
        else
          InternalLog('ALERTA: Status HTTP inesperado: ' + IntToStr(LHTTP.ResponseCode).Trim + ' - ' + LHTTP.ResponseText.Trim);

      finally
        LBody.Free;
      end;
    finally
      LJsonRoot.Free;
    end;
  finally
    LHTTP.Free; // O LSSL é destruído automaticamente junto, pois é "Owned" por LHTTP
  end;
end;

procedure TEmailService.SMTPStatus(ASender: TObject; const AStatus: TIdStatus; const AStatusText: string);
begin
  case AStatus of
    hsResolving: InternalLog('Resolvendo DNS...');
    hsConnecting: InternalLog('Conectando ao servidor SMTP...');
    hsConnected: InternalLog('Conectado!');
    hsDisconnecting: InternalLog('Desconectando...');
    hsDisconnected: InternalLog('Desconectado.');
    hsStatusText: InternalLog('Status: ' + AStatusText);
  end;
end;

end.