import org.h2.mvstore.*;
import java.util.*;
import java.text.*;
import java.io.*;
import java.util.concurrent.atomic.*;

public class LongTest {

  public static void main(String[] args) {
    DateFormat df = new SimpleDateFormat("HH:mm:ss.SSS");
    
    int iterates = 1;
    int threads = 1;
    int items = 10000000;
    int batch = 100;
    String db = "long-test.db";
    boolean tryCommit = true;
    
    for (int i = 0, n = args.length; i < n; ++i) {
      String arg = args[i];
      if ("--iterates".equals(arg)) {
        iterates = Integer.decode(args[++i]);
      } else if ("--threads".equals(arg)) {
        threads = Integer.decode(args[++i]);
      } else if ("--items".equals(arg)) {
        items = Integer.decode(args[++i]);
      } else if ("--batch".equals(arg)) {
        batch = Integer.decode(args[++i]);
      } else if ("--db".equals(arg)) {
        db = args[++i];
      } else if ("--try-commit".equals(arg)) {
        tryCommit = Boolean.parseBoolean(args[++i]);
      }
    }
    long dbSize = new File(db).length();
    System.out.println(String.format("%s>> iterates %d, items [0 - %d), threads %d, batch %d, tryCommit %s, dbSize %dM", 
      df.format(new Date()), iterates, items, threads, batch, tryCommit, dbSize >> 20));

    final long ts = System.currentTimeMillis();
    for (int j = 0; j < iterates; ++j) {
      final long ta = System.currentTimeMillis();
      String time = df.format(new Date());
      System.out.println(String.format("%s[iterate-%d] Open MVStore '%s'", time, j, db));
      try (final MVStore store = MVStore.open(db)) {
        final long to = System.currentTimeMillis();
        dbSize = new File(db).length();
        time = df.format(new Date());
        System.out.println(String.format("%s[iterate-%d] MVStore opened: time %dms, dbSize %dM", 
          time, j, to - ta, dbSize >> 20));
        final Thread[] workers = new Thread[threads];
        final boolean tryco = tryCommit;
        int step = items / threads;
        int rem = items % threads;
        int txBatch = batch;
        final AtomicInteger count = new AtomicInteger();
      
        for (int i = 0; i < threads; ++i) {
          final int offset = i * step;
          final int range = (i == threads - 1? step + rem: step);
          Thread t = new Thread(() -> {
              int n = test(store, offset, range, txBatch, tryco);
              count.set(n);
            }, "worker-" + i);
          t.setDaemon(true);
          workers[i] = t;
          t.start();
        }
        
        time = df.format(new Date());
        System.out.println(String.format("%s[iterate-%d] Wait for test completion", time, j));
        for (int i = 0; i < threads; ++i) {
          Thread t = workers[i];
          try {
            t.join();
          } catch(InterruptedException ignore){}
        }
        if (count.get() != items) throw new AssertionError("Expect count " + items + " but " + count);
      }
      dbSize = new File(db).length();
      
      final long tb = System.currentTimeMillis();
      time = df.format(new Date());
      System.out.println(String.format("%s[iterate-%d] Time %dms, items %d, threads %d, batch %d, tryCommit %s, dbSize %dM", 
        time, j, tb - ta, items, threads, batch, tryCommit, dbSize >> 20));
    }
    dbSize = new File(db).length();

    final long te = System.currentTimeMillis();
    System.out.println(String.format("%s<< time %dms, iterates %d, items [0 - %d), threads %d, batch %d, tryCommit %s, dbSize %dM", 
      df.format(new Date()), te - ts, iterates, items, threads, batch, tryCommit, dbSize >> 20));
    System.out.println();
  }

  static int test(MVStore store, int offset, int range, int batch, boolean tryCommit) {
    MVMap<Integer, String> map = store.openMap("data");
    String prefix = "Bar-bar-bar-bar-bar-bar-bar-bar-bar-bar-bar-bar-bar-bar-bar-bar-bar-bar-bar-";
    
    for (int i = offset, n = i + range; i < n; ++i) {
      String value = prefix + i;
      map.put(i, value);
      if (i > offset && i % batch == 0 || i == n - 1) {
        String last = map.get(i);
        if (!last.equals(value)) {
          throw new AssertionError("Last value not matched at i " + i);
        }
        if (tryCommit) store.tryCommit();
        else store.commit();
      }
    }
    return map.size();
  }

}