/*
 * 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 2013-2016 UnboundID Corp.
 */

package com.unboundid.directory.sdk.examples;

import com.unboundid.directory.sdk.broker.api.StoreAdapter;
import com.unboundid.directory.sdk.broker.config.StoreAdapterConfig;
import com.unboundid.directory.sdk.broker.types.IdentityBrokerContext;
import com.unboundid.directory.sdk.broker.types.StoreCreateRequest;
import com.unboundid.directory.sdk.broker.types.StoreDeleteRequest;
import com.unboundid.directory.sdk.broker.types.StoreSearchRequest;
import com.unboundid.directory.sdk.broker.types.StoreUpdateRequest;
import com.unboundid.directory.sdk.common.types.LogSeverity;
import com.unboundid.ldap.sdk.LDAPException;
import com.unboundid.scim.data.AttributeValueResolver;
import com.unboundid.scim.data.BaseResource;
import com.unboundid.scim.data.Meta;
import com.unboundid.scim.marshal.json.JsonMarshaller;
import com.unboundid.scim.marshal.json.JsonUnmarshaller;
import com.unboundid.scim.schema.ResourceDescriptor;
import com.unboundid.scim.sdk.AttributePath;
import com.unboundid.scim.sdk.Diff;
import com.unboundid.scim.sdk.InvalidResourceException;
import com.unboundid.scim.sdk.PageParameters;
import com.unboundid.scim.sdk.ResourceNotFoundException;
import com.unboundid.scim.sdk.Resources;
import com.unboundid.scim.sdk.SCIMException;
import com.unboundid.scim.sdk.SCIMFilter;
import com.unboundid.scim.sdk.SCIMFilterType;
import com.unboundid.scim.sdk.SCIMObject;
import com.unboundid.scim.sdk.SCIMQueryAttributes;
import com.unboundid.scim.sdk.ServerErrorException;
import com.unboundid.util.StaticUtils;
import com.unboundid.util.Validator;
import com.unboundid.util.args.ArgumentException;
import com.unboundid.util.args.ArgumentParser;
import com.unboundid.util.args.FileArgument;
import com.unboundid.util.args.StringArgument;
import org.json.JSONException;
import org.json.JSONObject;

import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.Closeable;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.net.URI;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;
import java.util.UUID;

import static com.unboundid.scim.sdk.SCIMConstants.SCHEMA_URI_CORE;
import static com.unboundid.scim.data.BaseResource.BASE_RESOURCE_FACTORY;
import static com.unboundid.scim.schema.CoreSchema.USER_DESCRIPTOR;

/**
 * Example implementation of a Dataview StoreAdapter persisting to a Java jdbc
 * RDBMS backing store. This adapter depends on a jdbc driver jar which must be
 * copied into server's lib directory. The defaults in this example work with
 * <a href="http://db.apache.org/derby/releases/release-10.10.1.1.cgi">Apache
 * derby 10.10.1.1</a>
 */
public class ExampleJDBCStoreAdapter extends StoreAdapter
{
  /**
   * The name of the argument that will be used to load the jdbc driver class.
   */
  public static final String ARG_NAME_JDBC_DRIVER = "jdbc-driver-class";

  /**
   * The name of the argument that will be used to specify the jdbc url to the
   * database instance used by this adapter.
   */
  public static final String ARG_NAME_JDBC_URL = "jdbc-url";

  /**
   * The name of the argument that will be used to specify the file name to
   * initialize the database schema used by this adapter.
   */
  public static final String ARG_NAME_INIT_SQL_SCHEMA_FILE =
    "init-sql-schema-path";



  // JDBC driver for the store adapter.
  private String jdbcDriverClass;

  // JDBC url for the store adapter.
  private String jdbcUrl;

  // Connection to JDBC database.
  private Connection connection;

  // Handle to the ServerContext object.
  private IdentityBrokerContext serverContext;

  private static final AttributeValueResolver<String> SINGULAR =
    AttributeValueResolver.STRING_RESOLVER;


  /**
   * {@inheritDoc}
   */
  @Override
  public String getExtensionName()
  {
    return "Simple JDBC Store Adapter";
  }



