/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package db.providers;

import com.evolute.entity.ProviderInterface;
import com.evolute.entity.ProviderRegistry;
import com.evolute.entity.evo.EvoDataException;
import com.evolute.entity.evo.EvoDataObject;
import com.evolute.entity.evo.EvoDataProvider;
import com.evolute.entity.evo.EvoDataProviderFactory;
import com.evolute.entity.utils.ConnectionIdentity;
import com.evolute.utils.Singleton;
import com.evolute.utils.db.DBException;
import com.evolute.utils.db.DBManager;
import com.evolute.utils.db.Executer;
import com.evolute.utils.db.JDBCManager;
import com.evolute.utils.error.ErrorLogger;
import com.evolute.utils.jdbc.DBStatementExecuter;
import com.evolute.utils.jdbc.StatementExecuterFactory;
import com.evolute.utils.sql.SQLQuery;
import com.evolute.utils.strings.UnicodeChecker;
import db.DBConstants;
import db.DBPropertiesLoader;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import javax.faces.context.ExternalContext;
import javax.faces.context.FacesContext;
import javax.servlet.http.HttpSession;

/**
 *
 * @author dneves
 */
public class EvoBaseProvider
{
	private static EvoBaseProvider INSTANCE = null;

	private ProviderInterface< EvoDataObject< ? >, EvoDataException > providerInterface;
	private DBManager dbManager;

	private ProviderInterface< EvoDataObject< ? >, EvoDataException > localProviderInterface;
	private DBManager localDBManager;

    private String url;
    private String username;
    private String password;

    private String url_local;
    private String username_local;
    private String password_local;



	private EvoBaseProvider() throws DBException
	{
		init();
	}

	public static synchronized EvoBaseProvider getInstance() throws DBException
	{
		if ( INSTANCE == null )
		{
			INSTANCE = new EvoBaseProvider();
		}
		return INSTANCE;
	}

	private void init() throws DBException
	{
//		System.out.println( "EvoBaseProvider . init() : " );

		String server = DBPropertiesLoader.getInstance().findProperty( DBConstants.SERVER_SIPRP );
		int port = DBPropertiesLoader.getInstance().findProperty( DBConstants.PORT_SIPRP, -1 );
		String dbname = DBPropertiesLoader.getInstance().findProperty( DBConstants.DATABASE_SIPRP );
		username = DBPropertiesLoader.getInstance().findProperty( DBConstants.USERNAME_SIPRP );
		password = DBPropertiesLoader.getInstance().findProperty( DBConstants.PASSWORD_SIPRP );

//		System.out.println( "\t" + server + " : " + port + " : " + dbname + " : " + username + " : " + password );

		String server_local = DBPropertiesLoader.getInstance().findProperty( DBConstants.SERVER_SIPRP_LOCAL );
		int port_local = DBPropertiesLoader.getInstance().findProperty( DBConstants.PORT_SIPRP_LOCAL, -1 );
		String dbname_local = DBPropertiesLoader.getInstance().findProperty( DBConstants.DATABASE_SIPRP_LOCAL );
		username_local = DBPropertiesLoader.getInstance().findProperty( DBConstants.USERNAME_SIPRP_LOCAL );
		password_local = DBPropertiesLoader.getInstance().findProperty( DBConstants.PASSWORD_SIPRP_LOCAL );

//		System.out.println( "\t" + server_local + " : " + port_local + " : " + dbname_local + " : " + username_local + " : " + password_local );

		init( DBConstants.DB.SIPRP, server, port, dbname, username, password );
		init( DBConstants.DB.SIPRP_LOCAL, server_local, port_local, dbname_local, username_local, password_local );
	}

	private void init( DBConstants.DB db, String  dbServer, Integer  dbPort, String  dbName, String dbUsername, String dbPassword )
		throws DBException
	{
		String dbUrl = "jdbc:postgresql://" + dbServer + ":" + dbPort + "/" + dbName + "?prepareThreshold=2";
		if ( DBConstants.DB.SIPRP.equals( db ) )
		{
			Singleton.setInstance( DBConstants.CONNECTION_URL, dbUrl );
            url = dbUrl;
		}
		else if ( DBConstants.DB.SIPRP_LOCAL.equals( db ) )
		{
			Singleton.setInstance( DBConstants.LOCAL_CONNECTION_URL, dbUrl );
            url_local = dbUrl;
		}

		createDBManager( db, dbUsername, dbPassword );
		initProviderConnection( db, dbUsername, dbPassword );
	}

