// **********************************************************************
//
// Copyright (c) 2003-2007 ZeroC, Inc. All rights reserved.
//
// This copy of Ice is licensed to you under the terms described in the
// ICE_LICENSE file included in this distribution.
//
// **********************************************************************

package Freeze;

class SharedDbEnv implements com.sleepycat.db.ErrorHandler, Runnable
{
    public static SharedDbEnv
    get(Ice.Communicator communicator, String envName, com.sleepycat.db.Environment dbEnv)
    {
        MapKey key = new MapKey(envName, communicator);

        SharedDbEnv result;

        synchronized(_map) 
        {
            result = (SharedDbEnv)_map.get(key);
            if(result == null)
            {
                try
                {
                    result = new SharedDbEnv(key, dbEnv);
                }
                catch(com.sleepycat.db.DatabaseException dx)
                {
                    DatabaseException ex = new DatabaseException();
                    ex.initCause(dx);
                    ex.message = errorPrefix(envName) + "creation: " + dx.getMessage();
                    throw ex;
                }

                Object previousValue = _map.put(key, result);
                assert(previousValue == null);
            }
            else
            {
                result._refCount++;
            }
        }

        //
        // Make sure the result if fully initialized
        //
        result.init();
        return result;
    }
    
    public String 
    getEnvName()
    {
        return _key.envName;
    }

    public Ice.Communicator
    getCommunicator()
    {
        return _key.communicator;
    }

    public com.sleepycat.db.Environment
    getEnv()
    {
        return _dbEnv;
    }

    public SharedDb
    getCatalog()
    {
        return _catalog;
    }

    public void
    close()
    {
        synchronized(_map) 
        {
            if(--_refCount == 0)
            {       
                //
                // Remove from map
                //
                Object value = _map.remove(_key);
                assert(value == this);

                //
                // Join thread
                //
                synchronized(this)
                {
                    _done = true;
                    notify();
                }

                for(;;)
                {
                    if(_thread != null)
                    {
                        try
                        {
                            _thread.join();
                            _thread = null;
                            break;
                        }
                        catch(InterruptedException ex)
                        {
                        }
                    }
                }

                //
                // Release catalog
                //
                if(_catalog != null)
                {
                    _catalog.close();
                    _catalog = null;
                }

                if(_trace >= 1)
                {
                    _key.communicator.getLogger().trace("Freeze.DbEnv", "closing database environment \"" +
                                                        _key.envName + "\"");
                }

                //
                // Keep lock to prevent somebody else from re-opening this DbEnv
                // before it's closed.
                //
                try
                {
                    _dbEnv.close();
                }
                catch(com.sleepycat.db.DatabaseException dx)
                {
                    DatabaseException ex = new DatabaseException();
                    ex.initCause(dx);
                    ex.message = errorPrefix(_key.envName) + "close: " + dx.getMessage();
                    throw ex;
                }
            }
        }
    }

    public void
    run()
    {
        for(;;)
        {
            synchronized(this)
            {
                while(!_done)
                {
                    try
                    {
                        wait(_checkpointPeriod);
                    }
                    catch(InterruptedException ex)
                    {
                        continue;
                    }
                    break;
                }
                if(_done)
                {
                    return;
                }
            }
            
            if(_trace >= 2)
            {
                _key.communicator.getLogger().trace("Freeze.DbEnv", "checkpointing environment \"" + _key.envName +
                                                    "\"");
            }

            try
            {
                com.sleepycat.db.CheckpointConfig config = new com.sleepycat.db.CheckpointConfig();
                config.setKBytes(_kbyte);
                _dbEnv.checkpoint(config);
            }
            catch(com.sleepycat.db.DatabaseException dx)
            {
                _key.communicator.getLogger().warning("checkpoint on DbEnv \"" + _key.envName +
                                                      "\" raised DbException: " + dx.getMessage());
            }
        }
    }
    
    public void 
    error(com.sleepycat.db.Environment env, String errorPrefix, String message)
    {
        _key.communicator.getLogger().error("Freeze database error in DbEnv \"" + _key.envName + "\": " + message);
    }

    protected void 
    finalize()
    {
        assert(_refCount == 0);
    }

