/*

     .----------------------------------------------------------------.
     | NODE | LOGON | HANDLE                    | ACTiViTY            |
     |======|=======|===========================|=====================|
     |   1  | 17:45 | The Skeleton              | Chat System         |
     |------|-------|---------------------------|---------------------|
     |   2  | --:-- | Awaiting a call           | Idle                |
     |------|-------|---------------------------|---------------------|
     |   3  | --:-- | Awaiting a call           | Idle                |
     `----------------------------------------------------------------'

Press <CTRL-?> to see menu.


<CTRL-P> Page node for chat
<CTRL-S> Send private text
<CTRL-W> Who's Online
<CTRL-X> Exit Chat


*/
//**********************
//*****  Includes  *****
//**********************

#include <proto/all.h>
#include <stdio.h>
#include <Stdlib.h>
#include <stdarg.h>
#include <time.h>

#include <string.h>
#include <tempest/headers.h>
#include <tempest/defines.h>

//********************************
//*****  Structures/Defines  *****
//********************************

 struct MyMessage
  {
   struct Message Msg; // for Exec message routines
   ULONG  Command;     // Command to be executed.

   TEXT   *text1,
          *text2,
          *text3;
   int    Value1,
          Value2;
   ULONG  LongValue;
   LONGBITS Flags;
   int    carrier;
   struct User       *User;
   struct SystemData *SystemData;
   struct NodeData   *NodeData;
   struct Today      *Today;
  };

struct MyMessage send;

struct User *User;
struct SystemData *SystemData;
struct NodeData *NodeData;
struct Today *Today;
struct MsgPort *MyPort = NULL;
struct MyMessage *msg;
struct node_info nody;

int  DoorStart(TEXT *);
int  DOORIO(WORD);
VOID CloseStuff(VOID);

VOID Activity(BYTE,TEXT *);
int  CheckKey(VOID);
int  hotkey(TEXT *);
VOID input(TEXT *,int);
VOID pl(TEXT *,...);
VOID WriteFile(TEXT *,TEXT *);
char *Myctime(long *);

VOID Send(BYTE);
VOID ListNodes(VOID);
int Loadnody(int node);
VOID CheckWaitingFile(VOID);
VOID GetStr(TEXT *s,int opt);

//******************************
//*****  Global Variables  *****
//******************************

int  NODE,NODES;
int  Error;
char nodename[200];

struct MsgPort *TempestPort;

char Lines[5][150];

//******************
//*****  Main  *****
//******************

