package com.atlassian.plugin.manager.store;
   
   import com.atlassian.annotations.Internal;
   import com.atlassian.plugin.manager.PluginPersistentState;
   import com.atlassian.plugin.manager.PluginPersistentStateStore;
   import com.atlassian.util.concurrent.ManagedLock;
   import com.atlassian.util.concurrent.ManagedLocks;
   import com.atlassian.util.concurrent.Supplier;
   import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import java.util.concurrent.TimeUnit;
  import java.util.concurrent.atomic.AtomicInteger;
  import java.util.concurrent.locks.Condition;
  import java.util.concurrent.locks.Lock;
  import java.util.concurrent.locks.ReadWriteLock;
  import java.util.concurrent.locks.ReentrantLock;
  import java.util.concurrent.locks.ReentrantReadWriteLock;
  
  import static com.atlassian.plugin.util.EnumUtils.enumValueFromProperty;
  import static com.google.common.base.Preconditions.checkNotNull;
  
  /**
   * A wrapper to add exclusion and logging to a {@link PluginPersistentStateStore}.
   *
   * This wrapper is intended as an interim measure to investigate and experiment with locking to avoid the worst symptoms of
   * PLUG-1106. It's not designed to fix the underlying causes of the concurrency issues.
   *
   * @since 3.2.12
   */
  public class SynchronizedPluginPersistentStateStore implements PluginPersistentStateStore {
      private static final Logger log = LoggerFactory.getLogger(SynchronizedPluginPersistentStateStore.class);
  
      @Internal
      public enum LockMode {
          UNLOCKED {
              @Override
              ReadWriteLock getReadWriteLock() {
                  return new CommonReadWriteLock(new NoOpLock());
              }
          },
          SIMPLE {
              @Override
              ReadWriteLock getReadWriteLock() {
                  return new CommonReadWriteLock(new ReentrantLock());
              }
  
          },
          FAIRSIMPLE {
              @Override
              ReadWriteLock getReadWriteLock() {
                  return new CommonReadWriteLock(new ReentrantLock(true));
              }
          },
          READWRITE {
              @Override
              ReadWriteLock getReadWriteLock() {
                  return new ReentrantReadWriteLock();
              }
          },
          FAIRREADWRITE {
              @Override
              ReadWriteLock getReadWriteLock() {
                  return new ReentrantReadWriteLock(true);
              }
          };
  
          private static final String PROPERTY_NAME = SynchronizedPluginPersistentStateStore.class.getName() + ".lockMode";
  
          static LockMode current() {
              return enumValueFromProperty(PROPERTY_NAME, LockMode.values(), LockMode.READWRITE);
          }
  
          abstract ReadWriteLock getReadWriteLock();
  
      }
  
      @Internal
      public static String getLockModeProperty() {
          return LockMode.PROPERTY_NAME;
      }
  
      private final PluginPersistentStateStore delegate;
      private final ManagedLock.ReadWrite lock;
      private final AtomicInteger loadConcurrency = new AtomicInteger(0);
      private final AtomicInteger saveConcurrency = new AtomicInteger(0);
  
      public SynchronizedPluginPersistentStateStore(final PluginPersistentStateStore delegate) {
          this(delegate, LockMode.current().getReadWriteLock());
      }
  
      public SynchronizedPluginPersistentStateStore(final PluginPersistentStateStore delegate, final ReadWriteLock lock) {
          this.delegate = checkNotNull(delegate);
          this.lock = ManagedLocks.manageReadWrite(checkNotNull(lock));
      }
  
      @Override
      public void save(final PluginPersistentState state) {
          final int writes = saveConcurrency.incrementAndGet();
         log.debug("save concurrency {}", writes);
         lock.write().withLock(new Runnable() {
             @Override
             public void run() {
                 delegate.save(state);
             }
         });
         saveConcurrency.decrementAndGet();
     }
 
     @Override
     public PluginPersistentState load() {
         final int reads = loadConcurrency.incrementAndGet();
         log.debug("load concurrency {}", reads);
         final PluginPersistentState pluginPersistentState = lock.read().withLock(new Supplier<PluginPersistentState>() {
             @Override
             public PluginPersistentState get() {
                 return delegate.load();
             }
         });
         loadConcurrency.decrementAndGet();
         return pluginPersistentState;
     }
 
     static class NoOpLock implements Lock {
         @Override
         public void lock() {
         }
 
         @Override
         public void lockInterruptibly() {
         }
 
         @Override
         public boolean tryLock() {
             return true;
         }
 
         @Override
         public boolean tryLock(final long time, final TimeUnit unit) {
             return true;
         }
 
         @Override
         public void unlock() {
         }
 
         @Override
         public Condition newCondition() {
             throw new UnsupportedOperationException("Not implemented");
         }
     }
 
     static class CommonReadWriteLock implements ReadWriteLock {
         private final Lock lock;
 
         public CommonReadWriteLock(final Lock lock) {
             this.lock = lock;
         }
 
         @Override
         public Lock readLock() {
             return lock;
         }
 
         @Override
         public Lock writeLock() {
             return lock;
         }
     }
 }