/*
 * 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.ignite.internal.processors.cache;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.StringReader;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Map;
import javax.cache.Cache;
import javax.cache.configuration.Factory;
import javax.cache.integration.CacheLoaderException;
import javax.cache.integration.CacheWriterException;
import org.apache.ignite.IgniteCheckedException;
import org.apache.ignite.IgniteException;
import org.apache.ignite.cache.store.CacheStore;
import org.apache.ignite.cache.store.CacheStoreAdapter;
import org.apache.ignite.cache.store.CacheStoreSession;
import org.apache.ignite.cache.store.CacheStoreSessionListener;
import org.apache.ignite.cache.store.jdbc.CacheJdbcStoreSessionListener;
import org.apache.ignite.configuration.CacheConfiguration;
import org.apache.ignite.internal.util.typedef.internal.U;
import org.apache.ignite.lang.IgniteBiInClosure;
import org.apache.ignite.resources.CacheStoreSessionResource;
import org.h2.jdbcx.JdbcConnectionPool;
import org.h2.tools.RunScript;
import org.h2.tools.Server;

/**
 * {@link TestCacheStoreStrategy} backed by H2 in-memory database.
 */
public class H2CacheStoreStrategy implements TestCacheStoreStrategy {
    /** Pool to get {@link Connection}s from. */
    private final JdbcConnectionPool dataSrc;

    /** */
    private final int port;

    /** Script that creates CACHE table. */
    private static final String CREATE_CACHE_TABLE =
        "create table if not exists CACHE(k binary not null, v binary not null, PRIMARY KEY(k));";

    /** Script that creates STATS table. */
    private static final String CREATE_STATS_TABLES =
        "create table if not exists READS(id bigint auto_increment);\n" +
        "create table if not exists WRITES(id bigint auto_increment);\n" +
        "create table if not exists REMOVES(id bigint auto_increment);";

    /** Script that populates STATS table */
    private static final String POPULATE_STATS_TABLE =
        "delete from READS;\n" +
        "delete from WRITES;\n" +
        "delete from REMOVES;";

    /**
     * @throws IgniteCheckedException If failed.
     */
    public H2CacheStoreStrategy() throws IgniteCheckedException {
        Server srv = null;

        try {
            srv = Server.createTcpServer().start();

            port = srv.getPort();

            dataSrc = H2CacheStoreSessionListenerFactory.createDataSource(port);

            try (Connection conn = connection()) {
                RunScript.execute(conn, new StringReader(CREATE_CACHE_TABLE));
                RunScript.execute(conn, new StringReader(CREATE_STATS_TABLES));
                RunScript.execute(conn, new StringReader(POPULATE_STATS_TABLE));
            }
        }
        catch (SQLException e) {
            throw new IgniteCheckedException("Failed to set up cache store strategy" +
                (srv == null ? "" : ": " + srv.getStatus()), e);
        }
    }

    /** {@inheritDoc} */
    @Override public int getReads() {
        return queryStats("reads");
    }

    /** {@inheritDoc} */
    @Override public int getWrites() {
        return queryStats("writes");
    }

    /** {@inheritDoc} */
    @Override public int getRemoves() {
        return queryStats("removes");
    }

    /**
     * @param tbl Table name.
     * @return Update statistics.
     */
    private int queryStats(String tbl) {
        return querySingleInt("select count(*) from " + tbl, "Failed to query store stats [table=" + tbl + "]");
    }

    /** {@inheritDoc} */
    @Override public int getStoreSize() {
        return querySingleInt("select count(*) from CACHE;", "Failed to query number of rows from CACHE table");
    }

    /** {@inheritDoc} */
    @Override public void resetStore() {
        try (Connection conn = connection()) {
            RunScript.execute(conn, new StringReader("delete from CACHE;"));
            RunScript.execute(conn, new StringReader(POPULATE_STATS_TABLE));
        }
        catch (SQLException e) {
            throw new IgniteException(e);
        }
    }

    /** {@inheritDoc} */
    @Override public void putToStore(Object key, Object val) {
        Connection conn = null;
        try {
            conn = connection();
            H2CacheStore.putToDb(conn, key, val);
        }
        catch (SQLException e) {
            throw new IgniteException(e);
        }
        finally {
            U.closeQuiet(conn);
        }
    }

    /** {@inheritDoc} */
    @Override public void putAllToStore(Map<?, ?> data) {
        Connection conn = null;
        PreparedStatement stmt = null;
        try {
            conn = connection();
            stmt = conn.prepareStatement(H2CacheStore.MERGE);
            for (Map.Entry<?, ?> e : data.entrySet()) {
                stmt.setBinaryStream(1, new ByteArrayInputStream(H2CacheStore.serialize(e.getKey())));
                stmt.setBinaryStream(2, new ByteArrayInputStream(H2CacheStore.serialize(e.getValue())));
                stmt.addBatch();
            }
            stmt.executeBatch();
        }
        catch (SQLException e) {
            throw new IgniteException(e);
        }
        finally {
            U.closeQuiet(stmt);
            U.closeQuiet(conn);
        }
    }

