import com.google.common.base.Function;
import com.google.common.util.concurrent.*;

import javax.annotation.Nullable;
import java.sql.*;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Consumer;

/**
 * @author vRchr
 */
public class SQLClass {
    private final String HOST;
    private final String NAME;
    private final String PASSWORD;
    private final String DATABASE;
    private final ListeningExecutorService THREAD_POOL = MoreExecutors
            .listeningDecorator( Executors.newCachedThreadPool() );
    private Connection connection;

    public SQLClass( String host, String name, String password, String database ) {
        this.HOST = host;
        this.NAME = name;
        this.PASSWORD = password;
        this.DATABASE = database;
    }

    public void connect( ) {
        try {
            //connect to database
            this.connection = DriverManager
                    .getConnection( "jdbc:mysql://" + this.getHOST() + "/" + this.getDATABASE() +
                            "?autoReconnect=true", this.getNAME(), this.getPASSWORD() );
        } catch ( SQLException e ) {
            e.printStackTrace();
        }
    }

    public void disconnect( ) {
        try {
            this.getConnection().close();
        } catch ( SQLException e ) {
            e.printStackTrace();
        }
    }

    /**
     * --CONSUMER--
     **/

    public <T> void queryAsync( final String sql, Function<ResultSet, T> function, Consumer<T> consumer,
                                final Object... parameters ) {
        Futures.addCallback( Futures.transform( this._queryAsync( sql, parameters ), new Function<Tuple<ResultSet,
                        Runnable>, Tuple<T, Runnable>>() {
                    @Nullable
                    @Override
                    public Tuple<T, Runnable> apply( @Nullable Tuple<ResultSet, Runnable> resultSetRunnableTuple ) {
                        return Tuple.of(function.apply( resultSetRunnableTuple.getOne() ), resultSetRunnableTuple.getTwo());
                    }
                } ),
                new FutureCallback<Tuple<T, Runnable>>() {
                    @Override
                    public void onSuccess( Tuple<T, Runnable> result ) {
                        consumer.accept( result.getOne() );
                        result.getTwo().run();
                    }

                    @Override
                    public void onFailure( Throwable t ) {
                        consumer.accept( null );
                    }
                } );
    }

    public void updateAsync( final String sql, Consumer<Boolean> consumer, final Object... parameters ) {
        Futures.addCallback( this.updateAsync( sql, parameters ), new FutureCallback<Boolean>() {
            @Override
            public void onSuccess( Boolean result ) {
                consumer.accept( result );
            }

            @Override
            public void onFailure( Throwable t ) {
                System.out.println( t.getMessage() );
                consumer.accept( null );
            }
        } );
    }


    /**
     * --LISTENING FUTURE--
     **/

    private ListenableFuture<Tuple<ResultSet, Runnable>> _queryAsync( final String sql, final Object... parameters ) {
        return this.getTHREAD_POOL().submit( ( ) -> query( sql, parameters ) );
    }

    private ListenableFuture<ResultSet> queryAsync( final String sql, final Object... parameters ) {
        return this.getTHREAD_POOL().submit( ( ) -> query( sql, parameters ).getOne() );
    }

    private ListenableFuture<Boolean> updateAsync( final String sql, final Object... parameters ) {
        return this.getTHREAD_POOL().submit( ( ) -> update( sql, parameters ) );
    }


    /**
     * --SYNC--
     **/

    private Tuple<ResultSet, Runnable> query( String sql, Object... parameters ) {
        AtomicReference<PreparedStatement> preparedStatement = new AtomicReference<>( null );
        AtomicReference<ResultSet> resultSet = new AtomicReference<>( null );
        try {
            preparedStatement.set( this.getConnection().prepareStatement( sql ) );

            int count = 0;
            for ( Object parameter : parameters ) {
                preparedStatement.get().setObject( count, parameter );
                count++;
            }

            resultSet.set( preparedStatement.get().executeQuery() );

            return Tuple.of( resultSet.get(), ( ) -> {
                try {
                    resultSet.get().close();
                    preparedStatement.get().close();
                } catch ( SQLException e ) {
                    e.printStackTrace();
                }
            } );
        } catch ( SQLException e ) {
            e.printStackTrace();
        }
        return Tuple.of( null, () -> {} );
    }

    private boolean update( String sql, Object... parameters ) {
        PreparedStatement preparedStatement = null;
        try {
            preparedStatement = this.getConnection().prepareStatement( sql );

            int count = 0;
            for ( Object parameter : parameters ) {
                preparedStatement.setObject( count, parameter );
                count++;
            }

            preparedStatement.executeUpdate();

            return true;
        } catch ( SQLException e ) {
            e.printStackTrace();
        } finally {
            try {
                preparedStatement.close();
            } catch ( SQLException e ) {
                e.printStackTrace();
            }
        }
        return false;
    }

    public String getHOST( ) {
        return HOST;
    }

    public String getNAME( ) {
        return NAME;
    }

    public String getPASSWORD( ) {
        return PASSWORD;
    }

    public String getDATABASE( ) {
        return DATABASE;
    }

    public ListeningExecutorService getTHREAD_POOL( ) {
        return THREAD_POOL;
    }

    public Connection getConnection( ) {
        return connection;
    }

    private static final class Tuple<O, T> {
        private O one;
        private T two;

        public Tuple( O one, T two ) {
            this.one = one;
            this.two = two;
        }

        public static <O, T> Tuple<O, T> of( O one, T two ) {
            return new Tuple<>( one, two );
        }

        public O getOne( ) {
            return one;
        }

        public void setOne( O one ) {
            this.one = one;
        }

        public T getTwo( ) {
            return two;
        }

        public void setTwo( T two ) {
            this.two = two;
        }
    }
}