	private void createDBManager( DBConstants.DB db, String username, String password )
		throws DBException
	{
		if ( DBConstants.DB.SIPRP.equals( db ) )
		{
			if( dbManager != null )
			{
				dbManager.close();
			}
			String dbUrl = ( String ) Singleton.getInstance( DBConstants.CONNECTION_URL );
			DBManager manager = new JDBCManager( dbUrl, username, password , 14, 7, 7, new SQLQuery[] {  } );
			StatementExecuterFactory.initialize( new DBStatementExecuter( manager.getSharedExecuter( EvoBaseProvider.class ) ) );
			UnicodeChecker.setUseDoubleSlash( true );
//			Insert.setDefaultKeyRetriever( PostgresqlAutoKeyRetriever.RETRIEVER );
			dbManager = manager;
//			Singleton.setInstance( Singleton.DEFAULT_DBMANAGER, dbManager );
//			System.out.println( "\nDBManager : " + dbManager );
		}
		else if ( DBConstants.DB.SIPRP_LOCAL.equals( db ) )
		{
			if( localDBManager != null )
			{
				localDBManager.close();
			}
			String dbUrl = ( String ) Singleton.getInstance( DBConstants.LOCAL_CONNECTION_URL );
			DBManager manager = new JDBCManager( dbUrl, username, password , 14, 7, 7, new SQLQuery[] {  } );
			StatementExecuterFactory.initialize( new DBStatementExecuter( manager.getSharedExecuter( EvoBaseProvider.class ) ) );
			UnicodeChecker.setUseDoubleSlash( true );
//			Insert.setDefaultKeyRetriever( PostgresqlAutoKeyRetriever.RETRIEVER );
			localDBManager = manager;
			Singleton.setInstance( Singleton.DEFAULT_DBMANAGER, localDBManager );
//			System.out.println( "\nLocalDBManager : " + localDBManager );
		}
	}

	private void initProviderConnection( DBConstants.DB db, String username, String password )
	{
		if ( DBConstants.DB.SIPRP.equals( db ) )
		{
			String dbUrl = ( String ) Singleton.getInstance( DBConstants.CONNECTION_URL );
			providerInterface = createInstance( db, dbUrl, username, password );
		}
		else if ( DBConstants.DB.SIPRP_LOCAL.equals( db ) )
		{
			String dbUrl = ( String ) Singleton.getInstance( DBConstants.LOCAL_CONNECTION_URL );
			localProviderInterface = createInstance( db, dbUrl, username, password );
		}
	}

	private static ProviderInterface< EvoDataObject< ? >, EvoDataException > createInstance( DBConstants.DB db, String url, String user, String password )
	{
		ProviderRegistry.registerDefaultProviderFactory( new EvoDataProviderFactory() );
		ConnectionIdentity conn = new ConnectionIdentity( url, user );
		ProviderRegistry.registerDefaultConnection( conn );
		ProviderInterface< EvoDataObject< ? >, EvoDataException > provider =
			( ProviderInterface< EvoDataObject< ? >, EvoDataException > ) ProviderRegistry.getDefaultProvider( conn );
		( ( EvoDataProvider ) provider ).setIsUsingCache( Boolean.FALSE );
		if ( DBConstants.DB.SIPRP.equals( db ) )
		{
			Singleton.setInstance( DBConstants.DEFAULT_PROVIDER, provider );
		}
		else if ( DBConstants.DB.SIPRP_LOCAL.equals( db ) )
		{
			Singleton.setInstance( DBConstants.LOCAL_PROVIDER, provider );
			Singleton.setInstance( Singleton.DEFAULT_EVO_DATA_PROVIDER, provider );
			Singleton.setInstance( Singleton.DEFAULT_OBJECT_PROVIDER, provider );
		}
		conn.setPassword( password );
		return provider;
	}

	public ProviderInterface< EvoDataObject< ? >, EvoDataException > getProvider()
	{
		return getProvider( DBConstants.DB.SIPRP );
	}

	public ProviderInterface< EvoDataObject< ? >, EvoDataException > getProvider( DBConstants.DB db )
	{
		ProviderInterface< EvoDataObject< ? >, EvoDataException > provider = null;

		if ( DBConstants.DB.SIPRP.equals( db ) )
		{
			provider = providerInterface;
		}
		else if ( DBConstants.DB.SIPRP_LOCAL.equals( db ) )
		{
			provider = localProviderInterface;
		}

		return provider;
	}

	public DBManager getDbManager()
	{
		return getDbManager( DBConstants.DB.SIPRP );
	}

	public DBManager getDbManager( DBConstants.DB db )
	{
		DBManager manager = null;
		if ( DBConstants.DB.SIPRP.equals( db ) )
		{
			manager = dbManager;
		}
		else if ( DBConstants.DB.SIPRP_LOCAL.equals( db ) )
		{
			manager = localDBManager;
		}
		return manager;
	}

	public Executer getExecuter() throws DBException
	{
		return getExecuter( this );
	}
	
	private Executer getExecuter( Object clazz ) throws DBException
	{
		if ( getDbManager() == null )
		{
			init();
		}

//		DBManager dbm = ( DBManager ) Singleton.getInstance( DBConstants.DEFAULT_DBMANAGER );
//		return dbm.getSharedExecuter( this );
		
		DBManager dbm = getDbManager( DBConstants.DB.SIPRP );
		if ( dbm != null )
		{
			return dbm.getSharedExecuter( this );
		}
		return null;
	}

	public Executer getLocalExecuter() throws DBException
	{
		return getLocalExecuter( this );
	}