  /**
   * {@inheritDoc}
   */
  @Override
  public String[] getExtensionDescription()
  {
    return new String[] {
      "Implements a simple Store Adapter for a Broker DataView which is " +
      "persisted in an embeddable JDBC backing store.  This example persists " +
      "user schema to a single table structure in user-defined tablespace."
    };
  }



  /**
   * {@inheritDoc}
   */
  @Override
  public void defineConfigArguments(final ArgumentParser parser)
    throws ArgumentException
  {
    StringArgument jdbcDriverClassStringArg =
      new StringArgument(null, ARG_NAME_JDBC_DRIVER, true, 1,
        "{jdbc-driver-class}",
        "The JDBC driver class name used by this store adapter.",
        "org.apache.derby.jdbc.EmbeddedDriver");
    parser.addArgument(jdbcDriverClassStringArg);

    StringArgument jdbcUrlStringArg =
      new StringArgument(null, ARG_NAME_JDBC_URL, true, 1, "{jdbc-url}",
        "The JDBC url to the database instance used by this store adapter.",
        "jdbc:derby:storeadapter;create=true");
    parser.addArgument(jdbcUrlStringArg);

    final FileArgument initSqlSchemaFileArg = new FileArgument(null,
      ARG_NAME_INIT_SQL_SCHEMA_FILE, true, 1, "{init-sql-schema-path}",
      "The path to the file containing the create table command used to " +
      "initialize the database.", false, true, true, false, Arrays.asList(
        new File("resource/example-jdbc-store-adapter/create-scim-table.sql")
    ));
    parser.addArgument(initSqlSchemaFileArg);
  }



  /**
   * {@inheritDoc}
   */
  @Override
  public void initializeStoreAdapter(final IdentityBrokerContext serverContext,
                                     final StoreAdapterConfig config,
                                     final ArgumentParser parser)
    throws IOException, LDAPException, SQLException
  {
    this.serverContext = serverContext;

    StringArgument jdbcDriverArgument =
      (StringArgument) parser.getNamedArgument(ARG_NAME_JDBC_DRIVER);
    jdbcDriverClass = jdbcDriverArgument.getValue();
    Validator.ensureNotNull(jdbcDriverClass);

    try
    {
      // Some JDBC drivers require their static and default constructors to be
      // called for the driver to be properly registered with the DriverManager.
      Class.forName(jdbcDriverClass).newInstance();
    }
    catch (Exception e)
    {
      throw new RuntimeException(e);
    }

    StringArgument jdbcUrlArgument =
      (StringArgument) parser.getNamedArgument(ARG_NAME_JDBC_URL);
    jdbcUrl = jdbcUrlArgument.getValue();
    Validator.ensureNotNull(jdbcUrl);

    connection = DriverManager.getConnection(jdbcUrl);

    // check to see if the schema exists
    FileArgument schemaFileArg =
      (FileArgument) parser.getNamedArgument(ARG_NAME_INIT_SQL_SCHEMA_FILE);
    File sqlSchemaFile = schemaFileArg.getValue();
    if(!sqlSchemaFile.isAbsolute())
    {
      sqlSchemaFile = new File(serverContext.getServerRoot(),
        sqlSchemaFile.getPath());
    }
    File schemaCreatedFlag = new File(sqlSchemaFile.getParentFile(),
      ".example-jdbc-schema-created");
    if (!schemaCreatedFlag.exists())
    {
      BufferedReader reader = new BufferedReader(new FileReader(sqlSchemaFile));
      StringBuffer buffer = new StringBuffer();
      String line;
      while ((line = reader.readLine()) != null)
      {
        if (line.trim().startsWith("--"))
        {
          continue;
        }
        buffer.append(line);
      }
      Statement createSql = connection.createStatement();
      createSql.execute(buffer.toString());
      schemaCreatedFlag.createNewFile();
    }
  }


  /**
   * {@inheritDoc}
   */
  @Override
  public boolean isAvailable()
  {
    if (connection != null && serverContext != null)
    {
      try
      {
        return connection.isValid(10);
      }
      catch (SQLException e)
      {
        serverContext.logMessage(LogSeverity.SEVERE_ERROR,
                "Cannot connect to database: " + e.getMessage());
        return false;
      }
    }
    else
    {
      return false;
    }
  }



