package com.ca.actions.startup;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;

import javax.sql.DataSource;

import org.apache.log4j.ConsoleAppender;
import org.apache.log4j.Logger;
import org.apache.log4j.PatternLayout;
import org.h2.jdbcx.JdbcConnectionPool;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.teiid.adminapi.impl.ModelMetaData;
import org.teiid.jdbc.TeiidDriver;
import org.teiid.runtime.EmbeddedConfiguration;
import org.teiid.runtime.EmbeddedServer;
import org.teiid.translator.TranslatorException;
import org.teiid.translator.jdbc.h2.H2ExecutionFactory;

public class EmbeddedTest
{

    private static EmbeddedServer    server;

    private static final Logger      logger     = Logger.getLogger(EmbeddedTest.class);
    static
    {
        final PatternLayout layout = new PatternLayout();
        logger.addAppender(new ConsoleAppender(layout));
    }

    private final JdbcConnectionPool dataSource = JdbcConnectionPool.create("jdbc:h2:mem:actions",
                                                                            "sa",
                                                                            "");

    @Before
    public void oneTimeSetUp() throws Exception
    {
        initH2Database();
        final EmbeddedServer.ConnectionFactoryProvider<DataSource> jdbcProvider = new EmbeddedServer.ConnectionFactoryProvider<DataSource>()
        {
            @Override
            public DataSource getConnectionFactory() throws TranslatorException
            {
                return EmbeddedTest.this.dataSource;
            }
        };

        final EmbeddedConfiguration ec = new EmbeddedConfiguration();
        ec.setUserRequestSourceConcurrency(1);
        ec.setUseDisk(true);
        server = new EmbeddedServer();
        server.start(ec);
        server.addConnectionFactoryProvider("source-jdbc", jdbcProvider);
        server.addTranslator(new H2ExecutionFactory());
        buildDeployVDB(server);
    }

    @After
    public void oneTimeTearDown() throws Exception
    {
        server.stop();
    }

    @Test
    public void testH2DataAvailable() throws Exception
    {
        final TeiidDriver td = server.getDriver();
        final Connection c = td.connect("jdbc:teiid:example", null);
        final String sql = "select * from actions.policy_definitions";
        final List<String> results = execute(c, sql, true);
        for (final String string : results)
        {
            logger.debug(string);
        }
    }

    private void initH2Database() throws Exception
    {
        this.dataSource.setMaxConnections(20);
        final EmbeddedServer.ConnectionFactoryProvider<DataSource> jdbcProvider = new EmbeddedServer.ConnectionFactoryProvider<DataSource>()
        {

            @Override
            public DataSource getConnectionFactory() throws TranslatorException
            {
                return EmbeddedTest.this.dataSource;
            }
        };

        final Connection conn = jdbcProvider.getConnectionFactory()
                                            .getConnection();
        final Statement statement = conn.createStatement();

        statement.execute("CREATE SCHEMA IF NOT EXISTS actions");
        statement.execute("CREATE TABLE IF NOT EXISTS actions.POLICY_DEFINITIONS(OBJECT_XML clob)");
        statement.execute("INSERT INTO actions.POLICY_DEFINITIONS(OBJECT_XML) values (' ')");
        statement.close();
        conn.close();
    }

    private static void buildDeployVDB(final EmbeddedServer teiidServer) throws Exception
    {
        final ModelMetaData jdbcModel = new ModelMetaData();
        jdbcModel.setName("actions");
        jdbcModel.setSchemaSourceType("native");
        jdbcModel.addSourceMapping("h2-connector", "h2", "source-jdbc");

        teiidServer.deployVDB("example", jdbcModel);
    }

    private List<String> execute(final Connection connection,
                                 final String sql,
                                 final boolean closeConn) throws Exception
    {
        final List<String> resultStore = new ArrayList<String>();
        try
        {
            final Statement statement = connection.createStatement();
            final boolean hasResults = statement.execute(sql);
            if (hasResults)
            {
                final ResultSet results = statement.getResultSet();
                final ResultSetMetaData metadata = results.getMetaData();
                final int columns = metadata.getColumnCount();
                for (int row = 1; results.next(); row++)
                {
                    final StringBuilder sb = new StringBuilder();
                    sb.append(row + ": ");
                    for (int i = 0; i < columns; i++)
                    {
                        if (i > 0)
                        {
                            sb.append(",");
                        }
                        sb.append(results.getString(i + 1));
                    }
                    resultStore.add(sb.toString());
                }
                results.close();
            }
            statement.close();
        } catch (final SQLException e)
        {
            e.printStackTrace();
        } finally
        {
            if (connection != null && closeConn)
            {
                connection.close();
            }
        }
        return resultStore;
    }
}