int main(int argc,char *argv[])
{
 char key,string[255],string1[255],Input[150],ch;
 int stat,file,sending=0,line=0,first;
 register x,y;

 if(!DoorStart(argv[1])) { PutStr("TempesT Door\n"); exit(0); }

 if(!(User->NFlags1 & NF1_InternodeLineChat))
  {
   pl("\r\nAccess Denied!\r\n");
   CloseStuff();
  }

 SetTaskPri(FindTask(0),SystemData->DoorsPriority);
 pl("\fInternode Line Chat Module v3.51\r\n\r\n");

//********************************
//*****  Load Internal.Data  *****
//********************************

 NODE = atoi(argv[1]);
// stat=Loadnody(NODE);
// if(stat==0)
//  {
//   pl("NodeInfo File Not Found!\r\n");
//   CloseStuff();
//  }
 NODES = SystemData->NumberOfLines;

 Activity(33,"");

 ListNodes();

 sprintf(string,"NODE:CBText-%d",NODE);
 DeleteFile(string);

 SetTaskPri(FindTask(0),0L);

//*********************************
//*****  Get Input & Send it  *****
//*********************************

 strcpy(Lines[0],"Entered the chat system!\r\n");
 Send(0);

 REDO:

 pl("\r\n\r\n<CTRL-P> Page node for Chat\r\n<CTRL-S> Send Private Msg to node\r\n<CTRL-W> Who's Online.\r\n<CTRL-X> Exit Chat.\r\n\r\n");

 PROMPT:

 x=0;
 line=0;

 setmem(&Lines[0],sizeof(Lines[0]),NULL);
 while(1)
  {
   REINPUT:
   line=0;
   first=0;
   CheckWaitingFile();
   key=CheckKey();
   if(key!=0)
    {
     while(1)
      {
       if(first!=0)
        {
         hotkey(Input);
        }
       else Input[0]=key;
       first=1;
       key=NULL;

       if((sending==0)&&(Input[0]!=13))
        {
         pl("<%s>\r\n1>",User->Name);
         sending=1;
         x=0;
        }
       switch(Input[0])
        {
         case 13: RETURNKEY: // Return Key
                  if(x<1)
                   {
                    line=0;
                    pl("\r\n");
                    goto PROMPT;
                   }    // Return without input
                  Lines[line][x]=NULL;
                  x=0;
                  if(Lines[0][0]!=NULL) pl("\r\nSending Text\r\n\r\n");
                  line=0;
                  Send(0);
                  sending=0;
                  goto PROMPT;

         case 8:  // BackSpace
                  if(x<1) goto REINPUT;
                  pl("\b \b");
                  x--;
                  Lines[line][x]=NULL;
                  if(x==0)
                   {
//                    sending=0;
                    goto PROMPT;
                   }
                  break;

         case 24: // CTRL-X = Quit Program
                  if(Lines[0][0]!=NULL) pl("\r\nSending Text\r\n\r\n");
                  pl("\r\n\r\n");
                  Send(0);
                  strcpy(Lines[0],"Exiting the chat system!\r\n");
                  Send(0);
                  sprintf(string,"NODE:CBText-%d",NODE);
                  DeleteFile(string);
                  CloseStuff();

         case 23: // CTRL-W = List Nodes
                  Send(0);
                  sending=0;
                  ListNodes();
                  goto REDO;


         case 19: // CTRL-S = Send Invite
         case 16: // CTRL-P = Page Node
                  Send(0);
                  sending=0;
                  ListNodes();
                  pl("\r\n\r\nSend to which node number: ");
                  hotkey(string);
                  y = atoi(string);
                  stat=Loadnody(y);
                  if((nody.UserInfo->Name[0]!=NULL)&&(stat!=0))
                   {
                    if((nody.GLOB->AN!=58)&&(nody.GLOB->AN!=56)&&(nody.GLOB->AN!=4))
                     {
                      if(Input[0]==16)
                       {
                        sprintf(string,"NODE:MsgToNode-%d",y);
                        sprintf(string1,"\r\n(%s) would like to chat in InterNode Chat\r\n",User->Name);
                        WriteFile(string,string1);
                       }
                      else
                       {
                        pl("\r\n\r\nInput your message (1 Line)\r\n");
                        pl(">");
                        input(Lines[0],77);
                        if(Lines[0][0]!=NULL) pl("Sending Text\r\n\r\n");
                        Send(y);
                       }
                     }
                    else pl("\r\nYou can not chat that user at this time!\r\n\r\n");
                    goto REDO;
                   }
                  else pl("\r\nNobody on that node!\r\n\r\n");
                  goto PROMPT;

         default: ch = Input[0];
                  Lines[line][x] = ch;
                  sprintf(string,"%c",ch);
                  pl(string);
                  x++;
                  if(x>=77)
                   {
                    line++;
                    if(line>=5) goto RETURNKEY;
                    x=0;
                    pl("\r\n%d>",(line+1));
                   }
        }
      }
    }
  }
}

//************************************
//*****  Send Text To All Nodes  *****
//************************************

