/*
 *
 * MariaDB Client for Java
 *
 * Copyright (c) 2012-2014 Monty Program Ab.
 * Copyright (c) 2015-2017 MariaDB Ab.
 *
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License as published by the Free
 * Software Foundation; either version 2.1 of the License, or (at your option)
 * any later version.
 *
 * This library is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
 * for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License along
 * with this library; if not, write to Monty Program Ab info@montyprogram.com.
 *
 * This particular MariaDB Client for Java file is work
 * derived from a Drizzle-JDBC. Drizzle-JDBC file which is covered by subject to
 * the following copyright and notice provisions:
 *
 * Copyright (c) 2009-2011, Marcus Eriksson
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 * Redistributions of source code must retain the above copyright notice, this list
 * of conditions and the following disclaimer.
 *
 * Redistributions in binary form must reproduce the above copyright notice, this
 * list of conditions and the following disclaimer in the documentation and/or
 * other materials provided with the distribution.
 *
 * Neither the name of the driver nor the names of its contributors may not be
 * used to endorse or promote products derived from this software without specific
 * prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS  AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
 * OF SUCH DAMAGE.
 *
 */


package org.mariadb.jdbc;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import javax.transaction.xa.XAException;
import javax.transaction.xa.XAResource;
import javax.transaction.xa.Xid;
import org.mariadb.jdbc.internal.util.Utils;

public class MariaXaResource implements XAResource {

  private final MariaDbConnection connection;

  public MariaXaResource(MariaDbConnection connection) {
    this.connection = connection;
  }

  private static String xidToString(Xid xid) {
    return "0x" + Utils.byteArrayToHexString(xid.getGlobalTransactionId())
        + ",0x" + Utils.byteArrayToHexString(xid.getBranchQualifier())
        + "," + xid.getFormatId();
  }

  private static String flagsToString(int flags) {
    switch (flags) {
      case TMJOIN:
        return "JOIN";
      case TMONEPHASE:
        return "ONE PHASE";
      case TMRESUME:
        return "RESUME";
      case TMSUSPEND:
        return "SUSPEND";
      default:
        return "";
    }
  }

  private XAException mapXaException(SQLException sqle) {
    int xaErrorCode;

    switch (sqle.getErrorCode()) {
      case 1397:
        xaErrorCode = XAException.XAER_NOTA;
        break;
      case 1398:
        xaErrorCode = XAException.XAER_INVAL;
        break;
      case 1399:
        xaErrorCode = XAException.XAER_RMFAIL;
        break;
      case 1400:
        xaErrorCode = XAException.XAER_OUTSIDE;
        break;
      case 1401:
        xaErrorCode = XAException.XAER_RMERR;
        break;
      case 1402:
        xaErrorCode = XAException.XA_RBROLLBACK;
        break;
      default:
        xaErrorCode = 0;
        break;
    }
    if (xaErrorCode != 0) {
      return new XAException(xaErrorCode);
    } else {
      return new XAException(sqle.getMessage());
    }
  }

  /**
   * Execute a query.
   *
   * @param command query to run.
   * @throws XAException exception
   */
  private void execute(String command) throws XAException {
    try {
      connection.createStatement().execute(command);
    } catch (SQLException sqle) {
      throw mapXaException(sqle);
    }
  }

  /**
   * Commits the global transaction specified by xid.
   *
   * @param xid      A global transaction identifier
   * @param onePhase If true, the resource manager should use a one-phase commit protocol to commit
   *                 the work done on behalf of xid.
   * @throws XAException exception
   */
  public void commit(Xid xid, boolean onePhase) throws XAException {
    String command = "XA COMMIT " + xidToString(xid);
    if (onePhase) {
      command += " ONE PHASE";
    }
    execute(command);
  }

  /**
   * Ends the work performed on behalf of a transaction branch. The resource manager disassociates
   * the XA resource from the transaction branch specified and lets the transaction complete.
   * <p>If TMSUSPEND is specified in the flags, the transaction branch is temporarily suspended in
   * an incomplete state. The transaction context is in a suspended state and must be resumed via
   * the start method with TMRESUME specified.</p>
   * <p>If TMFAIL is specified, the portion of work has failed. The resource manager may mark the
   * transaction as rollback-only</p>
   * <p>If TMSUCCESS is specified, the portion of work has completed successfully.</p>
   *
   * @param xid   A global transaction identifier that is the same as the identifier used previously
   *              in the start method.
   * @param flags One of TMSUCCESS, TMFAIL, or TMSUSPEND.
   * @throws XAException An error has occurred. (XAException values are XAER_RMERR, XAER_RMFAILED,
   *                     XAER_NOTA, XAER_INVAL, XAER_PROTO, or XA_RB*)
   */
  public void end(Xid xid, int flags) throws XAException {
    if (flags != TMSUCCESS && flags != TMSUSPEND && flags != TMFAIL) {
      throw new XAException(XAException.XAER_INVAL);
    }

    execute("XA END " + xidToString(xid) + " " + flagsToString(flags));
  }

  /**
   * Tells the resource manager to forget about a heuristically completed transaction branch.
   *
   * @param xid A global transaction identifier.
   * @throws XAException An error has occurred. Possible exception values are XAER_RMERR,
   *                     XAER_RMFAIL, XAER_NOTA, XAER_INVAL, or XAER_PROTO.
   */
  public void forget(Xid xid) throws XAException {
    // Not implemented by the server
  }

