package NET.worlds.network;

import NET.worlds.console.StatNetMUNode;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.util.Vector;

public class netPacketReader extends Thread {
   private Vector<receivedNetPacket> _msgQ;
   private ServerInputStream _in;
   private WorldServer _serv;
   private static Class<receivedNetPacket>[] msgTable = new Class[255];

   static {
      String basePath = "NET.worlds.network.";
      Vector<String> cmdList = new netCmds().recvCmdList();

      for (int i = 0; i < cmdList.size(); i++) {
         String cmdName = basePath + cmdList.elementAt(i);

         try {
            Class<receivedNetPacket> tmpCmdClass = (Class<receivedNetPacket>)Class.forName(cmdName);
            receivedNetPacket tmpInstance = tmpCmdClass.newInstance();
            int indx = tmpInstance.msgID();

            assert indx > -1;

            assert msgTable[indx] == null;

            msgTable[indx] = tmpCmdClass;
         } catch (NoSuchMethodError var11) {
            NoSuchMethodError e = var11;
            synchronized (System.out) {
               System.out.println("netPacketReader:: " + e.getClass().getName() + " creating " + cmdName);
               System.out.println("netPacketReader:: Exception: " + e.getMessage());
               e.printStackTrace(System.out);
            }

            assert false;
         } catch (Exception var12) {
            Exception e = var12;
            synchronized (System.out) {
               System.out.println("netPacketReader:: " + e.getClass().getName() + " creating " + cmdName);
               System.out.println("netPacketReader:: Exception: " + e.getMessage());
               e.printStackTrace(System.out);
            }

            assert false;
         }
      }
   }

   public netPacketReader(ServerInputStream in) {
      this._in = in;
      this._msgQ = new Vector<receivedNetPacket>();
   }

   public netPacketReader(WorldServer serv, ServerInputStream in) {
      this._serv = serv;
      this._in = in;
      this._msgQ = new Vector<receivedNetPacket>();
      this._in.setVersion(this.getVersion());
   }

   public void setVersion(int vers) {
      this._in.setVersion(vers);
   }

   public int getVersion() {
      return this._serv.getVersion();
   }

   public void put(receivedNetPacket pkt) {
      this._msgQ.addElement(pkt);
   }

   public receivedNetPacket get() {
      assert this._msgQ != null;

      if (this._msgQ.isEmpty()) {
         return null;
      } else {
         receivedNetPacket packet = this._msgQ.firstElement();
         this._msgQ.removeElement(packet);
         return packet;
      }
   }

   public int count() {
      return this._msgQ.size();
   }

   private final void buildMsg() throws IOException {
      this._in.readPacketSize();
      byte[] packetData = new byte[this._in.bytesLeft() + 1];
      packetData[0] = (byte)(this._in.bytesLeft() + 1);
      this._in.readFully(packetData, 1, this._in.bytesLeft());
      StatNetMUNode netStat = StatNetMUNode.getNode();
      netStat.addBytesRcvd(packetData.length);
      netStat.addPacketsRcvd(1);
      ServerInputStream in = new ServerInputStream(new ByteArrayInputStream(packetData));
      in.readPacketSize();
      if ((WorldServer.getDebugLevel() & 2048) > 0) {
         synchronized (System.out) {
            System.out.print(this._serv + ": recv[");

            for (int i = 0; i < packetData.length; i++) {
               System.out.print(Integer.toString(packetData[i] & 255, 16) + " ");
            }

            System.out.println("]");
         }
      }

      receivedNetPacket packet = null;
      ObjID objID = new ObjID();
      objID.parseNetData(in);
      boolean isCO = objID.shortID() == 254;
      int cmdType = in.readUnsignedByte();
      if (cmdType < msgTable.length && msgTable[cmdType] != null) {
         do {
            if (isCO) {
               objID = new ObjID();
               objID.parseNetData(in);
            }

            try {
               packet = msgTable[cmdType].newInstance();
            } catch (Exception var8) {
               System.out.println(var8 + ": " + var8.getMessage());

               assert false;
            }

            packet.init(objID);
            packet.parseNetData(in);
            this._msgQ.addElement(packet);
            yield();
         } while (!in.isEmpty() && isCO);

         assert in.isEmpty();
      } else {
         System.out.println("UNKNOWN SERVER MSG#" + String.valueOf(cmdType));
         in.skipBytes(in.bytesLeft());

         assert in.isEmpty();
      }
   }

   @Override
   public void run() {
      try {
         while (true) {
            this.buildMsg();
         }
      } catch (IOException var2) {
         this._msgQ.addElement(new ExceptionCmd(var2));
      }
   }
}