import System;
import System.Text;
import TI.ZPI2;

class TheScript
{

  // Set this variable to the COM port assigned to the target device.

  private var comPort : String = "COM4";



  // Set to 'true' when running the ZNP in order to reset the devices and startup the network.
  private var ZNP_RUN : boolean = true;
  private var SUCCESS : int = 0;
  private var HOMEAUT : int = 0x0104;
  private var LIGHT   : int = 0x0100;
  private var AF_DEFAULT_RADIUS : int = 0x1E;

  

  // Set this variable to 'true' to enable the display of log messages (i.e. verbose mode).
  private var showLogMsgs : boolean = true;

  // Variables set by the incoming message handler to enable "re-try until success" looping.
  private var gotRstRsp           : boolean = false;
  private var gotCfgRsp           : boolean = false;
  private var gotRegRsp           : boolean = false;
  private var gotStartRsp         : boolean = false;
  private var gotStateRsp         : boolean = false;
  private var gotAfReqExtRsp      : boolean = false;
  private var gotAfIncExt         : boolean = false;
  private var gotAfStoreRsp       : boolean = false;
  private var gotAfRetrieveRsp    : boolean = false;
  private var gotDevRsp           : boolean = false;
  private var gotEpRsp            : boolean = false;
  private var gotSdescRsp         : boolean = false;
  private var gotTogRsp         : boolean = false;
  private var gotDevAnn         : boolean = false;


  private var isLight             : boolean = false;
  private var lightStatus             : boolean = false;

  private var profileId           : UInt16  = 0x0104;  // HA Profile ID
  private var devId               : UInt16  = 0x0100;  // HA Profile ID  oprginal 0x0100
  private var endPoint            : Byte    = 0x07;    // SampleSW has endpoint 12 so we use that
  private var inClusterCnt        : Byte    = 5;
  private var outClusterCnt       : Byte    = 1;
  private var inClusterList = new Array(inClusterCnt);
  private var outClusterList = new Array(outClusterCnt);

  private var NV_STARTUP_OPTION     : Byte = 0x03;
  private var NV_STARTUP_OPTION_VAL : Byte = 0x03;	// 0x03 = clear configuration
  private var NV_STARTUP_LEN        : Byte = 1;

  private var cfgArr = new Array(256);        // Make big enough for any configuration item.
  private var retrieveBuf = new Array(1024);  // Make big enough for any huge message attempted.
  private var retrieveTot           : UInt16 = 741;
  private var retrieveLen           : Byte = 247;
  private var retrieveIdx           : UInt16;
  private var devaddr               : UInt16;
  private var dstEndPoint           : Byte    = 0x00;

  //DATA REQUEST VARIABLES
  private var drData = new Array(99);
  private var drCluster           : UInt16;
  private var drTrans          : Byte;
  private var drOption           : Byte;
  private var drRadius           : Byte = 0x1E;//AF_DEFAULT_RADIUS
  private var drLen           : Byte;

  //INCOMING MESSAGES VARIABLES

  private var imData = new Array(99);
  private var imGroup           : UInt16;
  private var imCluster           : UInt16;
  private var imSrcAddr           : UInt16;
  private var imSrcEndp           : Byte;
  private var imDstEndp           : Byte;
  private var imLen           : Byte;


  private var lqiData = new Array(99);
  private var lqiCount           : UInt16  = 0;



