package com.atlassian.vcache.internal.harness;
   
   import com.atlassian.cache.CacheFactory;
   import com.atlassian.cache.memory.MemoryCacheManager;
   import com.atlassian.marshalling.jdk.JavaSerializationMarshalling;
   import com.atlassian.vcache.ChangeRate;
   import com.atlassian.vcache.DirectExternalCache;
   import com.atlassian.vcache.ExternalCacheSettingsBuilder;
   import com.atlassian.vcache.JvmCache;
  import com.atlassian.vcache.JvmCacheSettingsBuilder;
  import com.atlassian.vcache.RequestCache;
  import com.atlassian.vcache.internal.core.DefaultVCacheCreationHandler;
  import com.atlassian.vcache.internal.core.WorkContextRequestContextSupplier;
  import com.atlassian.vcache.internal.core.metrics.DefaultMetricsCollector;
  import com.atlassian.vcache.internal.core.metrics.MetricsCollector;
  import com.atlassian.vcache.internal.core.metrics.NoopMetricsCollector;
  import com.atlassian.vcache.internal.core.service.AbstractVCacheService;
  import com.atlassian.vcache.internal.legacy.LegacyServiceSettings;
  import com.atlassian.vcache.internal.legacy.LegacyServiceSettingsBuilder;
  import com.atlassian.vcache.internal.legacy.LegacyVCacheService;
  import com.atlassian.vcache.internal.memcached.MemcachedVCacheService;
  import com.atlassian.vcache.internal.memcached.MemcachedVCacheServiceSettings;
  import com.atlassian.vcache.internal.memcached.MemcachedVCacheServiceSettingsBuilder;
  import com.atlassian.vcache.internal.test.EmptyVCacheSettingsDefaultsProvider;
  import com.atlassian.vcache.internal.test.ThreadLocalRequestContextSupplier;
  import com.codahale.metrics.MetricRegistry;
  import com.codahale.metrics.Snapshot;
  import net.spy.memcached.AddrUtil;
  import net.spy.memcached.BinaryConnectionFactory;
  import net.spy.memcached.MemcachedClient;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import java.io.IOException;
  import java.text.DecimalFormat;
  import java.time.Duration;
  import java.util.Arrays;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.concurrent.TimeUnit;
  import java.util.stream.Collectors;
  import java.util.stream.IntStream;
  
  import static java.util.Objects.requireNonNull;
  import static java.util.stream.Collectors.joining;
  
  /**
   * Runs some stressy thing.
   */
  public class StressHarness {
      private static final Logger log = LoggerFactory.getLogger(StressHarness.class);
  
      private static final ThreadLocalRequestContextSupplier requestContextSupplier = ThreadLocalRequestContextSupplier.strictSupplier();
      private static final WorkContextRequestContextSupplier workContextContextSupplier = new WorkContextRequestContextSupplier(() -> "tenant-123");
      private static final CacheFactory cacheFactory = new MemoryCacheManager();
  
      private final MetricRegistry metricRegistry = new MetricRegistry();
      private final AbstractVCacheService service;
      private OverallConfig overallConfig;
  
      public StressHarness(AbstractVCacheService service) {
          this.service = requireNonNull(service);
      }
  
      public static void main(String[] args) throws InterruptedException, IOException {
          log.info("And away");
  
          final boolean useLegacy = false;
          final LegacyServiceSettings settings = new LegacyServiceSettingsBuilder().build();
          final MetricsCollector metricsCollector = new DefaultMetricsCollector(requestContextSupplier);
  
          final AbstractVCacheService legacySvc = new LegacyVCacheService(
                  "harness",
                  requestContextSupplier,
                  workContextContextSupplier,
                  new EmptyVCacheSettingsDefaultsProvider(),
                  new DefaultVCacheCreationHandler(
                          10_000, Duration.ofHours(2), 10_000, ChangeRate.HIGH_CHANGE, ChangeRate.HIGH_CHANGE),
                  metricsCollector,
                  () -> cacheFactory,
                  settings,
                  context -> {
                  });
  
          final MemcachedClient memcachedClient = new MemcachedClient(
                  new BinaryConnectionFactory(),
                  AddrUtil.getAddresses("192.168.99.100:32768"));
  
          final MemcachedVCacheServiceSettings serviceSettings = new MemcachedVCacheServiceSettingsBuilder()
                  .productIdentifier("" + System.nanoTime())
                  .clientSupplier(() -> memcachedClient)
                  .threadLocalContextSupplier(requestContextSupplier)
                  .defaultsProvider(new EmptyVCacheSettingsDefaultsProvider())
                  .creationHandler(new DefaultVCacheCreationHandler(
                          10_000, Duration.ofHours(2), 10_000, ChangeRate.HIGH_CHANGE, ChangeRate.HIGH_CHANGE))
                  .metricsCollector(metricsCollector)
                  .begunTransactionalActivityHandler(context -> {
                  })
                 .build();
         final AbstractVCacheService memcachedSvc = new MemcachedVCacheService(serviceSettings);
 
         final StressHarness harness = new StressHarness(useLegacy ? legacySvc : memcachedSvc);
 //        final StressHarness harness = new StressHarness(memcachedSvc);
         harness.setup();
         harness.perform();
 
         System.out.printf(
                 "\n\nFinished: serializeHack is '%s', collecting metrics is '%s', use legacy is '%s'\n",
                 settings.isSerializationHack(), !(metricsCollector instanceof NoopMetricsCollector), useLegacy);
     }
 
     private void perform() throws InterruptedException {
         // Spin up threads
         // Wait time
         // Set time to stop
         final List<Worker> workers = IntStream.rangeClosed(1, 10)
                 .mapToObj(i -> new Worker(i, overallConfig))
                 .collect(Collectors.toList());
 
         workers.forEach(w -> new Thread(w).start());
         Thread.sleep(60_000);
         workers.forEach(Worker::stopIt);
         Thread.sleep(500); // yeah yeah, I should wait for the threads!
 
         final List<String> columns = Arrays.asList("Timer", "Count", "Min", "Max", "Median", "95th", "99th");
         System.out.println(columns.stream().collect(joining("\t")));
         metricRegistry.getTimers().entrySet().forEach(timerEntry -> {
             final Snapshot snapshot = timerEntry.getValue().getSnapshot();
             final List<String> parts = Arrays.asList(
                     timerEntry.getKey(),
                     Long.toString(timerEntry.getValue().getCount()),
                     toMillisString(snapshot.getMin()),
                     toMillisString(snapshot.getMax()),
                     toMillisString(snapshot.getMedian()),
                     toMillisString(snapshot.get95thPercentile()),
                     toMillisString(snapshot.get99thPercentile()));
 
             System.out.println(parts.stream().collect(joining("\t")));
         });
     }
 
     private String toMillisString(double nanoseconds) {
         return new DecimalFormat("#0.0#####").format(
                 nanoseconds / TimeUnit.NANOSECONDS.convert(1, TimeUnit.MILLISECONDS));
     }
 
     private void setup() {
         final Map<String, CacheConfig> cacheTestConfigMap = new HashMap<>();
         overallConfig = new OverallConfig(metricRegistry, service, requestContextSupplier, cacheTestConfigMap, 5, 200);
 
         // JvmCache
         final JvmCache<String, String> jvmCache1 = service.getJvmCache("jvmCache1", new JvmCacheSettingsBuilder().build());
         final CacheConfig jvmCache1Config = new CacheConfig(jvmCache1, 10, 10, 10, 20, 90);
 //        cacheTestConfigMap.put(jvmCache1.getName(), jvmCache1Config);
 
         // Request Cache
         final RequestCache<String, String> requestCache1 = service.getRequestCache("requestCache1");
         final CacheConfig requestCache1Config = new CacheConfig(requestCache1, 20, 20, 20, 40, 90);
 //        cacheTestConfigMap.put(requestCache1.getName(), requestCache1Config);
 
         // DirectEX
         final DirectExternalCache<String> directExternalCache = service.getDirectExternalCache(
                 "directEC1",
                 JavaSerializationMarshalling.pair(String.class),
                 new ExternalCacheSettingsBuilder().build());
         final CacheConfig directExternalCacheConfig = new CacheConfig(directExternalCache, 20, 20, 20, 40, 90);
         cacheTestConfigMap.put(directExternalCache.getName(), directExternalCacheConfig);
     }
 }