  /**
   * {@inheritDoc}
   */
  @Override
  public ResourceDescriptor getNativeSchema()
  {
    return USER_DESCRIPTOR;
  }



  /**
   * {@inheritDoc}
   */
  @Override
  public Resources<? extends BaseResource> search(
    final StoreSearchRequest request) throws SCIMException
  {
    final SCIMFilter filter = request.getSCIMFilter();

    final AttributePath idAttrPath =
      new AttributePath(SCHEMA_URI_CORE, "id", null);

    try
    {
      if (filter != null &&
        filter.getFilterType().equals(SCIMFilterType.EQUALITY) &&
        filter.getFilterAttribute().toString().equals(idAttrPath.toString()))
      {
        //This is a search by SCIM ID
        ResultSet resultSet = queryScimResourceById(filter.getFilterValue(),
          true);
        if (resultSet.next())
        {
          BaseResource resource = loadScimResourceFromResultSet(resultSet);
          removeSensitiveAttributes(resource.getScimObject());
          return new Resources<BaseResource>(
            Collections.singletonList(resource));
        }
        else
        {
          return new Resources<BaseResource>(
            Collections.<BaseResource>emptyList());
        }
      }
      else
      {
        final PageParameters pageParams = request.getPageParameters();
        final List<BaseResource> resultList = new LinkedList<BaseResource>();

        int index = 0;
        Statement statement = connection.createStatement();
        ResultSet resultSet = statement.executeQuery(ScimSqlStatement.SELECT_ALL
          .getStatement());
        while (resultSet.next())
        {
          BaseResource resource = loadScimResourceFromResultSet(resultSet);
          if (filter == null || resource.getScimObject().matchesFilter(filter))
          {
            index++;
            if (pageParams != null && pageParams.getStartIndex() > index)
            {
              continue;
            }

            if (pageParams != null && index > pageParams.getCount())
            {
              break;
            }

            resultList.add(createParedResource(resource.getScimObject(),
              request.getSCIMQueryAttributes()));
          }
        }
        return new Resources<BaseResource>(resultList);
      }
    }
    catch (final SQLException se)
    {
      serverContext.debugCaught(se);
      throw new ServerErrorException(StaticUtils.getExceptionMessage(se));
    }
  }



  /**
   * {@inheritDoc}
   */
  @Override
  public BaseResource create(final StoreCreateRequest request)
    throws SCIMException
  {
    try
    {
      //Populate the SCIM 'id' and 'meta' attributes
      final BaseResource resourceToCreate = request.getResource();
      resourceToCreate.setId(UUID.randomUUID().toString());
      final URI location = URI.create("/" + resourceToCreate.getId());
      final Meta meta = new Meta(new Date(), null, location, null);
      resourceToCreate.setMeta(meta);

      List<String> parameters = getParametersFromResource(resourceToCreate);
      PreparedStatement preparedStatement = ScimSqlStatement.INSERT
        .getPreparedStatement(connection, parameters
          .toArray(new String[parameters.size()]));
      preparedStatement.executeUpdate();


      return createParedResource(resourceToCreate.getScimObject(),
        request.getSCIMQueryAttributes());
    }
    catch (final Exception e)
    {
      serverContext.debugCaught(e);
      throw new ServerErrorException(StaticUtils.getExceptionMessage(e));
    }
  }



  /**
   * {@inheritDoc}
   */
  @Override
  public BaseResource update(final StoreUpdateRequest request)
    throws SCIMException
  {
    checkIfIdExists(request.getId());

    try
    {
      BaseResource resource = loadScimResourceById(request.getId());

      final Diff<BaseResource> diff = Diff.fromPartialResource(
                    request.getPartialResource(), false);

      //Apply the PATCH modifications to the resource
      BaseResource resourceToUpdate = diff.apply(resource,
        BASE_RESOURCE_FACTORY);

      //Update the 'meta.lastModified' attribute
      final Meta meta = resource.getMeta();
      meta.setLastModified(new Date());
      resource.setMeta(meta);

      Validator.ensureNotNull(resourceToUpdate);
      final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
      try
      {
        new JsonMarshaller().marshal(resourceToUpdate, outputStream);
        List<String> parameters = getParametersFromResource(resource);
        parameters.remove(0);
        parameters.add(resourceToUpdate.getId());
        PreparedStatement preparedStatement = ScimSqlStatement.UPDATE
          .getPreparedStatement(connection, parameters.toArray(
            new String[parameters.size()]));
        preparedStatement.executeUpdate();
      }
      finally
      {
        safeCloseStream(outputStream);
      }

      return createParedResource(resourceToUpdate.getScimObject(),
        request.getSCIMQueryAttributes());
    }
    catch (final Exception e)
    {
      serverContext.debugCaught(e);
      throw new ServerErrorException(StaticUtils.getExceptionMessage(e));
    }
  }



