package voip;

public class SIPHandler implements SIPMsg
{
    private boolean doCipher = false;

    private boolean isValid = false;

    private boolean isCanceled = false;

    private String  clientSipId = null;

    private int currSipStatus = SIPMsg.ST_OTHERS;

    private CryptoManager cryptoMgr = null;

    private RTPManager  rtpMgr = null;

    public SIPHandler(CryptoManager cm)
    {
        this.cryptoMgr = cm;
    }


    public String executeSIPMethod(String packetStr, String strFrom)
    {
        currSipStatus = setStatus(packetStr);

        System.out.println("current status = " + currSipStatus);

        if ( currSipStatus == SIPMsg.ST_OTHERS)
        {
            return packetStr;
        }

        if ( currSipStatus == SIPMsg.ST_INVITE )
        {
            packetStr = doInvite(strFrom, packetStr);
        }
        else if ( currSipStatus == SIPMsg.ST_INVITE_OK )
        {
            packetStr = doInviteOK(strFrom, packetStr);
        }
        if ( currSipStatus == SIPMsg.ST_BYE )
        {
            terminatertpMgrnnection();
        }
        else if ( currSipStatus == SIPMsg.ST_BYE_OK )
        {
            terminateConnection();
        }
        else if ( currSipStatus == SIPMsg.ST_CANCEL )
        {
            isCanceled = true;
        }

        return packetStr;
    }

    private String doInvite(String strFrom, String packetStr)
    {
        if (rtpMgr == null)
           rtpMgr = new RTPManager(this);

        if ( strFrom.equals("client") )
        {
            //	Append the public key to the SDP content
            String ext = cryptoMgr.generate_KE_REQ();
            packetStr += ext;
            packetStr = rtpMgr.updateContentLength(packetStr, ext.length());
        }
        else
        {
            //
            //  Verify Peer's Certificate
            //
            isValid = cryptoMgr.verify_KE_REQ(packetStr);

            //
            //  Set media proxy switch to/not to crypt
            //
            rtpMgr.setDoCipher(isValid);

            //
            //  Fix the ip address and port numbers
            //
            rtpMgr.setGuestAddr(rtpMgr.extractMediaAddr(packetStr));
            rtpMgr.setGuestPort(rtpMgr.extractMediaPort(packetStr));

            packetStr = rtpMgr.replaceMediaInfo(
                            packetStr,
                            null, // No needs to change IP address!!!
                            null, // No needs to change IP address!!!
                            rtpMgr.getProxyPort(),
                            rtpMgr.getGuestPort()
                            );
        }

        return packetStr;
    }

    private String doInviteOK(String strFrom, String packetStr)
    {
        if ( strFrom.equals("client") )
        {
             //  Verify Peer's Certificate
             isValid = cryptoMgr.verify_KE_REQ(packetStr);

             //  Set media proxy switch to/not to crypt
             mdProxy.setDoCipher(isValid);

             String ciphered = cryptoMgr.generateKE_REPLY();

             //	Append the public key to the SDP content
             packetStr += ciphered;
             packetStr = mdProxy.updateContentLength(packetStr, ciphered.length());
        }

        if ( rtpMgr != null )
        {
            if ( isCanceled )
            {
                rtpMgr = null;
                isCanceled = false;
            }
            else
            {
            	(new Thread(rtpMgr, "RTPManager")).start();
            }
        }

        return packetStr;
    }

    private String getClientSipId(String strFrom, String packetStr)
    {
        String guestSipId = null;

        Assert.assertTrue(rtpMgr != null);

        if ( strFrom.equals("client") )
        {
            guestSipId = rtpMgr.extractGuestSipId("From: ", packetStr);
        }
        else
        {
            guestSipId = rtpMgr.extractGuestSipId("To: ", packetStr);
        }

        return guestSipId;
    }


    private String doBye (String strFrom, String packetStr)
    {
        String client = getCurrclientSipId(packetStr);

        if ( client.equals (clientSipId) )
            terminateConnection();

        return packetStr;
    }

    private void terminateConnection()
    {
        isValid = false;
        doCipher = false;

        if ( rtpMgr != null )
        {
            rtpMgr.terminate();
            rtpMgr = null;
        }

        cryptoMgr.resetPeer();
    }

    public int getStatus()
    {
        return currSipStatus;
    }

    public int setStatus(String packetStr)
    {
        if ( isInviteRequest(packetStr) )
        {
            currSipStatus = SIPMsg.ST_INVITE;
        }
        else if ( isInviteOkStatus(packetStr) )
        {
            currSipStatus = SIPMsg.ST_INVITE_OK;
        }
        else if ( isByeRequest(packetStr))
        {
           currSipStatus = SIPMsg.ST_BYE;
        }
        else if ( isByeOkStatus(packetStr) && (currSipStatus == SIPMsg.ST_BYE) )
        {
           currSipStatus = SIPMsg.ST_BYE_OK;
        }
        else if ( isCancelRequest(packetStr) )
        {
           currSipStatus = SIPMsg.ST_CANCEL;
        }
        else
        {
           currSipStatus = SIPMsg.ST_OTHERS;
        }

        return currSipStatus;
    }

    public boolean isInviteRequest (String packet)
    {
        return packet.startsWith("INVITE") ? true : false;
    }

    public boolean isByeRequest (String packet)
    {
        return ( packet.startsWith("BYE") || packet.startsWith("Bye") )
            ? true :
            false
            ;
    }

    public boolean isCancelRequest (String packet)
    {
        return ( packet.startsWith("CANCEL") || packet.startsWith("Cancel") )
            ? true :
            false
            ;
    }

    public boolean isInviteOkStatus (String packet)
    {
        return  ( (packet.indexOf("INVITE") != -1) &&
                  ((packet.indexOf("200 OK") != -1) || (packet.indexOf("200 Ok") != -1))
                  )
                ? true
                : false
                ;
    }

    public boolean isByeOkStatus (String packet)
    {
        return  ( ( packet.indexOf("BYE") != -1 ) &&
                  ((packet.indexOf("200 OK") != -1) || (packet.indexOf("200 Ok") != -1))
                 )
                ? true
                : false
                ;
    }

    public boolean isAckStatus (String packet)
    {
        return  ( packet.startsWith("ACK") &&
                ( packet.indexOf("INVITE") != -1 ) )
                ? true
                : false
                ;
    }

    public byte[] encryptMedia (byte[] input)
    {
        return cryptoMgr.aesCipher(CryptoManager.ENC_MODE, input);
    }

    public byte[] decryptMedia (byte[] input)
    {
        return cryptoMgr.aesCipher(CryptoManager.DEC_MODE, input);
    }
}