    private
    SharedDbEnv(MapKey key, com.sleepycat.db.Environment dbEnv)
        throws com.sleepycat.db.DatabaseException
    {   
        _key = key;
        _dbEnv = dbEnv;
        _ownDbEnv = (dbEnv == null);

        Ice.Properties properties = key.communicator.getProperties();
        _trace = properties.getPropertyAsInt("Freeze.Trace.DbEnv");

        if(_ownDbEnv)
        {
            com.sleepycat.db.EnvironmentConfig config = new com.sleepycat.db.EnvironmentConfig();

            config.setErrorHandler(this);
            config.setInitializeLocking(true);
            config.setInitializeLogging(true);
            config.setInitializeCache(true);
            config.setAllowCreate(true);
            config.setTransactional(true);

            //
            // Deadlock detection
            //
            config.setLockDetectMode(com.sleepycat.db.LockDetectMode.YOUNGEST);

            String propertyPrefix = "Freeze.DbEnv." + _key.envName;
            if(properties.getPropertyAsInt(propertyPrefix + ".DbRecoverFatal") != 0)
            {
                config.setRunFatalRecovery(true);
            }
            else
            {
                config.setRunRecovery(true);
            }

            if(properties.getPropertyAsIntWithDefault(propertyPrefix + ".DbPrivate", 1) != 0)
            {
                config.setPrivate(true);
            }

            if(properties.getPropertyAsIntWithDefault(propertyPrefix + ".OldLogsAutoDelete", 1) != 0)
            {
                config.setLogAutoRemove(true);
            }

            if(_trace >= 1)
            {
                _key.communicator.getLogger().trace("Freeze.DbEnv", "opening database environment \"" +
                                                    _key.envName + "\"");
            }

            //
            // TODO: FREEZE_DB_MODE
            //
            
            try
            {
                String dbHome = properties.getPropertyWithDefault(propertyPrefix + ".DbHome", _key.envName);
                java.io.File home = new java.io.File(dbHome);
                _dbEnv = new com.sleepycat.db.Environment(home, config);
            }
            catch(java.io.FileNotFoundException dx)
            {
                NotFoundException ex = new NotFoundException();
                ex.initCause(dx);
                ex.message = errorPrefix(_key.envName) + "open: " + dx.getMessage();
                throw ex;
            }
            
            //
            // Default checkpoint period is every 120 seconds
            //
            _checkpointPeriod =
                properties.getPropertyAsIntWithDefault(propertyPrefix + ".CheckpointPeriod", 120) * 1000;
            
            _kbyte = properties.getPropertyAsIntWithDefault(propertyPrefix + ".PeriodicCheckpointMinSize", 0);

            String threadName;
            String programName = properties.getProperty("Ice.ProgramName");
            if(programName.length() > 0)
            {
                threadName = programName + "-";
            }
            else
            {
                threadName = "";
            }
            threadName += "FreezeCheckpointThread(" + _key.envName + ")";

            if(_checkpointPeriod > 0)
            {
                _thread = new Thread(this, threadName);
                _thread.start();
            }    
        }

        _refCount = 1;
    }

    private synchronized void
    init()
    {
        if(_catalog == null)
        {
            _catalog = SharedDb.openCatalog(this);
        }
    }

    private static String
    errorPrefix(String envName)
    {
        return "DbEnv(\"" + envName + "\"): ";
    }

    private static class MapKey
    {
        final String envName;
        final Ice.Communicator communicator;
        
        MapKey(String envName, Ice.Communicator communicator)
        {
            this.envName = envName;
            this.communicator = communicator;
        }

        public boolean
        equals(Object o)
        {   
            try
            {
                MapKey k = (MapKey)o;
                return (communicator == k.communicator) && envName.equals(k.envName);
            }
            catch(ClassCastException ex)
            {
                communicator.getLogger().trace("Freeze.DbEnv", "equals cast failed");
                return false;
            }
        }
        
        public int hashCode()
        {
            return envName.hashCode() ^ communicator.hashCode();
        }
    }

    private MapKey _key;
    private com.sleepycat.db.Environment _dbEnv;
    private boolean _ownDbEnv;
    private SharedDb _catalog;
    private int _refCount = 0;
    private boolean _done = false;
    private int _trace = 0;
    private long _checkpointPeriod = 0;
    private int _kbyte = 0;
    private Thread _thread;

    //
    // Hash map of (MapKey, SharedDbEnv)
    //
    private static java.util.Map _map = new java.util.HashMap();
}