import java.io.*;
import java.util.*;
import java.util.zip.*;

/**
 * Outputs the versionCode and versionName of the APK files you input.
 * You can pass in -v or -d for verbose debugging information.
 */
public final class APK {

  private boolean v;

  public static void main(String[] args) {
    System.exit(new APK().realMain(args));
  }

  public int realMain(String[] args) {
    int res = 0;
    List<String> files = new ArrayList<String>();
    for (String arg : args) {
      if (arg.startsWith("-v") || arg.startsWith("-d")) {
	v = true;
      } else {
	files.add(arg);
      }
    }
    for (String fileName : files) {
      res |= read(fileName);
    }
    return res;
  }

  private final static class PackedInputStream {
    private final InputStream in;
    private int pos;
    PackedInputStream(InputStream in) {
      this.in = in;
    }
    public int pos() {
      return pos;
    }
    public int read() throws IOException {
      pos++;
      return 0xff & in.read();
    }
    public int readBytes() throws IOException {
      int a = read() << 24;
      int b = read() << 16;
      int c = read() <<  8;
      int d = read() <<  0;
      return a + b + c + d;
    }
    public int readInt() throws IOException {
      int a = read() <<  0;
      int b = read() <<  8;
      int c = read() << 16;
      int d = read() << 24;
      return a + b + c + d;
    }
    public int readShort() throws IOException {
      int a = read() <<  0;
      int b = read() <<  8;
      return a + b;
    }
    public char readChar() throws IOException {
      int v = read();
      read();
      return (char)v;
    }
    public String readString() throws IOException {
      return readString(readShort());
    }
    public String readString(int len) throws IOException {
      char[] arr = new char[len];
      for (int i=0; i<arr.length; i++) {
	arr[i] = readChar();
      }
      readChar();
      return new String(arr);
    }
    public void close() throws IOException {
      in.close();
    }
  }


  private int read(String fileName) {
    ZipFile z = null;
    try {
      z = new ZipFile(new File(fileName),ZipFile.OPEN_READ);
    } catch (IOException e) {
      e.printStackTrace();
    }
    if (z == null) return 0x1;

    ZipEntry e = z.getEntry("AndroidManifest.xml");
    if (e == null) {
      System.err.println("Couldn't find manifest");
      return 0x2;
    }
    PackedInputStream in = null;
    try {
      in = new PackedInputStream(z.getInputStream(e));
    } catch (IOException ex) {
      ex.printStackTrace();
    }
    if (in == null) return 0x4;

    try {

      // The first thing is the magic number
      if (assertEqual(0x03000800,in.readBytes(),"magic number")) {
	return 0xa;
      }
      
      // Then, the file length, though we don't care about that
      noteInt(in,"file length");
      if (assertEqual(0x01001c00,in.readBytes(),"something")) {
	return 0xa;
      }
      
      // There's stuff after this, not sure what?
      // More stuff follows -- 4 of them
      noteBytes(in,"something");
      int numStrings = noteInt(in,"# strings");
      for (int i=0 ;i<4; i++) noteBytes(in,"? #" + i);

      // String offsets -- we don't use these
      int[] offsets = new int[numStrings];
      for (int i=0; i<offsets.length; i++) {
	offsets[i] = noteInt(in,"String #" + i);
      }

      // String table -- we use this
      List<String> strings = new ArrayList<String>();
      for (int i=0; i<numStrings; i++) {
	String s = noteString(in,"String #" + i);
	strings.add(s);
      }
      
      int indexOfManifest = strings.indexOf("manifest");
      int indexOfVersionCode = strings.indexOf("versionCode");
      int indexOfVersionName = strings.indexOf("versionName");
      note("indexOfManifest",indexOfManifest);
      note("indexOfVersionCode",indexOfVersionCode);
      note("indexOfVersionName",indexOfVersionName);

      // Search for two 0xffff's followed by the start manifest tag
      // This couldn't be grosser!
      while (in.readShort() != 0xffff) {
	if (in.readShort() != 0xffff) continue;
	if (in.readShort() != 0xffff) continue;
	if (in.readShort() == 0xffff) break;
      }
      while (in.readShort() != indexOfManifest) {}

      // Read to the next 0xffff and one behind and get the build number
      while (in.readShort() != 0xffff) {}
      in.readInt();
      in.readShort();
      int versionCode = noteInt(in,"versionCode");

      // Read to the next instance of indexOfVersionName and the next
      // value will an index into the string table of the version name
      while (in.readInt() != indexOfVersionName) {}
      String versionName = strings.get(in.readInt());

      // Print the results
      System.out.println("Results -----------------------");
      out("versionCode",versionCode);
      out("versionName",versionName);
      
    } catch (IOException ex) {
      ex.printStackTrace();
    } finally {
      try {
	in.close();
      } catch (IOException ex) {
	ex.printStackTrace();
      }
    }
   
    return 0;
  }

  private String noteString(PackedInputStream in, String msg) throws IOException {
    String v = in.readString();
    note(msg,v);
    return v;
  }

  private int noteInt(PackedInputStream in, String msg) throws IOException {
    int v = in.readInt();
    note(msg,v);
    return v;
  }

  private int noteBytes(PackedInputStream in, String msg) throws IOException {
    int v = in.readBytes();
    note(msg,v);
    return v;
  }

  private boolean assertEqual(int want, int have, String msg) {
    if (want != have) {
      err(msg + ": " + x(have) + " != " + x(want));
      return true;
    }
    note(msg,have);
    return false;
  }

  private void err(Object msg) {
    System.err.println(msg);
  }
  
  private void note(String label, int value) {
    if (v) System.err.println(String.format("%-20s: %x",label,value));
  }
  
  private void note(String label, String value) {
    if (v) System.err.println(String.format("%-20s: %s",label,value));
  }
  
  private void out(String label, Object value) {
    System.out.println(String.format("%-20s: %s",label,value));
  }
  
  private String x(int v) {
    return Integer.toString(v,16);
  }
  
}