/*
 * HA-JDBC: High-Availability JDBC
 * Copyright (C) 2012  Paul Ferraro
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
package net.sf.hajdbc.sql;

import java.io.PrintWriter;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.concurrent.TimeUnit;
import java.util.logging.Logger;

import javax.naming.BinaryRefAddr;
import javax.naming.Reference;
import javax.naming.Referenceable;
import javax.naming.StringRefAddr;

import net.sf.hajdbc.Database;
import net.sf.hajdbc.DatabaseCluster;
import net.sf.hajdbc.DatabaseClusterConfiguration;
import net.sf.hajdbc.DatabaseClusterConfigurationFactory;
import net.sf.hajdbc.DatabaseClusterFactory;
import net.sf.hajdbc.ExceptionType;
import net.sf.hajdbc.util.Objects;
import net.sf.hajdbc.util.TimePeriod;
import net.sf.hajdbc.util.concurrent.ReferenceRegistryStoreFactory;
import net.sf.hajdbc.util.concurrent.LifecycleRegistry;
import net.sf.hajdbc.util.concurrent.Registry;
import net.sf.hajdbc.xml.XMLDatabaseClusterConfigurationFactory;

/**
 * @author Paul Ferraro
 * @param <Z> data source class
 */
public abstract class CommonDataSource<Z extends javax.sql.CommonDataSource, D extends Database<Z>, F extends CommonDataSourceProxyFactory<Z, D>> implements Referenceable, javax.sql.CommonDataSource, CommonDataSourceProxyFactoryFactory<Z, D, F>, Registry.Factory<Void, DatabaseCluster<Z, D>, Void, SQLException>
{
        private final Class<? extends DatabaseClusterConfiguration<Z, D>> configurationClass;
        
        private final Registry<Void, DatabaseCluster<Z, D>, Void, SQLException> registry = new LifecycleRegistry<Void, DatabaseCluster<Z, D>, Void, SQLException>(this, new ReferenceRegistryStoreFactory(), ExceptionType.SQL.<SQLException>getExceptionFactory());
        
        private volatile TimePeriod timeout = new TimePeriod(10, TimeUnit.SECONDS);
        private volatile String cluster;
        private volatile String config;
        private volatile String user;
        private volatile String password;
        private volatile DatabaseClusterFactory<Z, D> factory = new DatabaseClusterFactoryImpl<Z, D>();
        private volatile DatabaseClusterConfigurationFactory<Z, D> configurationFactory;  
        
        protected CommonDataSource(Class<? extends DatabaseClusterConfiguration<Z, D>> configurationClass)
        {
                this.configurationClass = configurationClass;
        }
        
        public void stop() throws SQLException
        {
                this.registry.remove(null);
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public DatabaseCluster<Z, D> create(Void key, Void context) throws SQLException
        {
                DatabaseClusterConfigurationFactory<Z, D> factory = (this.configurationFactory != null) ? this.configurationFactory : new XMLDatabaseClusterConfigurationFactory<Z, D>(this.configurationClass, this.cluster, this.config);
                
                return this.factory.createDatabaseCluster(this.cluster, factory);
        }

        public Z getProxy() throws SQLException
        {
                return this.createProxyFactory(this.registry.get(null, null)).createProxy();
        }
        
        /**
         * @return the cluster
         */
        public String getCluster()
        {
                return this.cluster;
        }

        /**
         * @param cluster the cluster to set
         */
        public void setCluster(String cluster)
        {
                this.cluster = cluster;
        }

        /**
         * @return the config
         */
        public String getConfig()
        {
                return this.config;
        }

        /**
         * @param config the config to set
         */
        public void setConfig(String config)
        {
                this.config = config;
        }
        
        public String getUser()
        {
                return this.user;
        }
        
        public void setUser(String user)
        {
                this.user = user;
        }
        
        public String getPassword()
        {
                return this.password;
        }
        
        public void setPassword(String password)
        {
                this.password = password;
        }
        
        public DatabaseClusterConfigurationFactory<Z, D> getConfigurationFactory()
        {
                return this.configurationFactory;
        }
        
        public void setConfigurationFactory(DatabaseClusterConfigurationFactory<Z, D> configurationFactory)
        {
                this.configurationFactory = configurationFactory;
        }
        
        public DatabaseClusterFactory<Z, D> getFactory()
        {
                return this.factory;
        }
        
        public void setFactory(DatabaseClusterFactory<Z, D> clusterFactory)
        {
                this.factory = clusterFactory;
        }
        
        /**
         * @return the timeout
         */
        @Override
        public TimePeriod getTimeout()
        {
                return this.timeout;
        }

        /**
         * @param value the timeout to set, expressed in the specified units
         * @param unit the time unit with which to qualify the specified timeout value
         */
        public void setTimeout(long value, TimeUnit unit)
        {
                this.timeout = new TimePeriod(value, unit);
        }

        /**
         * @throws SQLFeatureNotSupportedException 
         * @see javax.sql.CommonDataSource#getParentLogger()
         */
        @Override
        public Logger getParentLogger() throws SQLFeatureNotSupportedException
        {
                try
                {
                        return this.getProxy().getParentLogger();
                }
                catch (SQLFeatureNotSupportedException e)
                {
                        throw e;
                }
                catch (SQLException e)
                {
                        throw new SQLFeatureNotSupportedException(e.getMessage(), e.getSQLState(), e.getErrorCode(), e.getCause());
                }
        }

        /**
         * @see javax.sql.CommonDataSource#getLoginTimeout()
         */
        @Override
        public int getLoginTimeout() throws SQLException
        {
                return this.getProxy().getLoginTimeout();
        }

        /**
         * @see javax.sql.CommonDataSource#getLogWriter()
         */
        @Override
        public PrintWriter getLogWriter() throws SQLException
        {
                return this.getProxy().getLogWriter();
        }

        /**
         * @see javax.sql.CommonDataSource#setLoginTimeout(int)
         */
        @Override
        public void setLoginTimeout(int timeout) throws SQLException
        {
                this.getProxy().setLoginTimeout(timeout);
        }

        /**
         * @see javax.sql.CommonDataSource#setLogWriter(java.io.PrintWriter)
         */
        @Override
        public void setLogWriter(PrintWriter writer) throws SQLException
        {
                this.getProxy().setLogWriter(writer);
        }

        @Override
        public Reference getReference()
        {
                Reference reference = new Reference(this.getClass().getName(), CommonDataSourceFactory.class.getName(), null);
                reference.add(new StringRefAddr(CommonDataSourceFactory.CLUSTER, this.cluster));
                DatabaseClusterConfigurationFactory<Z, D> factory = this.getConfigurationFactory();
                if (factory != null)
                {
                        reference.add(new BinaryRefAddr(CommonDataSourceFactory.CONFIG, Objects.serialize(factory)));
                }
                else
                {
                        reference.add(new StringRefAddr(CommonDataSourceFactory.CONFIG, this.config));
                }
                if (this.user != null)
                {
                        reference.add(new StringRefAddr(CommonDataSourceFactory.USER, this.user));
                }
                if (this.password != null)
                {
                        reference.add(new StringRefAddr(CommonDataSourceFactory.PASSWORD, this.password));
                }
                return reference;
        }
}