break;

        case 5: // '\005'
            RecCDeliver reccdeliver = new RecCDeliver();
            recccmpppacket.recDeliver = reccdeliver;
            RecCDeliverRcpt reccdeliverrcpt = new RecCDeliverRcpt();
            recccmpppacket.recReceipt = reccdeliverrcpt;
            i = nCMPP_ParseDeliver(cmpppacket, recccmpppacket.recDeliver, recccmpppacket.recReceipt);
            break;

        case -2147483642:
            RecCQueryRep reccqueryrep = new RecCQueryRep();
            recccmpppacket.recQueryRep = reccqueryrep;
            i = nCMPP_ParseQueryRep(cmpppacket, recccmpppacket.recQueryRep);
            break;

        case -2147483641:
            RecCCancelRep recccancelrep = new RecCCancelRep();
            recccmpppacket.recCancelRep = recccancelrep;
            i = nCMPP_ParseCancelRep(cmpppacket, recccmpppacket.recCancelRep);
            break;

        case 8: // '\b'
            RecCActiveTest reccactivetest = new RecCActiveTest();
            recccmpppacket.recActiveTest = reccactivetest;
            i = nCMPP_ParseActive(cmpppacket, recccmpppacket.recActiveTest);
            break;

        case -2147483640:
            RecCActiveTestRep reccactivetestrep = new RecCActiveTestRep();
            recccmpppacket.recActiveTestRep = reccactivetestrep;
            i = nCMPP_ParseActiveRep(cmpppacket, recccmpppacket.recActiveTestRep);
            break;
        }
        return i;
    }

    public int nCMPP_ReplyTerminate(RecCTerminateRep reccterminaterep)
    {
        byte byte0 = -1;
        if(reccterminaterep == null)
            return byte0;
        cmppTerminateRep cmppterminaterep = new cmppTerminateRep(sock);
        cmppterminaterep.setSequenceId(reccterminaterep.nSeqId);
        int i = cmppterminaterep.sendTerminateRep();
        if(i < 0)
            return i;
        else
            return byte0;
    }

    public int nCMPP_SendActive()
    {
        if(sock == null)
            return -1;
        cmppActiveTest cmppactivetest = new cmppActiveTest(sock);
        synchronized(sock)
        {
            cmppactivetest.setSequenceId(sock.seq);
            sock.seq++;
            if(sock.seq == 0x7fffffff)
                sock.seq = 2;
        }
        int i = cmppactivetest.sendActiveTest();
        return i;
    }

    public int nCMPP_SendActiveRep(RecCActiveTestRep reccactivetestrep)
    {
        if(sock == null)
            return -1;
        if(reccactivetestrep == null)
        {
            return -2;
        } else
        {
            cmppActiveTestRep cmppactivetestrep = new cmppActiveTestRep(sock);
            cmppactivetestrep.setSequenceId(reccactivetestrep.nSeqId);
            cmppactivetestrep.setSuccessId(reccactivetestrep.ucSuccId);
            int i = cmppactivetestrep.sendcmppActivetestRep();
            return i;
        }
    }

    public int nCMPP_SendCancel(RecCCancel recccancel)
    {
        int i = -1;
        if(recccancel == null)
            return i;
        cmppCancel cmppcancel = new cmppCancel(sock);
        synchronized(sock)
        {
            i = sock.seq;
            recccancel.nSeqId = i;
            cmppcancel.setSequenceId(sock.seq);
            sock.seq++;
            if(sock.seq == 0x7fffffff)
                sock.seq = 2;
        }
        cmppcancel.setMsgId(recccancel.usMsgId);
        int j = cmppcancel.sendcmppCancel();
        if(j < 0)
            return j;
        else
            return i;
    }

    public int nCMPP_SendDeliverRep(RecCDeliverRep reccdeliverrep)
    {
        if(reccdeliverrep == null)
        {
            return -1;
        } else
        {
            cmppDeliverRep cmppdeliverrep = new cmppDeliverRep(sock);
            cmppdeliverrep.setSequenceId(reccdeliverrep.nSeqId);
            cmppdeliverrep.setcmppDeliverRep(reccdeliverrep.usMsgId, reccdeliverrep.ucResult);
            int i = cmppdeliverrep.sendcmppDeliverRep();
            return i;
        }
    }

    public int nCMPP_SendPacket(RecCCMPPPacket recccmpppacket)
    {
        byte byte0 = -1;
        if(recccmpppacket == null)
            return byte0;
        int i = -1;
        switch(recccmpppacket.nCmdId)
        {
        default:
            break;

        case 1: // '\001'
            i = nCMPP_Connect();
            break;

        case 2: // '\002'
            i = nCMPP_Terminate();
            break;

        case 4: // '\004'
            i = nCMPP_SendSubmit(recccmpppacket.recSubmit, recccmpppacket.recSubmit.sValidTime, recccmpppacket.recSubmit.sDstTermId, recccmpppacket.recSubmit.ucMsgLen, recccmpppacket.recSubmit.usMsgContent);
            break;

        case -2147483643:
            i = nCMPP_SendDeliverRep(recccmpppacket.recDeliverRep);
            break;

        case 6: // '\006'
            if(recccmpppacket == null)
                System.out.println("precPkg is null");
            i = nCMPP_SendQuery(recccmpppacket.recQuery);
            break;

        case 7: // '\007'
            i = nCMPP_SendCancel(recccmpppacket.recCancel);
            break;

        case 8: // '\b'
            i = nCMPP_SendActive();
            break;

        case -2147483640:
            i = nCMPP_SendActiveRep(recccmpppacket.recActiveTestRep);
            break;
        }
        return i;
    }

    public int nCMPP_SendQuery(RecCQuery reccquery)
    {
        int i = -1;
        if(reccquery == null)
            return i;
        cmppQuery cmppquery = new cmppQuery(sock);
        synchronized(sock)
        {
            i = sock.seq;
            cmppquery.setSequenceId(sock.seq);
            sock.seq++;
            if(sock.seq == 0x7fffffff)
                sock.seq = 2;
        }
        cmppquery.setcmppQuerys(reccquery.sTime, reccquery.ucQueryType, reccquery.sQueryCode, reccquery.usReserve);
        int j = cmppquery.sendcmppQuery();
        if(j < 0)
            return j;
        else
            return i;
    }

    public int nCMPP_SendSubmit(RecCSubmit reccsubmit, String s, String s1, int i, byte abyte0[])
    {
        if(reccsubmit == null || s1 == null || abyte0 == null)
            return -1;
        if(sock == null)
            return -7;
        reccsubmit.sValidTime = s;
        reccsubmit.sDstTermId = s1;
        reccsubmit.ucMsgLen = i;
        reccsubmit.usMsgContent = abyte0;
        Vector vector = parseAllSubscribers(s1);
        if(vector == null)
            return -2;
        int j = getSendtimes(abyte0);
        synchronized(sock)
        {
            reccsubmit.nSeqId = sock.seq;
        }
        int k = 0;
        for(int l = 0; l < vector.size(); l++)
        {
            String s2 = (String)vector.elementAt(l);
            if(s2 != null)
            {
                cmppSubmit cmppsubmit = new cmppSubmit(sock);
                cmppsubmit.setMsgId(reccsubmit.usMsgId);
                cmppsubmit.setPkTotal(reccsubmit.ucPkTotal);
                cmppsubmit.setPkNumber(reccsubmit.ucPkNumber);
                cmppsubmit.setRegisteredDelivery(reccsubmit.ucRegister);
                cmppsubmit.setMsgLevel(reccsubmit.ucMsgLevel);
                cmppsubmit.setServiceId(reccsubmit.sServiceId);
                cmppsubmit.setFeeUserType(reccsubmit.ucFeeUserType);
                cmppsubmit.setFeeterminalid(reccsubmit.sFeeTermId);
                cmppsubmit.setTppid(reccsubmit.ucTpPid);
                cmppsubmit.setTpudhi(reccsubmit.ucTpUdhi);
                cmppsubmit.setMsgFmt(reccsubmit.ucMsgFmt);
                cmppsubmit.setMsgSrc(reccsubmit.sMsgSrc);
                cmppsubmit.setFeeType(reccsubmit.sFeeType);
                cmppsubmit.setFeeCode(reccsubmit.sFeeCode);
                cmppsubmit.setValidTime(reccsubmit.sValidTime);
                cmppsubmit.setAtTime(reccsubmit.sAtTime);
                cmppsubmit.setSrcTerminalId(reccsubmit.sSrcTermId);
                cmppsubmit.setReverse(reccsubmit.usReserve);
                byte abyte1[] = new byte[140];
                int i1 = 140;
                for(int j1 = 0; j1 < j; j1++)
                {
                    synchronized(sock)
                    {
                        cmppsubmit.setSequenceId(sock.seq);
                        sock.seq++;
                        if(sock.seq == 0x7fffffff)
                            sock.seq = 2;
                    }
                    if(j1 + 1 == j)
                    {
                        cmppCommon.BytesCopy(abyte0, abyte1, j1 * 140, abyte0.length - 1, 0);
                        i1 = abyte0.length - j1 * 140;
                        byte abyte2[] = new byte[i1];
                        cmppCommon.BytesCopy(abyte1, abyte2, 0, i1 - 1, 0);
                        cmppsubmit.setRequiredItems(s2, i1, abyte2);
                    } else
                    {
                        cmppCommon.BytesCopy(abyte0, abyte1, j1 * 140, (j1 + 1) * 140 - 1, 0);
                        cmppsubmit.setRequiredItems(s2, i1, abyte1);
                    }
                    int k1 = cmppsubmit.sendCmppSubmit();
                    if(k1 == 0)
                        k++;
                    if(k1 < 0)
                        return k1;
                }

            }
        }

        return vector.size() * j;
    }

    public int nCMPP_Terminate()
    {
        if(sock == null)
            return -1;
        cmppTerminate cmppterminate = new cmppTerminate(sock);
        synchronized(sock)
        {
            cmppterminate.setSequenceId(sock.seq);
            if(sock.seq == 0x7fffffff)
                sock.seq = 2;
        }
        int i = cmppterminate.sendTerminate();
        if(i < 0)
            return i;
        cmppPacket cmpppacket = new cmppPacket(sock);
        int j;
        do
        {
            int k = cmpppacket.readPacket();
            if(k < 0)
                return k;
            j = cmpppacket.getCommandID();
        } while(j != 0x80000002);
        int l = sock.closeSock();
        return l;
    }

    public int nCMPP_getPacket(cmppPacket cmpppacket)
    {
        int i = -1;
        if(cmpppacket == null)
            return -1;
        synchronized(cmpppacket.conn)
        {
            int k = cmpppacket.readPacket();
            if(k < 0)
            {
                int j = k;
                return j;
            }
        }
        i = cmpppacket.getCommandID();
        return i;
    }

    Vector parseAllSubscribers(String s)
    {
        if(s == null)
            return null;
        Vector vector = new Vector();
        do
        {
            byte byte0 = 44;//44為 ，號
            int i = s.indexOf(byte0);
            if(i != -1)
            {
                String s1 = s.substring(0, i);
                vector.addElement(s1.trim());
                s = s.substring(i + 1);
            } else
            {
                vector.add(s.trim());
                return vector;
            }
        } while(true);
    }

    String apiVersion;
    public String SPID;
    public String SPPassword;
    public String hostIp;
    public int port;
    public int version;
    public int sversion;
    public cmppSocket sock;
}