  /**
   * Obtains the current transaction timeout value set for this XAResource instance. If
   * XAResource.setTransactionTimeout was not used prior to invoking this method, the return value
   * is the default timeout set for the resource manager; otherwise, the value used in the previous
   * setTransactionTimeout call is returned.
   *
   * @return the transaction timeout value in seconds.
   * @throws XAException An error has occurred. Possible exception values are XAER_RMERR and
   *                     XAER_RMFAIL.
   */
  public int getTransactionTimeout() throws XAException {
    // not implemented
    return 0;
  }

  /**
   * This method is called to determine if the resource manager instance represented by the target
   * object is the same as the resource manager instance represented by the parameter xares.
   *
   * @param xaResource An XAResource object whose resource manager instance is to be compared with
   *                   the target object.
   * @return true if it's the same RM instance; otherwise false.
   * @throws XAException An error has occurred. Possible exception values are XAER_RMERR and
   *                     XAER_RMFAIL.
   */
  @Override
  public boolean isSameRM(XAResource xaResource) throws XAException {
    // Typically used by transaction manager to "join" transactions. We do not support joins,
    // so always return false;
    return false;
  }

  /**
   * Ask the resource manager to prepare for a transaction commit of the transaction specified in
   * xid.
   *
   * @param xid A global transaction identifier.
   * @return A value indicating the resource manager's vote on the outcome of the transaction.
   * @throws XAException An error has occurred. Possible exception values are: XA_RB*, XAER_RMERR,
   *                     XAER_RMFAIL, XAER_NOTA, XAER_INVAL, XAER_PROTO.
   */
  public int prepare(Xid xid) throws XAException {
    execute("XA PREPARE " + xidToString(xid));
    return XA_OK;
  }

  /**
   * Obtains a list of prepared transaction branches from a resource manager. The transaction
   * manager calls this method during recovery to obtain the list of transaction branches that are
   * currently in prepared or heuristically completed states.
   *
   * @param flags One of TMSTARTRSCAN, TMENDRSCAN, TMNOFLAGS. TMNOFLAGS must be used when no other
   *              flags are set in the parameter.
   * @return The resource manager returns zero or more XIDs of the transaction branches.
   * @throws XAException An error has occurred. Possible values are XAER_RMERR, XAER_RMFAIL,
   *                     XAER_INVAL, and XAER_PROTO.
   */
  public Xid[] recover(int flags) throws XAException {
    // Return all Xid  at once, when STARTRSCAN is specified
    // Return zero-length array otherwise.

    if (((flags & TMSTARTRSCAN) == 0) && ((flags & TMENDRSCAN) == 0) && (flags != TMNOFLAGS)) {
      throw new XAException(XAException.XAER_INVAL);
    }

    if ((flags & TMSTARTRSCAN) == 0) {
      return new MariaDbXid[0];
    }

    try {
      ResultSet rs = connection.createStatement().executeQuery("XA RECOVER");
      ArrayList<MariaDbXid> xidList = new ArrayList<>();

      while (rs.next()) {
        int formatId = rs.getInt(1);
        int len1 = rs.getInt(2);
        int len2 = rs.getInt(3);
        byte[] arr = rs.getBytes(4);

        byte[] globalTransactionId = new byte[len1];
        byte[] branchQualifier = new byte[len2];
        System.arraycopy(arr, 0, globalTransactionId, 0, len1);
        System.arraycopy(arr, len1, branchQualifier, 0, len2);
        xidList.add(new MariaDbXid(formatId, globalTransactionId, branchQualifier));
      }
      Xid[] xids = new Xid[xidList.size()];
      xidList.toArray(xids);
      return xids;
    } catch (SQLException sqle) {
      throw mapXaException(sqle);
    }
  }

  /**
   * Informs the resource manager to roll back work done on behalf of a transaction branch.
   *
   * @param xid A global transaction identifier.
   * @throws XAException An error has occurred.
   */
  public void rollback(Xid xid) throws XAException {
    execute("XA ROLLBACK " + xidToString(xid));
  }

  /**
   * Sets the current transaction timeout value for this XAResource instance. Once set, this timeout
   * value is effective until setTransactionTimeout is invoked again with a different value. To
   * reset the timeout value to the default value used by the resource manager, set the value to
   * zero. If the timeout operation is performed successfully, the method returns true; otherwise
   * false. If a resource manager does not support explicitly setting the transaction timeout value,
   * this method returns false.
   *
   * @param timeout The transaction timeout value in seconds.
   * @return true if the transaction timeout value is set successfully; otherwise false.
   * @throws XAException An error has occurred. Possible exception values are XAER_RMERR,
   *                     XAER_RMFAIL, or XAER_INVAL.
   */
  public boolean setTransactionTimeout(int timeout) throws XAException {
    return false; // not implemented
  }

  /**
   * Starts work on behalf of a transaction branch specified in xid. If TMJOIN is specified, the
   * start applies to joining a transaction previously seen by the resource manager. If TMRESUME is
   * specified, the start applies to resuming a suspended transaction specified in the parameter
   * xid. If neither TMJOIN nor TMRESUME is specified and the transaction specified by xid has
   * previously been seen by the resource manager, the resource manager throws the XAException
   * exception with XAER_DUPID error code.
   *
   * @param xid   A global transaction identifier to be associated with the resource.
   * @param flags One of TMNOFLAGS, TMJOIN, or TMRESUME.
   * @throws XAException An error has occurred.
   */
  public void start(Xid xid, int flags) throws XAException {
    if (flags != TMJOIN && flags != TMRESUME && flags != TMNOFLAGS) {
      throw new XAException(XAException.XAER_INVAL);
    }
    execute("XA START " + xidToString(xid) + " "
        + flagsToString(
        flags == TMJOIN && connection.getPinGlobalTxToPhysicalConnection() ? TMRESUME : flags));
  }
}
