/*[]=====================================================================[]*/
/*[]     LeadTools Run Time Library - Version 11                         []*/
/*[]                                                                     []*/
/*[]                                                                     []*/
/*[]     Copyright (c) 1991-2000 LEAD Technologies, Inc.                 []*/
/*[]     All Rights Reserved.                                            []*/
/*[]                                                                     []*/
/*[]     process.c                                                       []*/
/*[]=====================================================================[]*/

#include "process.h"
#include "utils.h"
#include "extern.h"
#include "resource.h"


UINT uBlink = 0;  //blinking light timer
UINT uProcess=0;  //process timer

L_CHAR *GetProcessString(L_INT nProcess)
{
   L_CHAR *szProcess;
   
   szProcess = "***UNKNOWN***";
   switch(nProcess)
   {
   case PROCESS_NONE:
      szProcess="None";
      break;
   case PROCESS_CONNECT:
      szProcess="Connect";
      break;
   case PROCESS_ASSOCIATE:
      szProcess="Associate";
      break;
   case PROCESS_RELEASE:
      szProcess="Release";
      break;
   case PROCESS_ABORT:
      szProcess="Abort";
      break;
   case PROCESS_CLOSE:
      szProcess="Close";
      break;
   case PROCESS_C_STORE:
      szProcess="C-STORE";
      break;
   case PROCESS_C_FIND:
      szProcess="C-FIND";
      break;
   case PROCESS_C_GET:
      szProcess="C-GET";
      break;
   case PROCESS_C_MOVE:
      szProcess="C-MOVE";
      break;
   case PROCESS_C_CANCEL:
      szProcess="C-CANCEL";
      break;
   case PROCESS_C_ECHO:
      szProcess="C-ECHO";
      break;
   case PROCESS_N_REPORT:
      szProcess="N-REPORT";
      break;
   case PROCESS_N_GET:
      szProcess="N-GET";
      break;
   case PROCESS_N_SET:
      szProcess="N-SET";
      break;
   case PROCESS_N_ACTION:
      szProcess="N-ACTION";
      break;
   case PROCESS_N_CREATE:
      szProcess="N-CREATE";
      break;
   case PROCESS_N_DELETE:
      szProcess="N-DELETE";
      break;
   case PROCESS_UNKNOWN:
      szProcess="Unknown";
      break;
   }
   return szProcess;
}

//Used to disconnect hNetGlobal and hNetListenGlobal
L_VOID DisconnectFromServer(HDICOMNET hNet)
{
   L_INT  nRet;
   L_CHAR szMsg[MAX_STRING_LEN];
   
   if (L_DicomIsConnected(hNet))
   {
      //Close in the ReleaseResponse
      wsprintf(szMsg, "Send Release Request\nhNet[%x]", hNet);
      LogMessage(MSG_SEND, szMsg);
      StartProcess(PROCESS_RELEASE,0);
      //StatusCommand(STATUS_WAIT, "Waiting for Release Response...", TRUE);
      nRet = L_DicomSendReleaseRequest(hNet);
      if (nRet != DICOM_SUCCESS)
         FinishProcess(PROCESS_RELEASE);
   }
   else
   {
      //Close here
      wsprintf(szMsg, "Close\nhNet[%x]", hNet);
      LogMessage(MSG_NONE, szMsg);
      L_DicomClose(hNet);
      switch (uSecureMode)
      {
      case DICOM_SECURE_NONE:
         if (hNet == hNetGlobal)
         {
            bConnectedGlobal = FALSE;
            hAssociateAccept = NULL;
            StatusInit(TRUE);
         }
         break;
      case DICOM_SECURE_ISCL:
         if (hNet == hNetGlobalISCL)
         {
            bConnectedGlobal = FALSE;
            hAssociateAccept = NULL;
            StatusInit(TRUE);
         }  
         break;
      case DICOM_SECURE_TLS:
         if (hNet == hNetGlobalTLS)
         {
            bConnectedGlobal = FALSE;
            hAssociateAccept = NULL;
            StatusInit(TRUE);
         }  
         break;
      }
   } 
}

//A hard close--Used to disconnect hNetGlobal and hNetListenGlobal
L_VOID CloseConnection(HDICOMNET hNet)
{
   L_CHAR szMsg[MAX_STRING_LEN];
   
   wsprintf(szMsg, "Close\nhNet[%x]", hNet);
   LogMessage(MSG_NONE, szMsg);
   L_DicomClose(hNet);
   switch (uSecureMode)
   {
   case DICOM_SECURE_NONE:
      if (hNet == hNetGlobal)
      {
         bConnectedGlobal = FALSE;
         hAssociateAccept = NULL;
         StatusInit(TRUE);
      }
      break;
   case DICOM_SECURE_ISCL:
      if (hNet == hNetGlobalISCL)
      {
         bConnectedGlobal = FALSE;
         hAssociateAccept = NULL;
         StatusInit(TRUE);
      }
      break;
   case DICOM_SECURE_TLS:
      if (hNet == hNetGlobalTLS)
      {
         bConnectedGlobal = FALSE;
         hAssociateAccept = NULL;
         StatusInit(TRUE);
      }
      break;
   }
} 