  /**
   * {@inheritDoc}
   */
  @Override
  public void delete(final StoreDeleteRequest request) throws SCIMException
  {
    checkIfIdExists(request.getId());

    try
    {
      PreparedStatement preparedStatement = ScimSqlStatement.DELETE
        .getPreparedStatement(connection, request.getId());
      preparedStatement.execute();
    }
    catch (final SQLException se)
    {
      serverContext.debugCaught(se);
      throw new ServerErrorException(StaticUtils.getExceptionMessage(se));
    }
  }


  /**
   * Checks to see if a resource exists.
   *
   * @param id to check
   * @throws ResourceNotFoundException if a resource was not found
   */
  private void checkIfIdExists(final String id) throws ResourceNotFoundException
  {
    ResultSet resultSet = queryScimResourceById(id, false);
    try
    {
      if (!resultSet.next())
      {
        throw new ResourceNotFoundException(String.format(
          "No resource found with ID '%s'", id));
      }
    }
    catch (final SQLException se)
    {
      serverContext.debugCaught(se);
      throw new ResourceNotFoundException(StaticUtils.getExceptionMessage(se));
    }
  }


  /**
   * Loads a scim resource by id.
   *
   * @param id to load from the database
   * @return BaseResource from the database
   * @throws ResourceNotFoundException if the resource cannot be found
   * @throws InvalidResourceException if the resource is invalid
   */
  private BaseResource loadScimResourceById(final String id)
    throws ResourceNotFoundException, InvalidResourceException
  {
    ResultSet resultSet = queryScimResourceById(id, true);
    try
    {
      if (!resultSet.next())
      {
        throw new ResourceNotFoundException(String.format(
          "No resource found with ID '%s'", id));
      }
      return loadScimResourceFromResultSet(resultSet);
    }
    catch (final SQLException se)
    {
      serverContext.debugCaught(se);
      throw new ResourceNotFoundException(StaticUtils.getExceptionMessage(se));
    }
  }


  /**
   * Loads a scim resource from the current database ResultSet.
   *
   * @param resultSet to load a resource from
   * @return BaseResource loaded from the ResultSet
   * @throws InvalidResourceException if the resource is invalid
   * @throws SQLException if a problem occurred
   */
  private BaseResource loadScimResourceFromResultSet(final ResultSet resultSet)
    throws InvalidResourceException, SQLException
  {
    final ResourceDescriptor schema = getNativeSchema();
    final JsonUnmarshaller jsonUnmarshaller = new JsonUnmarshaller();
    return jsonUnmarshaller.unmarshal(resultSet.getAsciiStream("json"), schema,
      BASE_RESOURCE_FACTORY);
  }


  /**
   * Queries the database for a scim resource by id.
   *
   * @param id to query in the database
   * @param loadRecord {@code true} to query full record,
   *                   {@code false} otherwise
   * @return ResultSet referencing a found scim resource
   * @throws ResourceNotFoundException if the resource cannot be found
   */
  private ResultSet queryScimResourceById(final String id,
                                          final boolean loadRecord)
    throws ResourceNotFoundException
  {
    try
    {
      Statement statement = connection.createStatement();
      PreparedStatement preparedStatement;
      if (loadRecord)
      {
        preparedStatement = ScimSqlStatement.SELECT_CONTENT
          .getPreparedStatement(connection, id);
      }
      else
      {
        preparedStatement = ScimSqlStatement.SELECT_ID
          .getPreparedStatement(connection, id);
      }
      return preparedStatement.executeQuery();
    }
    catch (final SQLException se)
    {
      serverContext.debugCaught(se);
      throw new ResourceNotFoundException(StaticUtils.getExceptionMessage(se));
    }
  }


