/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at
 * docs/licenses/cddl.txt
 * or http://www.opensource.org/licenses/cddl1.php.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at
 * docs/licenses/cddl.txt.  If applicable,
 * add the following below this CDDL HEADER, with the fields enclosed
 * by brackets "[]" replaced with your own identifying information:
 *      Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 *
 *
 *      Copyright 2021 Ping Identity Corporation
 */
package com.unboundid.directory.sdk.ds.types;



import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;

import com.unboundid.util.Mutable;
import com.unboundid.util.NotNull;
import com.unboundid.util.Nullable;
import com.unboundid.util.ThreadSafety;
import com.unboundid.util.ThreadSafetyLevel;
import com.unboundid.util.Validator;



/**
 * This class provides a data structure that holds information about the result
 * of an attempt to pass through authentication to an external service.
 */
@Mutable()
@ThreadSafety(level=ThreadSafetyLevel.NOT_THREADSAFE)
public final class PassThroughAuthenticationResult
{
  // A set of custom log elements that should be included in the server's access
  // log message for the bind operation.
  @NotNull private final Map<String,Object> customLogElements;

  // A result code that provides a general classification for the result of the
  // pass-through authentication attempt.
  @NotNull private final PassThroughAuthenticationResultCode resultCode;

  // A diagnostic message that should be included in the response to the client
  // (and also included in the server's access log message).
  @Nullable private String diagnosticMessageForClient;

  // An identifier for the user's account in the external service.
  @Nullable private String remoteUserIdentifier;



  /**
   * Creates a new pass-through authentication result with the provided
   * result code.
   *
   * @param  resultCode  A result code that provides a general classification
   *                     for the result of the pass-through authentication
   *                     attempt.  It must not be {@code null}.
   */
  public PassThroughAuthenticationResult(
              @NotNull final PassThroughAuthenticationResultCode resultCode)
  {
    Validator.ensureNotNullWithMessage(resultCode,
         "PassThroughAuthenticationResult.resultCode must not be null.");

    this.resultCode = resultCode;

    customLogElements = new LinkedHashMap<>();
    diagnosticMessageForClient = null;
    remoteUserIdentifier = null;
  }



  /**
   * Retrieves a result code that provides a general classification for the
   * result of the pass-through authentication attempt.
   *
   * @return  A result code that provides a general classification for the
   *          result of the pass-through authentication attempt.
   */
  @NotNull()
  public PassThroughAuthenticationResultCode getResultCode()
  {
    return resultCode;
  }



  /**
   * Retrieves an identifier for the user's account in the external service.
   *
   * @return  An identifier for the user's account in the external service, or
   *          {@code null} if the user could not be identified or no identifier
   *          is available.
   */
  @Nullable()
  public String getRemoteUserIdentifier()
  {
    return remoteUserIdentifier;
  }



  /**
   * Sets an identifier for the user's account in the external service.
   *
   * @param  remoteUserIdentifier  An identifier for the user's account in the
   *                               external service.  It may be {@code null} if
   *                               the user could not be identified or if no
   *                               identifier is available.
   */
  public void setRemoteUserIdentifier(
                   @Nullable final String remoteUserIdentifier)
  {
    this.remoteUserIdentifier = remoteUserIdentifier;
  }



  /**
   * Retrieves a diagnostic message that should be included in the response to
   * the client.  If provided, it will also be included in the bind result
   * access log message.
   *
   * @return  A diagnostic message that should be included in the response to
   *          the client, or {@code null} if there should be no client-side
   *          diagnostic message.
   */
  @Nullable()
  public String getDiagnosticMessageForClient()
  {
    return diagnosticMessageForClient;
  }



  /**
   * Sets a diagnostic message that should be included in the response to the
   * client.  If provided, it will also be included in the bind result access
   * log message.
   *
   * @param  diagnosticMessageForClient  A diagnostic message that should be
   *                                     included in the response to the client.
   *                                     It may be {@code null} if no client
   *                                     diagnostic message should be used.
   */
  public void setDiagnosticMessageForClient(
                   @Nullable final String diagnosticMessageForClient)
  {
    this.diagnosticMessageForClient = diagnosticMessageForClient;
  }



  /**
   * Retrieves a map containing name-value pairs for custom elements that should
   * be included in the bind result access log message.
   *
   * @return  A map containing name-value pairs for custom elements that should
   *          be included in the bind result access log message.  It will not be
   *          {@code null} but may be empty.
   */
  @NotNull()
  public Map<String,Object> getCustomLogElements()
  {
    return customLogElements;
  }



  /**
   * Sets a custom name-value pair that should be included in the bind result
   * access log message.
   *
   * @param  name   The name for the log element.  It must not be {@code null}.
   * @param  value  The value for the log element.  It may be {@code null} if
   *                any existing log element with the provided name should be
   *                removed.
   */
  public void setCustomLogElement(@NotNull final String name,
                                  @Nullable final Object value)
  {
    if (value == null)
    {
      customLogElements.remove(name);
    }
    else
    {
      customLogElements.put(name, value);
    }
  }



  /**
   * Retrieves a string representation of this pass-through authentication
   * result.
   *
   * @return  A string representation of this pass-through authentication
   * result.
   */
  @Override()
  @NotNull()
  public String toString()
  {
    final StringBuilder buffer = new StringBuilder();
    toString(buffer);
    return buffer.toString();
  }



  /**
   * Appends a string representation of this pass-through authentication result
   * to the provided buffer.
   *
   * @param  buffer  The buffer to which the string representation should be
   *                 appended.  It must not be {@code null}.
   */
  public void toString(@NotNull final StringBuilder buffer)
  {
    buffer.append("PassThroughAuthenticationResult(resultCode=");
    buffer.append(resultCode.getName());

    if (remoteUserIdentifier != null)
    {
      buffer.append(", remoteUserIdentifier='");
      buffer.append(remoteUserIdentifier);
      buffer.append('\'');
    }

    if (diagnosticMessageForClient != null)
    {
      buffer.append(", diagnosticMessageForClient='");
      buffer.append(diagnosticMessageForClient);
      buffer.append('\'');
    }

    if (! customLogElements.isEmpty())
    {
      buffer.append(", customLogElements={");

      final Iterator<Map.Entry<String,Object>> iterator =
           customLogElements.entrySet().iterator();
      while (iterator.hasNext())
      {
        final Map.Entry<String,Object> e = iterator.next();
        buffer.append(" '");
        buffer.append(e.getKey());
        buffer.append("'='");
        buffer.append(e.getValue());
        buffer.append('\'');

        if (iterator.hasNext())
        {
          buffer.append(", ");
        }
      }

      buffer.append(" }");
    }

    buffer.append(')');
  }
}