/*
 * 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.lock.semaphore;

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;

import net.sf.hajdbc.lock.LockManager;

/**
 * @author Paul Ferraro
 */
public class SemaphoreLockManager implements LockManager
{
        private final ConcurrentMap<String, ReadWriteLock> lockMap = new ConcurrentHashMap<String, ReadWriteLock>();

        private final boolean fair;
        
        public SemaphoreLockManager(boolean fair)
        {
                this.fair = fair;
        }
        
        /**
         * @see net.sf.hajdbc.lock.LockManager#readLock(java.lang.String)
         */
        @Override
        public Lock readLock(String object)
        {
                Lock lock = this.getReadWriteLock(null).readLock();
                
                return (object == null) ? lock : new GlobalLock(lock, this.getReadWriteLock(object).readLock());
        }
        
        /**
         * @see net.sf.hajdbc.lock.LockManager#writeLock(java.lang.String)
         */
        @Override
        public Lock writeLock(String object)
        {
                ReadWriteLock readWriteLock = this.getReadWriteLock(null);
                
                return (object == null) ? readWriteLock.writeLock() : new GlobalLock(readWriteLock.readLock(), this.getReadWriteLock(object).writeLock());
        }
        
        private synchronized ReadWriteLock getReadWriteLock(String object)
        {
                // CHM cannot use a null key
                String key = (object != null) ? object : "";
                
                ReadWriteLock lock = this.lockMap.get(key);
                
                if (lock == null)
                {
                        lock = new SemaphoreReadWriteLock(new Semaphore(Integer.MAX_VALUE, this.fair));

                        ReadWriteLock existing = this.lockMap.putIfAbsent(key, lock);
                        
                        if (existing != null)
                        {
                                lock = existing;
                        }
                }
                
                return lock;
        }
        
        private static class GlobalLock implements Lock
        {
                private Lock globalLock;
                private Lock lock;
                
                GlobalLock(Lock globalLock, Lock lock)
                {
                        this.globalLock = globalLock;
                        this.lock = lock;
                }
                
                @Override
                public void lock()
                {
                        this.globalLock.lock();
                        this.lock.lock();
                }

                @Override
                public void lockInterruptibly() throws InterruptedException
                {
                        this.globalLock.lockInterruptibly();
                        
                        try
                        {
                                this.lock.lockInterruptibly();
                        }
                        catch (InterruptedException e)
                        {
                                this.globalLock.unlock();
                                throw e;
                        }
                }

                @Override
                public boolean tryLock()
                {
                        if (this.globalLock.tryLock())
                        {
                                if (this.lock.tryLock())
                                {
                                        return true;
                                }

                                this.globalLock.unlock();
                        }

                        return false;
                }

                @Override
                public boolean tryLock(long time, TimeUnit unit) throws InterruptedException
                {
                        if (this.globalLock.tryLock(time, unit))
                        {
                                if (this.lock.tryLock(time, unit))
                                {
                                        return true;
                                }

                                this.globalLock.unlock();
                        }

                        return false;
                }

                @Override
                public void unlock()
                {
                        this.lock.unlock();
                        this.globalLock.unlock();
                }

                @Override
                public Condition newCondition()
                {
                        throw new UnsupportedOperationException();
                }
        }

        /**
         * @see net.sf.hajdbc.Lifecycle#start()
         */
        @Override
        public void start()
        {
                // Do nothing
        }

        /**
         * @see net.sf.hajdbc.Lifecycle#stop()
         */
        @Override
        public void stop()
        {
                // Do nothing
        }
}