    /** {@inheritDoc} */
    @Override public Object getFromStore(Object key) {
        Connection conn = null;
        try {
            conn = connection();
            return H2CacheStore.getFromDb(conn, key);
        }
        catch (SQLException e) {
            throw new IgniteException(e);
        }
        finally {
            U.closeQuiet(conn);
        }
    }

    /** {@inheritDoc} */
    @Override public void removeFromStore(Object key) {
        Connection conn = null;
        try {
            conn = connection();
            H2CacheStore.removeFromDb(conn, key);
        }
        catch (SQLException e) {
            throw new IgniteException(e);
        }
        finally {
            U.closeQuiet(conn);
        }
    }

    /** {@inheritDoc} */
    @Override public boolean isInStore(Object key) {
        return getFromStore(key) != null;
    }

    /**
     * @return New {@link Connection} from {@link #dataSrc}
     * @throws SQLException if failed
     */
    private Connection connection() throws SQLException {
        return dataSrc.getConnection();
    }

    /**
     * Retrieves single int value from {@link ResultSet} returned by given query.
     *
     * @param qry Query string (fully populated, with params).
     * @param errorMsg Message for {@link IgniteException} to bear in case of failure.
     * @return Requested value
     */
    private int querySingleInt(String qry, String errorMsg) {
        Connection conn = null;
        PreparedStatement stmt = null;
        ResultSet rs = null;
        try {
            conn = connection();
            stmt = conn.prepareStatement(qry);
            rs = stmt.executeQuery();
            if (rs.next())
                return rs.getInt(1);
            else
                throw new IgniteException(errorMsg);
        }
        catch (SQLException e) {
            throw new IgniteException(e);
        }
        finally {
            U.closeQuiet(rs);
            U.closeQuiet(stmt);
            U.closeQuiet(conn);
        }
    }

    /** {@inheritDoc} */
    @Override public void updateCacheConfiguration(CacheConfiguration<Object, Object> cfg) {
        cfg.setCacheStoreSessionListenerFactories(new H2CacheStoreSessionListenerFactory(port));
    }

    /** {@inheritDoc} */
    @Override public Factory<? extends CacheStore<Object, Object>> getStoreFactory() {
        return new H2StoreFactory();
    }

    /** Serializable H2 backed cache store factory. */
    public static class H2StoreFactory implements Factory<CacheStore<Object, Object>> {
        /** {@inheritDoc} */
        @Override public CacheStore<Object, Object> create() {
            return new H2CacheStore();
        }
    }

    /** Serializable {@link Factory} producing H2 backed {@link CacheStoreSessionListener}s. */
    public static class H2CacheStoreSessionListenerFactory implements Factory<CacheStoreSessionListener> {
        /** */
        private int port;

        /**
         * @param port Port.
         */
        public H2CacheStoreSessionListenerFactory(int port) {
            this.port = port;
        }

        /**
         * @return Connection pool
         */
        static JdbcConnectionPool createDataSource(int port) {
            JdbcConnectionPool pool = JdbcConnectionPool.create("jdbc:h2:tcp://localhost:" + port +
                "/mem:TestDb;LOCK_MODE=0", "sa", "");

            pool.setMaxConnections(Integer.getInteger("H2_JDBC_CONNECTIONS", 100));
            return pool;
        }

        /** {@inheritDoc} */
        @Override public CacheStoreSessionListener create() {
            CacheJdbcStoreSessionListener lsnr = new CacheJdbcStoreSessionListener();
            lsnr.setDataSource(createDataSource(port));
            return lsnr;
        }
    }

    /** H2 backed {@link CacheStoreAdapter} implementations */
    public static class H2CacheStore extends CacheStoreAdapter<Object, Object> {
        /** Store session */
        @CacheStoreSessionResource
        private CacheStoreSession ses;

        /** Template for an insert statement */
        private static final String MERGE = "merge into CACHE(k, v) values(?, ?);";

        /** {@inheritDoc} */
        @Override public void loadCache(IgniteBiInClosure<Object, Object> clo, Object... args) {
            Connection conn = ses.attachment();
            assert conn != null;

            Statement stmt = null;
            ResultSet rs = null;
            try {
                stmt = conn.createStatement();
                rs = stmt.executeQuery("select * from CACHE");
                while (rs.next())
                    clo.apply(deserialize(rs.getBytes(1)), deserialize(rs.getBytes(2)));
            }
            catch (SQLException e) {
                throw new IgniteException(e);
            }
            finally {
                U.closeQuiet(rs);
                U.closeQuiet(stmt);
            }
        }

