/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.tinkerpop.gremlin.structure.util;

import org.apache.tinkerpop.gremlin.structure.Graph;
import org.apache.tinkerpop.gremlin.structure.Transaction;

import java.util.function.Consumer;
import java.util.function.Function;

/**
 * A simple base class for {@link Transaction} that provides some common functionality and default behavior.
 * While providers can choose to use this class, it is generally better to extend from
 * {@link AbstractThreadedTransaction} or {@link AbstractThreadLocalTransaction} which include default "listener"
 * functionality.  Implementers should note that this class assumes that threaded transactions are not enabled
 * and should explicitly override {@link #createThreadedTx} to implement that functionality if required.
 *
 * @author Stephen Mallette (http://stephen.genoprime.com)
 */
public abstract class AbstractTransaction implements Transaction {
    private Graph g;

    public AbstractTransaction(final Graph g) {
        this.g = g;
    }

    /**
     * Called within {@link #open} if it is determined that the transaction is not yet open given {@link #isOpen}.
     * Implementers should assume the transaction is not yet started and should thus open one.
     */
    protected abstract void doOpen();

    /**
     * Called with {@link #commit} after the {@link #onReadWrite(Consumer)} has been notified.  Implementers should
     * include their commit logic here.
     */
    protected abstract void doCommit() throws TransactionException;

    /**
     * Called with {@link #rollback} after the {@link #onReadWrite(Consumer)} has been notified.  Implementers should
     * include their rollback logic here.
     */
    protected abstract void doRollback() throws TransactionException;

    /**
     * Called within {@link #commit()} just after the internal call to {@link #doCommit()}. Implementations of this
     * method should raise {@link org.apache.tinkerpop.gremlin.structure.Transaction.Status#COMMIT} events to any
     * listeners added via {@link #addTransactionListener(Consumer)}.
     */
    protected abstract void fireOnCommit();

    /**
     * Called within {@link #rollback()} just after the internal call to {@link #doRollback()} ()}. Implementations
     * of this method should raise {@link org.apache.tinkerpop.gremlin.structure.Transaction.Status#ROLLBACK} events
     * to any listeners added via {@link #addTransactionListener(Consumer)}.
     */
    protected abstract void fireOnRollback();
    
    /**
     * Called {@link #readWrite}.  
     * Implementers should run their readWrite consumer here.
     */
    protected abstract void doReadWrite();
    
    /**
     * Called {@link #close}.  
     * Implementers should run their readWrite consumer here.
     */
    protected abstract void doClose();

    /**
     * {@inheritDoc}
     */
    @Override
    public void open() {
        if (isOpen())
            throw Transaction.Exceptions.transactionAlreadyOpen();
        else
            doOpen();
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void commit() {
        readWrite();
        try {
            doCommit();
            fireOnCommit();
        } catch (TransactionException te) {
            throw new RuntimeException(te);
        }
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void rollback() {
        readWrite();
        try {
            doRollback();
            fireOnRollback();
        } catch (TransactionException te) {
            throw new RuntimeException(te);
        }
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public <R> Workload<R> submit(final Function<Graph, R> work) {
        return new Workload<>(g, work);
    }
    /**
     * {@inheritDoc}
     */
    @Override
    public <G extends Graph> G createThreadedTx() {
        throw Transaction.Exceptions.threadedTransactionsNotSupported();
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void readWrite() {
        doReadWrite();
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void close() {
        doClose();
    }

    /**
     * An "internal" exception thrown by providers when calls to {@link AbstractTransaction#doCommit} or
     * {@link AbstractTransaction#doRollback} fail.
     */
    public static class TransactionException extends Exception {
        public TransactionException(final String message) {
            super(message);
        }

        public TransactionException(final Throwable cause) {
            super(cause);
        }

        public TransactionException(final String message, final Throwable cause) {
            super(message, cause);
        }
    }
}