  /**
   * Creates a new resource from a scim object with specific attributes.
   *
   * @param scimObject to create a resource from
   * @param attributes to include in the resource
   * @return BaseResource created from the scim object
   */
  private BaseResource createParedResource(final SCIMObject scimObject,
                                           final SCIMQueryAttributes attributes)
  {
    //Pare the returned resource down to the attributes that were requested
    final SCIMObject paredObject = attributes.pareObject(scimObject);
    removeSensitiveAttributes(paredObject);
    final BaseResource newResource = new BaseResource(
      getNativeSchema(), paredObject);

    return newResource;
  }


  /**
   * Removes any sensitive attributes from a scim object.
   *
   * @param scimObject to process
   */
  private void removeSensitiveAttributes(final SCIMObject scimObject)
  {
    scimObject.removeAttribute(SCHEMA_URI_CORE, "password");
  }


  /**
   * Returns a resource as a series of sql parameters.
   *
   * @param resource to parameterize
   * @return resource as parameters
   * @throws SCIMException if problem occurs
   */
  private List<String> getParametersFromResource(final BaseResource resource)
    throws SCIMException
  {
    final List<String> parameters = new ArrayList<String>();
    final JsonMarshaller marshaller = new JsonMarshaller();
    ByteArrayOutputStream outputStream = null;
    try
    {
      parameters.add(resource.getId());
      parameters.add(resource.getExternalId());
      parameters.add(resource.getMeta().toString());
      parameters.add(getSingularAttribute(resource, "userName"));
      parameters.add(getSingularAttribute(resource, "name.formatted"));
      parameters.add(getSingularAttribute(resource, "name.familyName"));
      parameters.add(getSingularAttribute(resource, "name.givenName"));
      parameters.add(getSingularAttribute(resource, "name.middleName"));
      parameters.add(getSingularAttribute(resource, "name.honorificPrefix"));
      parameters.add(getSingularAttribute(resource, "name.honorificSuffix"));
      parameters.add(getSingularAttribute(resource, "displayName"));
      parameters.add(getSingularAttribute(resource, "nickName"));
      parameters.add(getSingularAttribute(resource, "profileUrl"));
      parameters.add(getSingularAttribute(resource, "title"));
      parameters.add(getSingularAttribute(resource, "preferredLanguage"));
      parameters.add(getSingularAttribute(resource, "locale"));
      parameters.add(getSingularAttribute(resource, "timezone"));

      outputStream = new ByteArrayOutputStream();
      marshaller.marshal(resource, outputStream);
      JSONObject jsonObject = null;
      try
      {
        jsonObject = new JSONObject(outputStream.toString());
        parameters.add(getComplexAttribute(resource, jsonObject, "emails"));
        parameters.add(getComplexAttribute(resource, jsonObject, "addresses"));
        parameters.add(getComplexAttribute(resource, jsonObject,
          "phonenumbers"));
        parameters.add(getComplexAttribute(resource, jsonObject, "photos"));
        parameters.add(getComplexAttribute(resource, jsonObject, "groups"));
        parameters.add(getComplexAttribute(resource, jsonObject,
          "entitlements"));
        parameters.add(getComplexAttribute(resource, jsonObject, "roles"));
      }
      catch (final JSONException je)
      {
        throw new RuntimeException(je);
      }
      parameters.add(getSingularAttribute(resource, "website"));
      parameters.add(getSingularAttribute(resource, "gender"));
      parameters.add(outputStream.toString());
    }
    finally
    {
      safeCloseStream(outputStream);
    }
    return parameters;
  }