VOID CALLBACK ProcessTimer(HWND hWnd, UINT uMsg, UINT iTimerID, DWORD dwTime)
{
   L_CHAR szMsg[MAX_STRING_LEN];
   
   strcpy(szMsg, GetProcessString(processGlobal.nProcess));
   if (processGlobal.nStatus == PROCESS_STATUS_PENDING)
   {
      //time-out 
      processGlobal.nStatus = PROCESS_STATUS_TIMEOUT;
      strcat(szMsg, " Timing Out...");
      KillTimer(hWnd, uProcess);
      uProcess = 0;
      if (DEBUG_PROCESS_MSG)
         LogMessage(MSG_ERROR, szMsg);

      switch(processGlobal.nProcess)
      {
      case PROCESS_CONNECT:
      case PROCESS_ASSOCIATE:
      case PROCESS_RELEASE:
      case PROCESS_ABORT:
      case PROCESS_CLOSE:
      case PROCESS_C_STORE:
      case PROCESS_C_FIND:
      case PROCESS_C_GET:
      case PROCESS_C_MOVE:
      case PROCESS_C_ECHO:
         switch (uSecureMode)
         {
         case DICOM_SECURE_NONE:
            break;
            DisconnectFromServer(hNetGlobal);
         case DICOM_SECURE_ISCL:
            DisconnectFromServer(hNetGlobalISCL);
            break;
         case DICOM_SECURE_TLS:
            DisconnectFromServer(hNetGlobalTLS);
            break;
         }
         break;
       }
   }
   else
   {
      strcat(szMsg, "Timer completed!");
     if (DEBUG_PROCESS_MSG)
        LogMessage(MSG_ERROR, szMsg);
      processGlobal.nStatus = PROCESS_STATUS_SUCCESS;
   }
   StopBlink();
}

L_VOID InitProcess()
{
   processGlobal.nProcess = PROCESS_NONE;
   processGlobal.nPresentationID = 0;
   processGlobal.nStatus = PROCESS_STATUS_SUCCESS;
}


L_VOID StartProcess(L_INT nProcess, L_UCHAR nPresentationID)
{
   L_CHAR szMsg[MAX_STRING_LEN];

   if (processGlobal.nStatus == PROCESS_STATUS_TIMEOUT)
      return;

   if (uProcess != 0)
   {
      wsprintf(szMsg, "Cannot start[%s]--Timer still running", 
         GetProcessString(nProcess)
         );
      if (DEBUG_PROCESS_MSG)
         LogMessage(MSG_ERROR, szMsg);
      return;
   }
   
   if (processGlobal.nStatus != PROCESS_STATUS_SUCCESS)
   {
      wsprintf(szMsg, "Incomplete Process[%s]--Cannot start[%s]", 
         GetProcessString(processGlobal.nProcess),
         GetProcessString(nProcess)
         );
      if (DEBUG_PROCESS_MSG)
         LogMessage(MSG_ERROR, szMsg);
      return;
   }
   processGlobal.nPresentationID = nPresentationID;
   processGlobal.nProcess = nProcess;
   processGlobal.nStatus = PROCESS_STATUS_PENDING;

   wsprintf(szMsg, "StartProcess: %s", GetProcessString(nProcess));
   StatusCommand(STATUS_WAIT, GetProcessString(nProcess), TRUE);
   
   StartBlink();
   uProcess =  SetTimer(
      hWndMainGlobal,         // handle to window for timer messages
      ID_TIMER_PROCESS,       // timer identifier
      uTimeOutGlobal*1000,    // time-out value (convert ms to seconds)
      (TIMERPROC)ProcessTimer // pointer to timer procedure
      );
}