VOID Send(BYTE TYPE)
{
 int x,y=1,stat;
 char OutFile[50],SendString[700];
 if(strlen(Lines[0])==0) return;

 sprintf(SendString,"\nInternode Message From (%s)\n",User->Name);

 for(x=0;x<5;x++)
  {
   if(Lines[x][0]!=NULL) strcat(SendString,Lines[x]);
   setmem(&Lines[x],sizeof(Lines[x]),NULL);
  }
 if(TYPE>1)
  {
   stat=Loadnody(TYPE);
   if(stat==0) return;
   if((nody.GLOB->AN==33)&&(TYPE!=NODE))
    {
     sprintf(OutFile,"NODE:CBText-%d",TYPE);
     WriteFile(OutFile,SendString);
    }
  }
 else
  {
   for(y=0;y<NODES+1;y++)
    {
     stat=Loadnody(y);
     if(stat!=0)
      {
       if((nody.GLOB->AN==33)&&(y!=NODE))
        {
         sprintf(OutFile,"NODE:CBText-%d",y);
         WriteFile(OutFile,SendString);
        }
      }
    }
  }
 CheckWaitingFile();
}

//************************************
//*****  Check for Waiting File  *****
//************************************

VOID CheckWaitingFile(VOID)
{
 char string[150];
 int stat;
 FILE *in;

 sprintf(string,"NODE:CBText-%d",NODE);

 if(access(string,0)==0)
  {
   in=fopen(string,"r");
   if(in==NULL) return;
   pl("\r\n");
   while(fgets(string,100,in)!=NULL)
    {
     string[99]=NULL;
     pl("%s\r",string);
    }
   fclose(in);
   sprintf(string,"NODE:CBText-%d",NODE);
   DeleteFile(string);
   pl("\r\n\r\n");
  }
}

//************************
//*****  List Nodes  *****
//************************

VOID ListNodes(VOID)
{
 char string[200],string2[20];
 char Handle[40],Activity[30],Time[15];
 register int i;
 int stat;

 if(!(User->NFlags1 & NF1_ViewNodeLists)) return;

 if(User->AnsiType<=1)
  {
   pl("\r\n\r\n     .------.-------.---------------------------.---------------------.\r\n");
   pl("     | NODE | LoGoN | HANDLE                    | ACTiViTY            |\r\n");
  }
 else
  {
   pl("\r\n\r\n     ÉÍÍÍÍÍÍËÍÍÍÍÍÍÍËÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍËÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»\r\n");
   pl("     º NODE º LoGoN º HANDLE                    º ACTiViTY            º\r\n");
  }

//***************************
//*****  Who is Online  *****
//***************************

 i=0;
 do
  {
   stat=Loadnody(i);
   if(stat==0) goto EXIT;
   if(nody.GLOB->AN!=62)
    {
     if((nody.GLOB->hide==1)&&(nody.UserInfo->Slot_Number==1)&&(!(User->SFlags1 & SF1_SysopWho))) goto EXIT;
     strcpy(Handle,nody.UserInfo->Name);
     if((nody.GLOB->hide==1)&&(!(User->SFlags1 & SF1_SysopWho)))
         strcpy(Handle,"(Hidden from display)");
     if(nody.UserInfo->Name[0]==NULL)
         strcpy(Handle," ");

     sprintf(string,"%s",Myctime(&nody.UserInfo->Time_Last_Connect));
     strmid(string,Time,12,5);
     strcpy(Activity,nody.GLOB->activity);
     //**************************
     //*****  Final Output  *****
     //**************************
     sprintf(string2,"%2d",i);
     if(User->AnsiType<=1)
      {
       pl("     |------|-------|---------------------------|---------------------|\r\n");
       pl("     |  %2s  | %5s | %-25.25s | %-19s |\r\n",
           string2,Time,Handle,Activity);
      }
     else
      {
       pl("     ºÍÍÍÍÍͺÍÍÍÍÍÍͺÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͺÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ͹\r\n");
       pl("     º  %2s  º %5s º %-25.25s º %-19s º\r\n",
           string2,Time,Handle,Activity);
      }
    }
   EXIT:
   i++;
  }
 while(i<NODES);
 if(User->AnsiType<=1)
      pl("     `------^-------^---------------------------^---------------------'");
 else pl("     ÈÍÍÍÍÍÍÊÍÍÍÍÍÍÍÊÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÊÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ");
}

