/**
 * MailArchiver is an application that provides services for storing and managing e-mail messages through a Web Services SOAP interface.
 * Copyright (C) 2012  Marcio Andre Scholl Levien and Fernando Alberto Reuter Wendt and Jose Ronaldo Nogueira Fonseca Junior
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program 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 Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

/******************************************************************************\
*
*  This product was developed by
*
*        SERVIÇO FEDERAL DE PROCESSAMENTO DE DADOS (SERPRO),
*
*  a government company established under Brazilian law (5.615/70),
*  at Department of Development of Porto Alegre.
*
\******************************************************************************/

package serpro.mailarchiver.util.jdo;

import java.sql.SQLException;

import javax.jdo.JDOException;
import javax.jdo.Transaction;

import org.datanucleus.TransactionEventListener;
import org.datanucleus.api.jdo.JDOTransaction;

import org.springframework.dao.DataAccessException;
import org.springframework.jdbc.datasource.ConnectionHandle;
import org.springframework.jdbc.support.SQLExceptionTranslator;
import org.springframework.orm.jdo.DefaultJdoDialect;
import org.springframework.transaction.TransactionDefinition;

import serpro.mailarchiver.util.Logger;

/**
 * Dialect for using DataNucleus within Spring's JDO support, giving finer control over transactions and queries.
 */
public class DNJdoDialect extends DefaultJdoDialect {

    private static final Logger log = Logger.getLocalLogger();

    /**
     * Method to start a transaction. Hooks into DataNucleus's configurability for transactions.
     * @param transaction The transaction to start
     * @param definition Definition of the transaction
     * @return The transaction
     */
    @Override
    public Object beginTransaction(final Transaction transaction, final TransactionDefinition definition) {

        ((JDOTransaction)transaction).registerEventListener(new TransactionEventListener() {

            @Override
            public void transactionStarted() {
                System.out.println("transactionStarted: " + definition.getName());
            }

            @Override
            public void transactionEnded() {
                System.out.println("transactionEnded: " + definition.getName());
            }

            @Override
            public void transactionFlushed() {
                System.out.println("transactionFlushed: " + definition.getName());
            }

            @Override
            public void transactionPreCommit() {
                System.out.println("transactionPreCommit: " + definition.getName());
            }

            @Override
            public void transactionPreRollBack() {
                System.out.println("transactionPreRollBack: " + definition.getName());
            }

            @Override
            public void transactionCommitted() {
                System.out.println("transactionCommitted: " + definition.getName());
            }

            @Override
            public void transactionRolledBack() {
                System.out.println("transactionRolledBack: " + definition.getName());
            }
        });

        StringBuilder sb = new StringBuilder();
        sb.append("beginTransaction")
                .append("\n\tname: ").append(definition.getName())
                .append("\n\treadOnly: ").append(definition.isReadOnly())
                .append("\n\tpropagation: ");

        switch(definition.getPropagationBehavior()) {
            case TransactionDefinition.PROPAGATION_REQUIRED:
                sb.append("REQUIRED");
                break;

            case TransactionDefinition.PROPAGATION_SUPPORTS:
                sb.append("SUPPORTS");
                break;

            case TransactionDefinition.PROPAGATION_MANDATORY:
                sb.append("MANDATORY");
                break;

            case TransactionDefinition.PROPAGATION_REQUIRES_NEW:
                sb.append("REQUIRES_NEW");
                break;

            case TransactionDefinition.PROPAGATION_NOT_SUPPORTED:
                sb.append("NOT_SUPPORTED");
                break;

            case TransactionDefinition.PROPAGATION_NEVER:
                sb.append("NEVER");
                break;

            case TransactionDefinition.PROPAGATION_NESTED:
                sb.append("NESTED");
                break;
        }

        sb.append("\n\tisolation: ");

        switch(definition.getIsolationLevel()) {
            case TransactionDefinition.ISOLATION_READ_UNCOMMITTED:
                sb.append("READ_UNCOMMITTED");
                transaction.setIsolationLevel("read-uncommitted");
                break;

            case TransactionDefinition.ISOLATION_READ_COMMITTED:
                sb.append("READ_COMMITTED");
                transaction.setIsolationLevel("read-committed");
                break;

            case TransactionDefinition.ISOLATION_REPEATABLE_READ:
                sb.append("REPEATABLE_READ");
                transaction.setIsolationLevel("repeatable-read");
                break;

            case TransactionDefinition.ISOLATION_SERIALIZABLE:
                sb.append("SERIALIZABLE");
                transaction.setIsolationLevel("serializable");
                break;

            case TransactionDefinition.ISOLATION_DEFAULT:
                sb.append("DEFAULT");
                transaction.setIsolationLevel("read-committed");
                break;
        }

        sb.append("\n\ttimeout: ").append(definition.getTimeout());

        String s = sb.toString();
        log.debug(s);
        System.out.println(s);

        transaction.begin();

        return transaction;
    }

    /**
     * Method to apply a timeout to the specified query.
     * @param query The query
     * @param remainingTimeInSeconds The timeout to apply
     * @throws JDOException Thrown when an error occurs setting the timeout.
     */
    @Override
    public void applyQueryTimeout(javax.jdo.Query query, int remainingTimeInSeconds) {
        System.out.println("applyQueryTimeout");

        query.addExtension("datanucleus.query.timeout", "" + remainingTimeInSeconds);
    }

    @Override
    public void cleanupTransaction(Object transactionData) {
        System.out.println("cleanupTransaction");

//        if(transactionData != null) {
//            JDOTransaction transaction = (JDOTransaction) transactionData;
//        }

        super.cleanupTransaction(transactionData);
    }
}