	private Executer getLocalExecuter( Object clazz ) throws DBException
	{
		if ( getDbManager( DBConstants.DB.SIPRP_LOCAL ) == null )
		{
			init();
		}
//		DBManager dbm = ( DBManager ) Singleton.getInstance( DBConstants.LOCAL_DBMANAGER );
//		return dbm.getSharedExecuter( this );

		DBManager dbm = getDbManager( DBConstants.DB.SIPRP_LOCAL );
		if ( dbm != null )
		{
			return dbm.getSharedExecuter( this );
		}
		return null;
	}

	@Deprecated
	public Statement createStatement()
	{
		String connectionURL = ( String ) Singleton.getInstance( DBConstants.CONNECTION_URL );
		String username = DBPropertiesLoader.getInstance().findProperty( DBConstants.USERNAME_SIPRP );
		String password = DBPropertiesLoader.getInstance().findProperty( DBConstants.PASSWORD_SIPRP );

		return getStatement( DBConstants.DB.SIPRP, connectionURL, username, password );
	}

	@Deprecated
	public Statement createLocalStatement()
	{
		String connectionURL = ( String ) Singleton.getInstance( DBConstants.LOCAL_CONNECTION_URL );
		String username = DBPropertiesLoader.getInstance().findProperty( DBConstants.USERNAME_SIPRP_LOCAL );
		String password = DBPropertiesLoader.getInstance().findProperty( DBConstants.PASSWORD_SIPRP_LOCAL );

		return getStatement( DBConstants.DB.SIPRP_LOCAL, connectionURL, username, password );
	}

	private Statement getStatement( DBConstants.DB db, String connectionURL, String username, String password )
	{
		Statement stm = null;
		try
		{
			Connection connection = getConnection( db, connectionURL, username, password );
			if ( connection != null )
			{
				stm = connection.createStatement( ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY );
			}
		}
		catch ( Exception e )
		{
			ErrorLogger.logException( e );
		}
		return stm;
	}

	private Connection getConnection( DBConstants.DB db, String connectionURL, String username, String password ) throws Exception
	{
		Connection connection = null;
//		System.out.println( "\nEvoBaseProvider . getConnection( " + connectionURL + ", " + username + " ) : " );

		FacesContext fc = FacesContext.getCurrentInstance();
//		System.out.println( "\tFacesContext : " + fc );
		if ( fc != null )
		{

			ExternalContext ec = fc.getExternalContext();
	//		System.out.println( "\tExternalContext : " + ec );
			if ( ec != null )
			{
				HttpSession session = ( HttpSession ) ec.getSession( false );
		//		System.out.println( "\tSession : " + session );

				if ( session != null )
				{
					if ( DBConstants.DB.SIPRP.equals( db ) )
					{
						connection = ( Connection ) session.getAttribute( DBConstants.SESSION_CONNECTION );
						if ( connection == null )
						{
		//					System.out.println( "\n-> Creating new SIPRP connection ..." );
							Class.forName( "org.postgresql.Driver" ).newInstance();
							connection = DriverManager.getConnection( connectionURL, username, password );
							session.setAttribute( DBConstants.SESSION_CONNECTION, connection );
						}
					}
					else if ( DBConstants.DB.SIPRP_LOCAL.equals( db ) )
					{
						connection = ( Connection ) session.getAttribute( DBConstants.SESSION_CONNECTION_LOCAL );
						if ( connection == null )
						{
		//					System.out.println( "\n-> Creating new SIPRP_LOCAL connection ..." );
							Class.forName( "org.postgresql.Driver" ).newInstance();
							connection = DriverManager.getConnection( connectionURL, username, password );
							session.setAttribute( DBConstants.SESSION_CONNECTION_LOCAL, connection );
						}
					}
				}
			}
		}

		if ( connection == null )
		{
			connection = ( Connection ) Singleton.getInstance( "CONNECTION_OBJECT" );
			if ( connection == null )
			{
	//			System.out.println( "\nEvoBaseProvider . getConnection() : session is null !" );

				if ( DBConstants.DB.SIPRP.equals( db ) )
				{
	//				System.out.println( "\t-> Creating new SIPRP connection ..." );
					Class.forName( "org.postgresql.Driver" ).newInstance();
					connection = DriverManager.getConnection( connectionURL, username, password );
				}
				else if ( DBConstants.DB.SIPRP_LOCAL.equals( db ) )
				{
	//				System.out.println( "\t-> Creating new SIPRP_LOCAL connection ..." );
					Class.forName( "org.postgresql.Driver" ).newInstance();
					connection = DriverManager.getConnection( connectionURL, username, password );
				}
				Singleton.setInstance( "CONNECTION_OBJECT", connection );
			}
		}

//		System.out.println( "<-- getConnection() : " + connection );
		return connection;
	}

    public String getUrl()
    {
        return url;
    }

    public String getUsername()
    {
        return username;
    }

    public String getPassword()
    {
        return password;
    }

    public String getUrl_local()
    {
        return url_local;
    }

    public String getUsername_local()
    {
        return username_local;
    }

    public String getPassword_local()
    {
        return password_local;
    }
}