  /**
   * Retrieves a single attribute from a resource.
   *
   * @param resource to access
   * @param attribute to retrieve
   * @return attribute value
   */
  private String getSingularAttribute(final BaseResource resource,
                                      final String attribute)
  {
    String value = null;
    if (attribute.contains("."))
    {
      AttributePath attributePath = AttributePath.parse(attribute);
      String parentAttributeName = attributePath.getAttributeName();
      SCIMObject object = resource.getScimObject();
      if (object.hasAttribute(SCHEMA_URI_CORE, parentAttributeName))
      {
        String subAttribute = attributePath.getSubAttributeName();
        value = object.getAttribute(SCHEMA_URI_CORE, parentAttributeName)
          .getValue().getSubAttributeValue(subAttribute, SINGULAR);
      }
    }
    else
    {
      value = resource.getSingularAttributeValue(SCHEMA_URI_CORE,
        attribute, SINGULAR);
    }
    return value == null ? "" : value;
  }


  /**
   * Retrieves a complex or multi-value attribute from a resource.
   *
   * @param resource to access
   * @param object resource in json format
   * @param attribute to retrieve
   * @return attribute content in json
   * @throws JSONException if a problem occurs
   */
  private String getComplexAttribute(final BaseResource resource,
                                     final JSONObject object,
                                     final String attribute)
    throws JSONException
  {
    String value = "";
    if (resource.getScimObject().hasAttribute(SCHEMA_URI_CORE, attribute))
    {
      value = object.getJSONObject(attribute).toString();
    }
    return value;
  }


  /**
   * Closes a stream quietly.
   *
   * @param stream to close
   */
  private void safeCloseStream(final Closeable stream)
  {
    if (stream != null)
    {
      try
      {
        stream.close();
      }
      catch (final IOException ioe)
      {  }
    }
  }


  /**
   * Enumerated templates for sql commands. These commands could be moved to
   * resources for customization.
   */
  enum ScimSqlStatement
  {
    /**
     * Insert into scim resources.
     */
    INSERT("insert into %s (id, externalid, meta, username, name, " +
           "familyname, givenname, middlename, honorificprefix, " +
           "honorificsuffix, displayname, nickname, profileurl, title, " +
           "preferredlanguage, locale, timezone, emails, addresses, " +
           "phonenumbers, photos, groups, entitlements, roles, website, " +
           "gender, json) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, " +
           "?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"),
    /**
     * Update scim resource by id.
     */
    UPDATE("update %s set " +
      "externalid = ?, meta = ?, username = ?, name = ?, familyname = ?, " +
      "givenname = ?, middlename = ?, honorificprefix = ?, " +
      "honorificsuffix = ?, displayname = ?, nickname = ?, profileurl = ?, " +
      "title = ?, preferredlanguage = ?, locale = ?, timezone = ?, " +
      "emails = ?, addresses = ?, phonenumbers = ?, photos = ?, groups = ?, " +
      "entitlements = ?, roles = ?, website = ?, gender = ?, json = ? " +
      "where id = ?"),
    /**
     * Delete scim resource by id.
     */
    DELETE("delete from %s where id = ?"),
    /**
     * Select all scim resources.
     */
    SELECT_ALL("select * from %s"),
    /**
     * Load scim resource by id.
     */
    SELECT_CONTENT("select id, json from %s where id = ?"),
    /**
     * Check for scim resource only by id.
     */
    SELECT_ID("select id from %s where id = ?");


    /**
     * Single table containing scim resources. This table is created by the
     * sql statement in config/create-scim-table.sql.
     */
    public static final String TABLE = "SCIM_RESOURCES";

    private final String statement;

    /**
     * enum constructor.
     *
     * @param statement embedded statement
     */
    ScimSqlStatement(final String statement)
    {
      this.statement = statement;
    }

    /**
     * Returns a rendered sql statement.
     *
     * @return String containing the rendered sql statement
     */
    public String getStatement()
    {
      return String.format(statement, TABLE);
    }

    /**
     * Returns a rendered prepared statement from the supplied parameters.
     *
     * @param connection sql connection
     * @param parameters parameters used for substitutions
     * @return PreparedStatement rendered result
     * @throws SQLException if a problem occurs
     */
    public PreparedStatement getPreparedStatement(final Connection connection,
                                                  final String... parameters)
      throws SQLException
    {
      final PreparedStatement preparedStatement =
        connection.prepareStatement(getStatement());
      if (parameters != null)
      {
        int parameterIndex = 1;
        for (final String parameter : parameters)
        {
          preparedStatement.setString(parameterIndex++, parameter);
        }
      }

      return preparedStatement;
    }
  }
}