//************************
//*****  Load Nody  ******
//************************

int Loadnody(int node)
{
 char string[50];
 register int y;
 int file;
 sprintf(string,"Node:NodeInfo_%d",node);
 for(y=1;y<3;y++)
  {
   file=Open(string,MODE_OLDFILE);
   if(file!=0)
    {
     Read(file,(char *)&nody,sizeof(struct node_info));
     Close(file);
     return(1);
    }
  }
 return(0);
}
//===========================* Beginning of Module *===========================
char *Myctime(long *secs)
{
 struct tm *tm;
 tm=gmtime(secs);
 return(asctime(tm));
}


//************************
//*****  Door Start  ***** // MUST BE INCLUDED IN ALL DOORS!
//************************
int DoorStart(TEXT *node)
{
 char string[60];
 send.carrier=0;
 sprintf(string,"%s:TEMPEST_DOOR",node);
 TempestPort=FindPort(string);
 if(TempestPort==NULL) return(int)FALSE;
 MyPort=CreateMsgPort();
 if(MyPort==NULL) return(int)FALSE;
 DOORIO(0);
 User=*&send.User;
 SystemData=*&send.SystemData;
 NodeData=*&send.NodeData;
 Today=*&send.Today;
 return(int)TRUE;
}
//********************
//*****  DoorIO  ***** // MUST BE INCLUDED IN ALL DOORS!
//********************
int DOORIO(WORD Command)
{
 if(send.carrier) return(0);
 send.Command=Command;
 send.Msg.mn_Node.ln_Type = NT_MESSAGE;
 send.Msg.mn_Length = sizeof(send);
 send.Msg.mn_ReplyPort = MyPort;
 send.carrier=0;
 PutMsg((struct MsgPort *)TempestPort,(struct Message *)&send);
 Wait(1 << MyPort->mp_SigBit);
 GetMsg(MyPort);
 if((send.carrier)&&(send.Command!=999)) CloseStuff();
 return(1);
}
//*************************
//*****  Close Stuff  ***** // MUST BE INCLUDED IN ALL DOORS!
//*************************
VOID CloseStuff(VOID)
{
 DOORIO(999);
 while(msg=(struct MyMessage *)GetMsg(MyPort)) ReplyMsg((struct Message *)msg);
 if(MyPort) DeleteMsgPort(MyPort);
 exit(0);
}
//**********************
//*****  Activity  ***** // Command 44
//**********************
VOID Activity(BYTE act,TEXT *s)
{
 send.Value1=act;
 send.text1=s;
 DOORIO(44);
}
//***********************
//*****  Check Key  ***** // Command 15
//***********************
int CheckKey(VOID)
{
 send.Value2=0;
 DOORIO(15);
 return(send.Value2);
}
//*********************
//*****  Hot Key  ***** // Command 16
//*********************
int hotkey(TEXT *character)
{
 send.text1=character;
 DOORIO(16);
 return((int)character[0]);
}
//*******************
//*****  Input  ***** // Command 20
//*******************
VOID input(TEXT *mstring,int len)
{
 send.Value1=len;
 send.text1 =mstring;
 DOORIO(20);
}
//*****************************
//*****  PL (Print Line)  ***** // Command 1 with a twist
//*****************************
VOID pl(TEXT *fmt,...)
{
 va_list args;
 char s[255];
 va_start(args,fmt);
 vsprintf(s,fmt,args);
 va_end(args);
 send.text1=&s[0];
 DOORIO(1);
}
//************************
//*****  Write File  ***** // Command 69
//************************
VOID WriteFile(TEXT *ostring,TEXT *mstring)
{
 send.text1=ostring;
 send.text2=mstring;
 DOORIO(69);
}
//*********************************
//*****  GetStr (Get String)  ***** // Command 33
//*********************************
VOID GetStr(TEXT *s,int opt)
{
 send.Value1=opt;
 strcpy(s,"");
 send.text1=s;
 DOORIO(33);
}