L_VOID FinishProcess(L_INT nProcess)
{
   L_CHAR szMsg[MAX_STRING_LEN];
   
   if (processGlobal.nStatus == PROCESS_STATUS_TIMEOUT)
   {
      if (DEBUG_PROCESS_MSG)
         LogMessage(MSG_ERROR, "Timeout--FinishProcess");
      StatusCommand(STATUS_NONE, "Timeout", TRUE);
      //StopBlink();
      //return;
   }
   if (nProcess != processGlobal.nProcess)
   {
      wsprintf(szMsg, "FinishProcess Mismatch: [%s] [%s]",
         GetProcessString(nProcess),
         GetProcessString(processGlobal.nProcess)
         );
      if (DEBUG_PROCESS_MSG)
         LogMessage(MSG_ERROR, szMsg);
      //StopBlink();
      //return;
   }
   wsprintf(szMsg, "FinishProcess: %s", GetProcessString(processGlobal.nProcess));
   StatusCommand(STATUS_READY, "", TRUE);
   processGlobal.nStatus = PROCESS_STATUS_SUCCESS;
   if (DEBUG_PROCESS_MSG)
      LogMessage(MSG_ERROR, szMsg);
   StopBlink();
   KillTimer(hWndMainGlobal, ID_TIMER_PROCESS);
   uProcess = 0;
}


VOID CALLBACK BlinkTimer(HWND hWnd, UINT uMsg, UINT iTimerID, DWORD dwTime)
{
   static L_BOOL bGreen = TRUE;

   bGreen = !bGreen;
   if (bGreen)
      hIconStatusGlobal = hIconGreen1Global;
   else
      hIconStatusGlobal = hIconGreen2Global;

   SendMessage(hStatusBarGlobal, SB_SETICON, (WPARAM)STATUS_INDEX_BLINK, (LPARAM)hIconStatusGlobal);  
}


L_VOID StartBlink()
{
   uBlink =  SetTimer(
      hWndMainGlobal,        // handle to window for timer messages
      ID_TIMER_BLINK,        // timer identifier
      250,                   // time-out value
      (TIMERPROC)BlinkTimer  // pointer to timer procedure
      );
}

L_VOID StopBlink()
{
   if (uBlink != 0)
   {
      KillTimer(hWndMainGlobal, uBlink);
      uBlink = 0;
   }
   SendMessage(hStatusBarGlobal, SB_SETICON, (WPARAM)STATUS_INDEX_BLINK, (LPARAM)hIconRedGlobal);
   hIconStatusGlobal = hIconRedGlobal;
}

L_VOID PaintBlink()
{
   SendMessage(hStatusBarGlobal, SB_SETICON, (WPARAM)STATUS_INDEX_BLINK, (LPARAM)hIconStatusGlobal);  
}

L_VOID StatusReceive(L_UINT32 nBytes)
{
   L_CHAR szMsg[MAX_STRING_LEN];

   wsprintf(szMsg, "Receive: %d", nBytes);
   SendMessage(hStatusBarGlobal, SB_SETTEXT, (WPARAM)STATUS_INDEX_RECEIVE, (LPARAM)szMsg);  
}

L_VOID StatusSend(L_UINT32 nBytes)
{
   L_CHAR szMsg[MAX_STRING_LEN];

   wsprintf(szMsg, "Send: %d", nBytes);
   SendMessage(hStatusBarGlobal, SB_SETTEXT, (WPARAM)STATUS_INDEX_SEND, (LPARAM)szMsg);  
}

L_VOID StatusServer(L_CHAR *lpszMsg, L_BOOL bUpdate)
{
   static L_CHAR szMsg[MAX_STRING_LEN];
   if (bUpdate)
   {
      wsprintf(szMsg, "Connected: %s", lpszMsg);
   }
   SendMessage(hStatusBarGlobal, SB_SETTEXT, (WPARAM)STATUS_INDEX_SERVER, (LPARAM)szMsg);  
}

//bUpdate TRUE:  update with lpszMsg
//        FALSE: refresh previous
L_VOID StatusCommand(L_INT nFlag, L_CHAR *lpszMsg, L_BOOL bUpdate)
{
   static L_CHAR szMsg[MAX_STRING_LEN];
   
   if (bUpdate)
   {
      switch (nFlag)
      {
      case STATUS_WAIT:
         wsprintf(szMsg, "Waiting for response: %s", lpszMsg);
         break;
         
      case STATUS_READY:
         lstrcpy(szMsg, "Ready");
         break;
         
      case STATUS_NONE:
         lstrcpy(szMsg, lpszMsg);
         break;
      }
   }
   SendMessage(hStatusBarGlobal, SB_SETTEXT, (WPARAM)STATUS_INDEX_COMMAND, (LPARAM)szMsg);  
}

//bUpdate TRUE:  update with lpszMsg
//        FALSE: refresh previous

L_VOID StatusInit(L_BOOL bUpdate)
{
   StatusCommand(STATUS_READY, NULL, bUpdate);
   StatusReceive(0);
   StatusSend(0);
   StatusServer("Not Connected", bUpdate);
   PaintBlink();
}