  // Main class function that effects the work of this test script.
  function run()
  {
    //set up clusters for light
    inClusterList[0] = 0;
    inClusterList[1] = 3;
    inClusterList[2] = 4;
    inClusterList[3] = 5;
    inClusterList[4] = 6;

    outClusterList[0] = 0;

    // Subscribe to the incoming message handler.
    ZEngine.add_OnMessageZPI2(this.msgHandler);

    if (ZNP_RUN)
    {
      // Force a device out of the boot loader wait routine (no bad effect when SBL is not present).
      sysReset(comPort);

      // Set the Startup_Option to Clear Configuration and reset to effect the action.
      cfgArr[0] = NV_STARTUP_OPTION_VAL;
      writeCfg(comPort , NV_STARTUP_OPTION, NV_STARTUP_LEN, cfgArr);
      sysReset(comPort);


      // Setup the device type, panId & channel mask and reset to effect the settings.
      cfgArr[0] = 0x00;                    // Set Logical Device Type to ZC.
      writeCfg(comPort, 0x87, 0x01, cfgArr);
      cfgArr[0] = 0xFF; cfgArr[1] = 0xFF;  // Set Pan Id to 0xFFFF Change this to any PAN ID you need to test
      writeCfg(comPort, 0x83, 0x02, cfgArr);
      cfgArr[0] = 0x00; cfgArr[1] = 0x00; cfgArr[2] = 0x08; cfgArr[3] = 0x00;
                                // Set Channel Maks to 0x00080000  // 19 - 0x13 - Current channel mask
      writeCfg(comPort, 0x84, 0x04, cfgArr);
      // Start the devices on the network.
      cfgArr[0] = 0x01;
      writeCfg(comPort, 0x8F, 0x01, cfgArr);// Set ZCD_NV_ZDO_DIRECT_CB to true. ZCD_NV_ZDO_DIRECT_CB address = 0x8F

      afReg(comPort);// set end point this is needed in order to send af_data_request

      startReq(comPort);// start the application
	  
	  //ZEngine.Pause(800);
	  //msgzes1(comPort ,0,Object);
	  
	  //while(1)
	  //{
		//  ZEngine.Pause(800);
		  // msgzes2(comPort ,0,Object);
	  //}
	   //msgzes3(comPort ,0,Object);
      //Add application specific code HERE if needed.
    }

    ZEngine.Complete(true);
  }
  
//
/*
	function msgzes1(comm : String)
	{
		logMsg("ZES -->" + comm + " --> SCript Complete");
	}
	function msgzes2(comm)
	{
		logMsg("ZES -->" + comm + " --> Döngü -->");
	}
	function msgzes3(comm : String)
	{
		logMsg("ZES -->" + comm + " --> Dongu Complete"+ Object);
	}	
*/	
 // Handler for incoming messages.
  function msgHandler(comm : String, id : MESSAGE_ID, msg : Object)
  {
	//logMsg("ZES -->" + comm + " --> "+ Object);
    switch (id)
    {
    case MESSAGE_ID.SYS_RESET_RESPONSE:
    {
      gotRstRsp = true;
      break;
    }
    case MESSAGE_ID.UTIL_GET_DEVICE_INFO_RESPONSE:
    {
        var devRsp : UTIL_GET_DEVICE_INFO_RESPONSE = msg;
        if (devRsp.Status == SUCCESS && devRsp.NumAssocDevices != 0)
        {
            gotDevRsp = true;
            devaddr = devRsp.AssocDevicesList[0];
        }

      break;
    }

    case MESSAGE_ID.ZDO_ACTIVE_EP_RSP:
    {
        var epRsp : ZDO_ACTIVE_EP_RSP = msg;
        if (epRsp.Status == SUCCESS && epRsp.ActiveEPCount != 0)
        {
            gotEpRsp=true;
            dstEndPoint = epRsp.ActiveEPList[0];
        }


      break;
    }

    case MESSAGE_ID.ZB_WRITE_CONFIGURATION_RSP:
    {
      var cfgRsp : ZB_WRITE_CONFIGURATION_RSP = msg;

      if (cfgRsp.Status == SUCCESS)
      {
        gotCfgRsp = true;
      }
      break;
    }

    case MESSAGE_ID.AF_REGISTER_SRSP:
    {
      var regRsp : AF_REGISTER_SRSP = msg;

      if (regRsp.Status == SUCCESS)
      {
        gotRegRsp = true;
      }
      break;
    }

    case MESSAGE_ID.ZB_START_REQUEST_RSP:
    {
      gotStartRsp = true;
      break;
    }


    case MESSAGE_ID.ZDO_END_DEVICE_ANNCE_IND:
    {
      var zdoDevInd : ZDO_END_DEVICE_ANNCE_IND = msg;
      devaddr = zdoDevInd.NwkAddr;
      gotDevAnn = true;

      break;
    }

    case MESSAGE_ID.ZDO_STATE_CHANGE_IND:
    {
      var zdoStateInd : ZDO_STATE_CHANGE_IND = msg;

      // { DEV_END_DEVICE, DEV_ROUTER, DEV_ZB_COORD } : { 6, 7, 9 }
      if ((zdoStateInd.State == 6) || (zdoStateInd.State == 7) || (zdoStateInd.State == 9))
      {
        gotStateRsp = true;
      }
      break;
    }

    case MESSAGE_ID.AF_DATA_REQUEST_EXT_SRSP:
    {
      var afRegExtRsp : AF_DATA_REQUEST_EXT_SRSP = msg;

      if (afRegExtRsp.Status == SUCCESS)
      {
        gotAfReqExtRsp = true;
      }
      break;
    }

    case MESSAGE_ID.AF_DATA_STORE_SRSP:
    {
      var afStoreRsp : AF_DATA_STORE_SRSP = msg;

      if (afStoreRsp.Status == SUCCESS)
      {
        gotAfStoreRsp = true;
      }
      break;
    }

    case MESSAGE_ID.AF_INCOMING_MSG_EXT:
    {
      var afIncExt : AF_INCOMING_MSG_EXT = msg;
      afDataRetrieve(comm, msg);
      gotAfIncExt = true;
      break;
    }

    case MESSAGE_ID.AF_INCOMING_MSG:
    {
      var inMsgDat : AF_INCOMING_MSG = msg;
      imGroup = inMsgDat.GroupID;
      imCluster = inMsgDat.ClusterID;
      imSrcAddr = inMsgDat.SrcAddr;
      imSrcEndp = inMsgDat.SrcEndpoint;
      imDstEndp = inMsgDat.DstEndpoint;
      imLen = inMsgDat.Len;
      for (var idx = 0; idx < imLen; idx++)
      {
          imData[idx] = inMsgDat.Data[idx];
      }

      break;
    }

    case MESSAGE_ID.AF_DATA_RETRIEVE_SRSP:
    {
      var afRetrieveRsp : AF_DATA_RETRIEVE_SRSP = msg;

      if (afRetrieveRsp.Status == SUCCESS)
      {
        var index = retrieveIdx;

        for (var idx = 0; idx < afRetrieveRsp.Length; idx++, index++)
        {
          retrieveBuf[index] = afRetrieveRsp.Data[idx];
        }

        gotAfRetrieveRsp = true;
      }
      break;
    }

    default:
	
      break;
    }
  }
  
// Send a ZB_SYSTEM_RESET message until success.
  function sysReset(comm : String)
  {
    var req : ZB_SYSTEM_RESET = new ZB_SYSTEM_RESET();
    gotRstRsp = false;

    while (!gotRstRsp)
    {
      logMsg("ZB_SYSTEM_RESET  to " + comm);
      ZEngine.Send(comm, req);
      ZEngine.Pause(800);

      // Sending SYS_STACK_TUNE as a way to get a 0x07 byte to the SBL before a 0xF8 byte.
      // An 0x07 byte forces the immediate run of valid code.
      //sysStackTune(comm, 7, 7);
      //ZEngine.Pause(300);
    }
  }


  
  
