/* Btree.java 
   
   source : Btree.java
   compile: javac Btree.java
   run    : java Btree <btree.dat
   NOTE   : needs IO.java and IO.class from same directory

   compare results with C version:

   source : btree.c
   run    : btree <btree.dat

Assignment:

   Convert the commented-out C code here into Java. 
   Uncomment as you go along.
   Search on Convert # for recommended order of conversion
*/

/* C version
typedef struct node_tag{
  int count;
  Key_type key[MAX+1];
  struct node_tag *branch[MAX+1];
}Node_type;
*/

// Converted
class Node_type {
  public int count;
  public char key[] = new char[Btree.MAX+1];
  public Node_type branch[] = new Node_type[Btree.MAX+1];
};

public class Btree {

   // Converted
   public static void main (String args[]) {
   
     if (args.length == 0)
       io = new IO(System.in,System.out);
     else
       io = new IO(args[0],System.out);
     interact();

   }

static final int MAX = 4;
static final int MIN = 2;
static final int MAXD = 10;
static final int MAXWD = 50;

// typedef char Key_type; just use char in Java

/* C version
int step=0;
int cnt[MAXD];
int levels;
int loc[MAXD][MAXWD];
Node_type *ptrs[MAXD][MAXWD];
Node_type *root;
int silent = 0;
FILE *fp;
*/

// Converted
static int step=0;
static int cnt[] = new int[MAXD];
static int levels;
static int loc[][] = new int[MAXD][MAXWD];
static Node_type ptrs[][] = new Node_type[MAXD][MAXWD];
static Node_type root;
static IO io;


/* C version
void Error(char *msg)
{
  printf("%s\n",msg);
}
*/

// Converted 
static void Error(String msg)
{
  io.println(msg);            // note that there is an io.print(String) also
}

/* C version
void DFS(Node_type *p, int depth)
{
  int i;

  if (p != NULL) {
    if (depth>levels) levels=depth;
    ptrs[depth][cnt[depth]] = p;
    cnt[depth]++;

    for (i=0; i<=p->count; i++)
      DFS(p->branch[i],depth+1);
  }
}
*/

// Converted
static void DFS(Node_type p, int depth)
{
  int i;

  if (p != null) {
    if (depth>levels) levels=depth;
    ptrs[depth][cnt[depth]] = p;
    cnt[depth]++;
  
    for (i=0; i<=p.count; i++)
      DFS(p.branch[i],depth+1); 
  }
}

// Converted except to uncomment Delete and PrintAllNodes
static void interact()
{
  char key;
  root = null;

  for (;;) {
    io.print("> ");
    String s = io.getLine(); 
    if (s.length() > 0) {
      char cmd = s.charAt(0);
      switch (cmd) {
      case 'q' : return;
      case 'h' : io.println("h(elp; q(uit; i(nsert x; d(elete x; p(rint\n");
                 break;
      case 'i' : key = s.charAt(2);
                 io.println("INSERT: "+ key); 
                 root=Insert(key,root);
                 break;     
      case 'd' : key = s.charAt(2);
                 io.println("DELETE: "+key); 
                 // uncomment when Delete is converted
                 // root=Delete(key,root);
                 break;
      case 'p' : io.println("B-TREE:"); 
                 // uncomment when PrinAllNodes is converted
                 //  PrintAllNodes(root);
                 break;
      } // end switch
    } // end if
  } // end for
}

/* 
BEGIN: ONE GIANT COMMENT

// Convert #1
void ListNode(int depth,int cnt,Node_type *p)
{
  int i;
  
  printf("%d %d ",depth,cnt);
  for (i=1; i<=p->count; i++)
    printf("%c ",p->key[i]);
  printf("\n");
}

// Convert #2
void SetLoc()
{
  int i,depth,pos,base,first,last,dist,x;

  depth = levels;
  pos = 0;
  for (i=0; i<cnt[depth]; i++){
    loc[depth][i] = pos; 
    pos += (ptrs[depth][i]->count)*2+2;
  }
  for (depth=levels-1; depth>=0; depth--){
    base = 0;
    for (i=0; i<cnt[depth]; i++){
       first = base;
       last  = first+(ptrs[depth][i]->count);
       dist = (loc[depth+1][last] - loc[depth+1][first] + 2*ptrs[depth+1][last]->count)/2;
       loc[depth][i] = loc[depth+1][first]+dist-ptrs[depth][i]->count;
       base += ptrs[depth][i]->count+1;
    }
  }
}

// Convert #3
void MoveRight(Node_type *p,int k)
{
  int c;
  Node_type *t;

  t = p->branch[k];
  for (c=t->count; c>0; c--){
     t->key[c+1]=t->key[c];
     t->branch[c+1]=t->branch[c];
  }
  t->branch[1] = t->branch[0];  
  t->count++;
  t->key[1]=p->key[k];
  t=p->branch [k-1];  
  p->key[k]=t->key[t->count];
  p->branch[k]->branch[0]=t->branch[t->count];
  t->count--;
}

// Convert #4
void MoveLeft(Node_type *p,int k)
{
  int c;
  Node_type *t;

  t = p->branch[k-1];
  t->count++;
  t->key[t->count] = p->key[k];
  t->branch[t->count] = p->branch[k]->branch[0];
  t = p->branch[k];
  p->key[k] = t->key[1];
  t->branch[0] = t->branch[1];
  t->count--;
  for (c=1; c<=t->count; c++){
    t->key[c] = t->key[c+1];
    t->branch[c] = t->branch[c+1];
  }
}

// Convert #5
void Combine(Node_type *p,int k)
{
  int c;
  Node_type *q; 
  Node_type *l;

  q = p->branch[k];
  l = p->branch[k-1];  
  l->count++;          
  l->key[l->count] = p->key[k];
  l->branch[l->count] = q->branch[0];
  for (c=1; c<=q->count; c++){  
    l->count++;
    l->key[l->count] = q->key[c];
    l->branch[l->count] = q->branch[c];
  }
  for (c=k; c<p->count; c++){  
    p->key[c] = p->key[c+1];
    p->branch[c] = p->branch[c+1];
  }
  p->count--;
  free(q);    
}

// Convert #6
void Restore(Node_type *p, int k)
{
  if (k==0)                
    if (p->branch[1]->count > MIN)
      MoveLeft(p,1);
    else
      Combine(p,1);
  else 
    if (k==p->count)    
      if (p->branch[k-1]->count > MIN)
        MoveRight(p,k);
      else
        Combine(p,k);
    else 
      if (p->branch[k-1]->count> MIN) 
        MoveRight(p,k);
      else 
        if (p->branch[k+1]->count> MIN)
          MoveLeft(p,k+1);
        else 
          Combine(p,k);
}

// Convert #7
void Remove(Node_type *p,int k)
{
  int i;  
  for (i=k+1; i<=p->count; i++){
    p->key[i-1] = p->key[i];
    p->branch[i-1] = p->branch[i];
  }
  p->count--;
}

// Convert #8
void Successor(Node_type *p, int k)
{
  Node_type *q;  
  for (q=p->branch[k]; q->branch[0]; q=q->branch[0]) 
    ;
  p->key[k]=q->key[1];
}

// Convert #9
void PushIn(Key_type x,Node_type *xr,Node_type *p, int k)  
{
   int i;               
	
   for (i = p->count; i > k; i--) {
     p->key[i+1] = p->key[i];
     p->branch[i+1] = p->branch[i];
   }
   p->key[k+1] = x;
   p->branch[k+1] = xr;
   p->count++;
}                 

// Convert #10
// How can parameters be call-by-ref in Java? Not allowed to make global.
// Try to think of a simple - but good OO - way to handle all of these 
// call-by-ref params in the source. You do not want to make a mistake 
// or the program will be impossible to debug.

void PrintNode(Node_type *p, int depth, int i, int *pos)  // CALL-BY-REF
{
  int j;
  while ((*pos)<loc[depth][i]) {
    printf(" ");
    (*pos)++;
  }
  printf("[");
  for (j=1; j<p->count; j++){
    printf("%c,",p->key[j]);
    (*pos) += 2;
  }
  printf("%c]",p->key[j]);
  (*pos)+=3;
}

// Convert #11
void PrintTop(Node_type *p, int depth, int i, int *pos, int *child) // CALL-BY-REF
{
  int j,strt,mid;

  mid = loc[depth][i]+p->count;
  for (j=0; j<=p->count; j++) {
    strt = loc[depth+1][*child]+1;
    if (strt>=mid)
      strt += 2*p->branch[j]->count-2;

    while ((*pos)<strt) {
      printf(" ");
      (*pos)++;
    }
  
    if (strt<=mid)
      printf("/");
    else
      printf("\\");
    (*pos)++; 
    (*child)++;
  }
}

// Convert #12
void PrintLine(Node_type *p, int depth, int i, int *pos, int *child) // CALL-BY-REF
{
  int strt,stop,mid;

  strt = loc[depth+1][*child]+2;
  stop = loc[depth+1][*child+p->count]+p->branch[p->count]->count*2-2;
  mid = loc[depth][i]+p->count;
  *child += p->count+1;
  while ((*pos)<strt) {
    printf(" ");
    (*pos)++;
  }
  while ((*pos)<=stop) {
    if (*pos==mid) 
      printf("|");
    else
      printf("_");
    (*pos)++;
  }
}

// Convert #13
void PrintAllNodes(Node_type *root)
{
  int i,depth,pos,child;

  if (root==NULL)
    printf("EMPTY\n");
  else {
    for (depth=0; depth<MAXD; depth++) 
      cnt[depth]=0;
    levels=0; 
    DFS(root,0);
    SetLoc();
    printf("L\n");
    for (depth=0; depth<=levels; depth++) {
      printf("%d",depth);
      pos=-1;
      for (i=0; i<cnt[depth]; i++)
        PrintNode(ptrs[depth][i],depth,i,&pos);
      printf("\n");
      if (depth < levels) {
        pos=-2;
        child=0;
        for (i=0; i<cnt[depth]; i++)
          PrintLine(ptrs[depth][i],depth,i,&pos,&child);
        printf("\n");
        pos=-2;
        child=0;
        for (i=0; i<cnt[depth]; i++)
          PrintTop(ptrs[depth][i],depth,i,&pos,&child);
        printf("\n");
      } 
    } 
    printf("\n");
  }
}

// Convert #14
Bool SeqSearch(Key_type target,Node_type *p, int *k)  // CALL-BY-REF
{
  if (target < p->key[1]) {  
    *k = 0;
    return FALSE;
  } 
  else {
    *k = p->count;
    while ((target<p->key[*k]) && *k > 1) {
      (*k)--;
      step++; 
    }
    return (target==p->key[*k]);
  }
}

// Convert #15
void Split(Key_type x, Node_type *xr, Node_type *p, int k, Key_type *y, Node_type **yr) // CALL-BY-REF
{
  int i;              
  int median;

  if (k <= MIN)
    median = MIN;
  else
    median = MIN + 1;
  
  *yr = (Node_type *)malloc(sizeof(Node_type));
  for (i = median+1; i <= MAX; i++) {  
    (*yr)->key[i-median] = p->key[i];
    (*yr)->branch[i-median] = p->branch[i];
  }
  (*yr)->count = MAX - median;
  p->count = median;
  if (k <= MIN) 
   PushIn(x,xr,p,k);
  else
    PushIn(x,xr,*yr,k - median);
  *y = p->key[p->count];
  (*yr)->branch[0] = p->branch[p->count];
   p->count--;
}

// Convert #16
Bool PushDown(Key_type newkey,Node_type *p,Key_type *x, Node_type **xr) // CALL-BY-REF
{
  int k;   
  if (p == NULL) {  
    *x = newkey;
    *xr = NULL;
    return TRUE;
  } 
  else {        
    if (SeqSearch(newkey,p,&k))
      Error("inserting duplicate key");
    if (PushDown(newkey,p->branch[k],x,xr))
      if (p->count < MAX) {
        PushIn(*x,*xr,p,k);
        return FALSE;
      } 
    else {
      Split(*x,*xr,p,k,x,xr);
      return TRUE;
    }
    return FALSE;
  }
}

// Convert #17
Bool RecDelete(Key_type target,Node_type *p)
{
  int k;  
  Bool found;

  if (p==NULL)
    return FALSE;    
  else {
    found=SeqSearch(target,p,&k);
    if (found)
      if (p->branch[k-1]) {     
        Successor(p,k);  
        if (!(found=RecDelete(p->key[k],p->branch[k]))) Error("Key not found.");
      } else
          Remove(p,k); 
    else                 
      found=RecDelete(target,p->branch[k]);
      if (p->branch[k] != NULL)
        if (p->branch[k]->count<MIN)
          Restore(p,k);
    return found;
  }
}

// Convert #18
Node_type *Delete(Key_type target, Node_type *root)
{
   Node_type *p,*t;      
	
   t = root;
   if (!RecDelete(target, t))
     Error("Target was not in the B-tree.");
   else 
     if (root->count == 0) {  
       p = root;
       root = root->branch[0];
       free(p);
     }
  return root;
}

END: ONE GIANT COMMENT
*/

// C version Node_type *Insert(Key_type newkey, Node_type *root)

// Convert #19
static Node_type Insert(char newkey, Node_type root)
{
  /* NEED TO CONVERT THE BODY
  Key_type x;   
  Node_type *xr;        
  Node_type *p; 
  Bool pushup; 

  pushup = PushDown(newkey,root,&x,&xr);
  if (pushup) {  
    p = (Node_type *)malloc(sizeof(Node_type)); 
    p->count = 1;
    p->key[1] = x;
    p->branch[0] = root;
    p->branch[1] = xr;
    return p;
  }
  */
  return root;
}

} // end Btree class