package jp.ac.u_ryukyu.ie.cr.tatsuki.xml;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.nio.ByteBuffer;
import java.util.Random;

import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.DefaultJungle;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.Jungle;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultTreeEditor;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultTraverser;

public class TransactionPerSecondMeasurement {

  public static void main(String[] args) throws InterruptedException, IOException {
    Jungle jungle = new DefaultJungle(null, "hoge", new DefaultTreeEditor(new DefaultTraverser()));
    JungleTree tree = jungle.createNewTree("testTree");
    JungleTreeEditor editor = tree.getTreeEditor();
    editor = createTree(0, new DefaultNodePath(), editor);
    System.out.println("endCreateTree");
    editor = editor.success().b();
    System.out.println(Runtime.getRuntime().availableProcessors());

    if (args.length > 0) {
      if (args[0].equals("read"))
        readOnly(tree);
      if (args[0].equals("write"))
        readAndWrite(tree);
    } else
      System.out.println("Please with the argument");
  }

  private static void readAndWrite(JungleTree tree) throws InterruptedException, IOException {
    System.out.println("read and write");
    File file = new File("./time/readAndWrite");
    PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter(file)));
    for (int THREAD_COUNT = 1; THREAD_COUNT <= 12; THREAD_COUNT++) {
      ReadJungleThread readThread[] = new ReadJungleThread[THREAD_COUNT];
      for (int count = 0; THREAD_COUNT > count; count++) {
        readThread[count] = new ReadJungleThread(tree);
      }

      WriteJungleThread writeThread =  new WriteJungleThread(tree);
      writeThread.start();
      for (int count = 0; THREAD_COUNT > count; count++) {
        readThread[count].start();
      }

      System.out.println("StartThread");

      Thread.sleep(10000);
      writeThread.set(false);
      int readCount = 0;

      for (int count = 0; THREAD_COUNT > count; count++) {
        readCount = readCount + readThread[count].getFindCount();
        readThread[count].set(false);
        System.out.println(readThread[count].getFindCount());
      }


      pw.println(THREAD_COUNT + " " + readCount);
      System.out.println(THREAD_COUNT + "readCount = " + readCount);
      Thread.sleep(1000);
    }
    pw.close();
  }

  private static void readOnly(JungleTree tree) throws InterruptedException, IOException {
    System.out.println("read only");
    File file = new File("./time/readOnly");
    PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter(file)));
    for (int THREAD_COUNT = 1; THREAD_COUNT <= 12; THREAD_COUNT++) {
      ReadJungleThread readThread[] = new ReadJungleThread[THREAD_COUNT];
      ;
      for (int count = 0; THREAD_COUNT > count; count++) {
        readThread[count] = new ReadJungleThread(tree);
      }

      for (int count = 0; THREAD_COUNT > count; count++) {
        readThread[count].start();
      }

      System.out.println("StartThread");

      Thread.sleep(10000);
      int readCount = 0;

      for (int count = 0; THREAD_COUNT > count; count++) {
        readCount = readCount + readThread[count].getFindCount();
        readThread[count].set(false);
        System.out.println(readThread[count].getFindCount());
      }
      pw.println(THREAD_COUNT + " " + readCount);
      System.out.println(THREAD_COUNT + "readCount = " + readCount);
    }
    pw.close();
  }

  static String key = "KEY";

  public static JungleTreeEditor createTree(int deep, NodePath path, JungleTreeEditor editor) {

    Random rnd = new Random();
    String value1 = String.valueOf(rnd.nextInt(1000));
    String value2 = String.valueOf(rnd.nextInt(1000));
    editor = editor.addNewChildAt(path, 0).b();
    editor = editor.putAttribute(path.add(0), key, ByteBuffer.wrap(value1.getBytes())).b();
    editor = editor.addNewChildAt(path, 1).b();
    editor = editor.putAttribute(path.add(0), key, ByteBuffer.wrap(value2.toString().getBytes())).b();
    deep++;

    if (deep < 10) {
      editor = createTree(deep, path.add(0), editor);
      editor = createTree(deep, path.add(1), editor);
    }
    return editor;
  }
}