        /** {@inheritDoc} */
        @Override public Object load(Object key) throws CacheLoaderException {
            try {
                Connection conn = ses.attachment();
                Object res = getFromDb(conn, key);
                updateStats("reads");
                return res;
            }
            catch (SQLException e) {
                throw new CacheLoaderException("Failed to load object [key=" + key + ']', e);
            }
        }

        /** {@inheritDoc} */
        @Override public void write(Cache.Entry<?, ?> entry) throws CacheWriterException {
            try {
                Connection conn = ses.attachment();
                putToDb(conn, entry.getKey(), entry.getValue());
                updateStats("writes");
            }
            catch (SQLException e) {
                throw new CacheWriterException("Failed to write object [key=" + entry.getKey() + ", " +
                    "val=" + entry.getValue() + ']', e);
            }
        }

        /** {@inheritDoc} */
        @Override public void delete(Object key) throws CacheWriterException {
            try {
                Connection conn = ses.attachment();
                removeFromDb(conn, key);
                updateStats("removes");
            }
            catch (SQLException e) {
                throw new CacheWriterException("Failed to delete object [key=" + key + ']', e);
            }
        }

        /**
         * Selects from H2 and deserialize from bytes the value pointed by key.
         *
         * @param conn {@link Connection} to use.
         * @param key Key to look for.
         * @return Stored object or null if the key is missing from DB.
         * @throws SQLException If failed.
         */
        static Object getFromDb(Connection conn, Object key) throws SQLException {
            PreparedStatement stmt = null;
            ResultSet rs = null;
            try {
                stmt = conn.prepareStatement("select v from CACHE where k = ?");
                stmt.setBinaryStream(1, new ByteArrayInputStream(H2CacheStore.serialize(key)));
                rs = stmt.executeQuery();
                return rs.next() ? H2CacheStore.deserialize(rs.getBytes(1)) : null;
            }
            finally {
                U.closeQuiet(rs);
                U.closeQuiet(stmt);
            }
        }

        /**
         * Puts key-value pair to H2.
         *
         * @param conn {@link Connection} to use.
         * @param key Key.
         * @param val Value.
         * @throws SQLException If failed.
         */
        static void putToDb(Connection conn, Object key, Object val) throws SQLException {
            PreparedStatement stmt = null;
            try {
                stmt = conn.prepareStatement(H2CacheStore.MERGE);
                stmt.setBinaryStream(1, new ByteArrayInputStream(H2CacheStore.serialize(key)));
                stmt.setBinaryStream(2, new ByteArrayInputStream(H2CacheStore.serialize(val)));
                stmt.executeUpdate();
            }
            finally {
                U.closeQuiet(stmt);
            }
        }

        /**
         * Removes given key and its value from H2.
         *
         * @param conn {@link Connection} to invoke query upon.
         * @param key Key to remove.
         * @throws SQLException if failed.
         */
        static void removeFromDb(Connection conn, Object key) throws SQLException {
            PreparedStatement stmt = null;
            try {
                stmt = conn.prepareStatement("delete from CACHE where k = ?");
                stmt.setBinaryStream(1, new ByteArrayInputStream(H2CacheStore.serialize(key)));
                stmt.executeUpdate();
            }
            finally {
                U.closeQuiet(stmt);
            }
        }

        /**
         * Increments stored stats for given operation.
         *
         * @param tblName Table name
         */
        private void updateStats(String tblName) {
            Connection conn = ses.attachment();
            assert conn != null;
            Statement stmt = null;
            try {
                stmt = conn.createStatement();
                stmt.executeUpdate("insert into " + tblName + " default values");
            }
            catch (SQLException e) {
                throw new IgniteException("Failed to update H2 store usage stats", e);
            }
            finally {
                U.closeQuiet(stmt);
            }
        }

        /**
         * Turns given arbitrary object to byte array.
         *
         * @param obj Object to serialize
         * @return Bytes representation of given object.
         */
        static byte[] serialize(Object obj) {
            try (ByteArrayOutputStream b = new ByteArrayOutputStream()) {
                try (ObjectOutputStream o = new ObjectOutputStream(b)) {
                    o.writeObject(obj);
                }
                return b.toByteArray();
            }
            catch (Exception e) {
                throw new IgniteException("Failed to serialize object to byte array [obj=" + obj, e);
            }
        }

        /**
         * Deserializes an object from its byte array representation.
         *
         * @param bytes Byte array representation of the object.
         * @return Deserialized object.
         */
        public static Object deserialize(byte[] bytes) {
            try (ByteArrayInputStream b = new ByteArrayInputStream(bytes)) {
                try (ObjectInputStream o = new ObjectInputStream(b)) {
                    return o.readObject();
                }
            }
            catch (Exception e) {
                throw new IgniteException("Failed to deserialize object from byte array", e);
            }
        }
    }
}