package jnpf.dmsBusinessOccupancy;

import com.baomidou.dynamic.datasource.tx.ConnectionFactory;
import com.baomidou.dynamic.datasource.tx.ConnectionProxy;
import com.baomidou.dynamic.datasource.tx.TransactionContext;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.ExecutorType;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.SqlSessionUtils;
import org.mybatis.spring.transaction.SpringManagedTransactionFactory;
import org.springframework.jdbc.datasource.ConnectionHolder;
import org.springframework.jdbc.datasource.DataSourceUtils;
import org.springframework.transaction.support.TransactionSynchronizationManager;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Objects;
import java.util.function.Function;

import static jnpf.dmsBusinessOccupancy.BusinessOccupancyException.Reason.*;

/** Verifies the SAME session connection that executes the mapper; never starts a transaction. */
final class BusinessOccupancyTransactions {
    private final SqlSessionTemplate template;
    private final DataSource dataSource;

    BusinessOccupancyTransactions(SqlSessionTemplate template) {
        this.template = Objects.requireNonNull(template);
        var environment = template.getSqlSessionFactory().getConfiguration().getEnvironment();
        if (!(environment.getTransactionFactory() instanceof SpringManagedTransactionFactory)
                || template.getExecutorType() == ExecutorType.BATCH)
            throw new BusinessOccupancyException(UNSUPPORTED_TRANSACTION);
        this.dataSource = environment.getDataSource();
    }

    BusinessFileOccupancyMapper reader() { return template.getMapper(BusinessFileOccupancyMapper.class); }

    <T> T execute(Function<BusinessFileOccupancyMapper, T> work) {
        String xid = TransactionContext.getXID();
        boolean spring = TransactionSynchronizationManager.isActualTransactionActive();
        if (xid != null && spring) throw new BusinessOccupancyException(UNSUPPORTED_TRANSACTION);
        if (xid == null && !spring) throw new BusinessOccupancyException(TRANSACTION_REQUIRED);
        if (TransactionSynchronizationManager.isCurrentTransactionReadOnly())
            throw new BusinessOccupancyException(READ_ONLY_TRANSACTION);
        // Check BEFORE opening a session: DataSourceUtils can otherwise enlist an unrelated
        // autocommit connection merely for synchronization, without starting a transaction on it.
        Object bound = TransactionSynchronizationManager.getResource(dataSource);
        if (spring && !(bound instanceof ConnectionHolder))
            throw new BusinessOccupancyException(TRANSACTION_CONNECTION_MISMATCH);
        SqlSession session = SqlSessionUtils.getSqlSession(template.getSqlSessionFactory(),
                template.getExecutorType(), template.getPersistenceExceptionTranslator());
        try {
            Connection connection = session.getConnection();
            if (spring) {
                if (!DataSourceUtils.isConnectionTransactional(connection, dataSource))
                    throw new BusinessOccupancyException(TRANSACTION_CONNECTION_MISMATCH);
            } else {
                // A bare XID is not enough. The dynamic transaction must own this exact proxy.
                if (!(connection instanceof ConnectionProxy proxy)
                        || ConnectionFactory.getConnection(xid, proxy.getDs()) != connection)
                    throw new BusinessOccupancyException(TRANSACTION_CONNECTION_MISMATCH);
            }
            if (connection.getAutoCommit()) throw new BusinessOccupancyException(TRANSACTION_CONNECTION_MISMATCH);
            if (connection.isReadOnly()) throw new BusinessOccupancyException(READ_ONLY_TRANSACTION);
            if (connection.getTransactionIsolation() != Connection.TRANSACTION_READ_COMMITTED)
                throw new BusinessOccupancyException(UNSUPPORTED_ISOLATION);
            return work.apply(session.getMapper(BusinessFileOccupancyMapper.class));
        } catch (SQLException e) {
            throw new IllegalStateException("Cannot verify business occupancy transaction connection", e);
        } finally {
            SqlSessionUtils.closeSqlSession(session, template.getSqlSessionFactory());
        }
    }
}