/*
 * Copyright 2007 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.tonicsystems.jarjar.util;

import java.io.*;
import java.lang.reflect.Array;
import java.util.*;

public class ClassHeaderReader {
  private int access;
  private String thisClass;
  private String superClass;
  private String[] interfaces;

  private InputStream in;
  private byte[] b = new byte[0x2000];
  private int[] items = new int[1000];
  private int bsize = 0;
  private MyByteArrayInputStream bin = new MyByteArrayInputStream();
  private DataInputStream data = new DataInputStream(bin);

  public int getAccess() {
    return access;
  }

  public String getClassName() {
    return thisClass;
  }

  public String getSuperName() {
    return superClass;
  }

  public String[] getInterfaces() {
    return interfaces;
  }

  public void read(InputStream in) throws IOException {
    try {
      this.in = in;
      bsize = 0;
      access = 0;
      thisClass = superClass = null;
      interfaces = null;

      try {
        buffer(4);
      } catch (IOException e) {
        // ignore
      }
      if (b[0] != (byte) 0xCA
          || b[1] != (byte) 0xFE
          || b[2] != (byte) 0xBA
          || b[3] != (byte) 0xBE) {
        throw new ClassFormatError("Bad magic number");
      }

      buffer(6);
      readUnsignedShort(4); // minorVersion
      readUnsignedShort(6); // majorVersion
      // TODO: check version
      int constant_pool_count = readUnsignedShort(8);
      items = (int[]) resizeArray(items, constant_pool_count);

      int index = 10;
      for (int i = 1; i < constant_pool_count; i++) {
        int size;
        buffer(index + 3); // TODO: reduce calls to buffer
        int tag = b[index];
        items[i] = index + 1;
        switch (tag) {
          case 9: // Fieldref
          case 10: // Methodref
          case 11: // InterfaceMethodref
          case 3: // Integer
          case 4: // Float
          case 12: // NameAndType
            size = 4;
            break;
          case 5: // Long
          case 6: // Double
            size = 8;
            i++;
            break;
          case 1: // Utf8
            size = 2 + readUnsignedShort(index + 1);
            break;
          case 7: // Class
          case 8: // String
            size = 2;
            break;
          default:
            throw new IllegalStateException("Unknown constant pool tag " + tag);
        }
        index += size + 1;
      }
      buffer(index + 8);
      access = readUnsignedShort(index);
      thisClass = readClass(index + 2);
      superClass = readClass(index + 4);
      int interfaces_count = readUnsignedShort(index + 6);

      index += 8;
      buffer(index + interfaces_count * 2);
      interfaces = new String[interfaces_count];
      for (int i = 0; i < interfaces_count; i++) {
        interfaces[i] = readClass(index);
        index += 2;
      }
    } finally {
      in.close();
    }
  }

  private String readClass(int index) throws IOException {
    index = readUnsignedShort(index);
    if (index == 0) {
      return null;
    }
    index = readUnsignedShort(items[index]);
    bin.readFrom(b, items[index]);
    return data.readUTF();
  }

  private int readUnsignedShort(int index) {
    byte[] b = this.b;
    return ((b[index] & 0xFF) << 8) | (b[index + 1] & 0xFF);
  }

  private static final int CHUNK = 2048;

  private void buffer(int amount) throws IOException {
    if (amount > b.length) {
      b = (byte[]) resizeArray(b, b.length * 2);
    }
    if (amount > bsize) {
      int rounded = (int) (CHUNK * Math.ceil((float) amount / CHUNK));
      bsize += read(in, b, bsize, rounded - bsize);
      if (amount > bsize) {
        throw new EOFException();
      }
    }
  }

  private static int read(InputStream in, byte[] b, int off, int len) throws IOException {
    int total = 0;
    while (total < len) {
      int result = in.read(b, off + total, len - total);
      if (result == -1) {
        break;
      }
      total += result;
    }
    return total;
  }

  private static Object resizeArray(Object array, int length) {
    if (Array.getLength(array) < length) {
      Object newArray = Array.newInstance(array.getClass().getComponentType(), length);
      System.arraycopy(array, 0, newArray, 0, Array.getLength(array));
      return newArray;
    } else {
      return array;
    }
  }

  private static class MyByteArrayInputStream extends ByteArrayInputStream {
    public MyByteArrayInputStream() {
      super(new byte[0]);
    }

    public void readFrom(byte[] buf, int pos) {
      this.buf = buf;
      this.pos = pos;
      count = buf.length;
    }
  }
}