    // Send a ZB_WRITE_CONFIGURATION message.
  function writeCfg(comm : String, cfgId : Byte, len : Byte,  value : Array )
  {
    var req : ZB_WRITE_CONFIGURATION = new ZB_WRITE_CONFIGURATION();
    req.ConfigId = cfgId;
    req.Len = len;
		req.Value = new byte[len];

    for (var idx = 0; idx < len; idx++)
    {
      req.Value[idx] = value[idx];
    }

    gotCfgRsp = false;
    while (!gotCfgRsp)
    {
      logMsg("ZB_WRITE_CONFIGURATION  to " + comm);
      ZEngine.Send(comm, req);
      ZEngine.Pause(200);
    }
  }

    // Send a ZB_AF_REGISTER_REQUEST message.
  function afReg(comm : String)
  {
    var req : AF_REGISTER  = new AF_REGISTER ();
    req.AppProfID = profileId;
    req.AppDeviceId = devId;
    req.EndPoint = endPoint;
    req.AppInClusterList = inClusterList;
    req.AppNumInClusters = inClusterCnt;
    req.AppOutClusterList = outClusterList;
    req.AppNumOutClusters = outClusterCnt;

    gotRegRsp = false;
    while (!gotRegRsp)
    {
      logMsg("ZB_AF_REGISTER_REQUEST to " + comm);
      ZEngine.Send(comm, req);
      ZEngine.Pause(200);
    }
  }
  
    // Send a ZB_START_REQUEST message.
  function startReq(comm : String)
  {
    var req : ZB_START_REQUEST  = new ZB_START_REQUEST();

    gotStateRsp = false;
    while (!gotStateRsp)
    {
      gotStartRsp = false;
      while (!gotStartRsp)
      {
        logMsg("ZB_START_REQUEST  to " + comm);
        ZEngine.Send(comm, req);
        ZEngine.Pause(1000);
      }
      ZEngine.Pause(5000);
    }
  }
  
  // Display a log message if log messages are enabled.
  function logMsg(theMsg : String)
  {
    if (showLogMsgs)
    {
      ZEngine.WriteLog(theMsg);  // Display the message.
    }
  }  
  
  // Send a series of AF_DATA_RETRIEVE message(s) to get the data of an incoming huge message.
  function afDataRetrieve(comm : String, msgIn : AF_INCOMING_MSG_EXT)
  {
    var req : AF_DATA_RETRIEVE = new AF_DATA_RETRIEVE();

    req.Timestamp = msgIn.Timestamp;
    req.Length = retrieveLen;

    for (retrieveIdx = 0; retrieveIdx < msgIn.Len; retrieveIdx += retrieveLen)
    {
      req.Index = retrieveIdx;

      gotAfRetrieveRsp = false;
      while (!gotAfRetrieveRsp)
      {
        logMsg("AF_DATA_RETRIEVE to " + comm);
        ZEngine.Send(comm, req);
        ZEngine.Pause(100);
      }
    }

    /* Retrieve request with zero length indicates to flush the message and free the dynamic
     * memory. If this request fails, the device times out the incoming huge message buffer and
     * flushes it automatically, so no loop here.
     */
    req.Length = 0;
    logMsg("AF_DATA_RETRIEVE to " + comm);
    ZEngine.Send(comm, req);
    ZEngine.Pause(100);
  } 
 
  
} // End of TheScript class.


// The script engine will execute the following code.
var script:TheScript = new TheScript();
script.run();