//                           DSKEL-ID


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

#include <proto/all.h>
#include <stdio.h>

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

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

struct MyMessage
 {
  struct Message Msg;
  struct User User;
  char text[255];
  char text1[255];
  int car,Value,Data;
  long LongValue;
  int  IntValue;
 };

struct User User;
struct MsgPort *MyPort = NULL;
struct MyMessage *msg;
struct node_info nody;
struct Catalog Catalog;
struct File_Area File_Area[41];          // To Read Files.Data

#define DROP if(EXIT_FLAG) CloseStuff();

void CloseStuff();
void input(char mstring[],int len);
int  DOORIO();
void GetStr(char s[],int opt);
void showfile(char mstring[]);

int  EXIT_FLAG, DOOR_DATA, DOOR_CAR, DOOR_VALUE, DOOR_VALUE1 = 0,first = 0;
char DOOR_MSG [255],DOOR_MSG1[255],MyName[255],st[100];

//*****************************
//*****  PL (Print Line)  *****
//*****************************

void pl(fmt,a1,a2)
char *fmt;
 {
  char s[255];
  sprintf(s,fmt,a1,a2);
  DOOR_DATA=1; strcpy(DOOR_MSG,s); DOORIO();
 }

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

void main(int argc,char *argv[])
{
 char string[255],string1[255],string2[255],ext[255];
 register int x,y,i,file,number,NODE;
 if(!DoorStart(argv[1])) { PutStr("[os2] Tempest Door\n"); exit(0); }


//***************************
//*****  Load Pointers  *****
//***************************

 NODE = atoi(argv[1]);

 sprintf(string,"NODE:NodeInfo_%d",NODE);
 for(x=1;x<4;x++)
  {
   file=Open(string,MODE_OLDFILE);
   if(file!=0)
    {
     Read(file,(char *)&nody,sizeof(struct node_info));
     Close(file);
     break;
    }
  }

//****************************
//*****  Load File.Data  *****
//****************************

 GetStr(string1,0);
 sprintf(string2,"%sSetup/Files.DATA",string1);
 file=Open(string2,MODE_OLDFILE);
 i=0;
 do
  {
   Read(file,(char *)&File_Area[i], sizeof(struct File_Area));
   i++;
  }
 while(i<40);
 Close(file);

 pl("\r\n[DSKEL-ID v1.0] File iD'er     By The SkeletoN [08-10-93]\r\n");
 pl("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\r\n");

 CONTINUE:

 pl("\r\n[Return = Quit] Enter File Number: ");
 input(string1,4);
 DROP;
 if(string1[0] == NULL) CloseStuff();

 number=atoi(string1);
 ReadCatalog(User.FB_J,number);

 pl("\r\nFileName: %s\r\n",Catalog.FileName);
 x=strlen(Catalog.FileName);
 sprintf(ext,"%c%c%c%c",Catalog.FileName[x-4],Catalog.FileName[x-3],Catalog.FileName[x-2],Catalog.FileName[x-1]);

 if(ext[0]=='.')
  {
   ext[1]=toupper(ext[1]);
   if(ext[1]=='Z')
    {
     strcpy(string,Catalog.FileName);

     x=OnlineFile(User.FB_J,string);
     if(x==1)
      {
       pl("\r\nWorking...\r\n\r\n");
       sprintf(string2,"T:iD.txt-%d",NODE);
       sprintf(string1,"UNZIP >%s -cq %s *.diz",string2,string);
       Execute(string1,0L,0L);
       showfile(string2);
       DeleteFile(string2);
      }
    }
  }
 goto CONTINUE;
}



int OnlineFile(Area,Filename)
int Area;
char Filename[];
{
 char string1[100],final[80];
 int stat,x;
 FILE *in;
// stat=ACCESS(Area);
// if(stat!=1)
//  {
   sprintf(final,"%s%s",File_Area[Area].Path,Filename);
   if(access(final,0L)==0)
    {
     strcpy(Filename,final);
     return(1);
    }
//  }
 x=0;
 while(x<40)
  {
//   stat=ACCESS(x);
//   if(stat==1) goto NOPE;
   sprintf(final,"%s%s",File_Area[x].Path,Filename);
   if(access(final,0L)==0)
    {
     strcpy(Filename,final);
     return(1);
    }
   NOPE:
   x++;
  }
 sprintf(final,"%sDownloads.opt",nody.SystemDataInfo->OptionalDirPath);
 in=fopen(final,"r");
 if(in==NULL)
  {
   return(0);
  }
 while(fgets(string1,79,in)!=NULL)
  {
   string1[strlen(string1)-1] = '\0';
   sprintf(final,"%s%s",string1,Filename);
   if(access(final,0)==0)
    {
     fclose(in);
     strcpy(Filename,final);
     return(1);
    }
  }
 fclose(in);
 return(0);
}





//********************************
//*****  Read Catalog Entry  *****
//********************************

ReadCatalog(int Area,int Slot)
{
 char string[80],temp[50];
 long size,FilePos;
 int in,stat;

 Slot--;
 sprintf(temp,"%d",Area);
 sprintf(string,"%sCatalog.%s",nody.SystemDataInfo->CatalogsPath,temp);
 in=Open(string,MODE_OLDFILE);
 size=(long)sizeof(struct Catalog);
 FilePos=(long)size*(long)Slot;
 if(in==0)
  {
   pl("\r\nNo files have been uploaded yet.\r\n\r\n");
   CloseStuff();
  }
 stat=Seek(in,FilePos,OFFSET_BEGINNING);
 if(stat!=0)
  {
   Close(in);
   pl("\r\nFile Number out of range!\r\n\r\n");
   CloseStuff();
  }
 setmem(&Catalog,sizeof(struct Catalog),NULL);
 stat=Read(in,(char *)&Catalog,sizeof(struct Catalog));
 if(stat==0)
  {
   Close(in);
   pl("\r\nNo More Files!\r\n\r\n");
   CloseStuff();
  }
 Close(in);
 return(0);
}




//*************************
//*****  Close Stuff  *****
//*************************

void CloseStuff()
{ DOOR_DATA=99; strcpy(DOOR_MSG,'\0'); DOORIO();
 while(msg=(struct MyMessage *)GetMsg(MyPort)) ReplyMsg((struct Message *)msg);
 if(MyPort) DeletePort(MyPort);
 exit(0); }

//************************
//*****  Door Start  *****
//************************

DoorStart(char node[])
{
 struct MsgPort *HisPort;
 EXIT_FLAG = 0;
 strcpy(st,node);
 strcat(st,":TEMPEST_DOOR");
 HisPort = FindPort(st);
 if(HisPort==NULL) return (FALSE);
 strcpy(MyName,node);
 strcat(MyName,":DOOR_PORT");
 MyPort = CreatePort(MyName,0L);
 if(MyPort==NULL)
  {
   PutStr("Cant open port");
   return(int)FALSE;
  }
 DOORIO();
 return (int)TRUE;
}

//********************
//*****  DoorIO  *****
//********************

int DOORIO()
{
 struct MsgPort *HisPort;
 struct MyMessage message;
 int UPDATE;
 if(EXIT_FLAG) return 0;
 UPDATE=0;
 HisPort = FindPort(st);
 if(HisPort!=NULL)
  {
   message.Msg.mn_Node.ln_Type = NT_MESSAGE;
   message.Msg.mn_Length = sizeof(message);
   message.Msg.mn_ReplyPort = MyPort;
   if(first)CopyMem(&User,&message.User,sizeof(struct User));
   message.car   = 0;
   message.Data  = DOOR_DATA;
   message.Value = DOOR_VALUE;
   message.IntValue = DOOR_VALUE1;
   strcpy(message.text,DOOR_MSG);
   strcpy(message.text1,DOOR_MSG1);
   PutMsg((struct MsgPort *)HisPort,(struct Message *)&message);
   Wait(1 << MyPort->mp_SigBit);
   GetMsg(MyPort);
   DOOR_DATA  = message.Data;
   DOOR_VALUE = message.Value;
   DOOR_VALUE1 = message.IntValue;
   strcpy(DOOR_MSG,message.text);
   strcpy(DOOR_MSG1,message.text1);
   CopyMem(&message.User,&User,sizeof(struct User));
   first=1;
   UPDATE=0;
   if(message.car) EXIT_FLAG=1;
  }
 return 0;
}

//*********************
//*****  Get Key  *****
//*********************

void getkey(char character[])
{ strcpy(DOOR_MSG,'\0'); DOOR_DATA=31; DOORIO(); strcpy(character,DOOR_MSG); DROP; }

//*********************************
//*****  GetStr (Get String)  *****
//*********************************

void GetStr(char s[],int opt)
{ DOOR_DATA=15; DOOR_VALUE=opt; strcpy(s,'\0'); DOORIO(); strcpy(s,DOOR_MSG); }

//*******************
//*****  Input  *****
//*******************

void input(char mstring[],int len)
{ DOOR_DATA=40; DOOR_VALUE=len; strcpy(DOOR_MSG,mstring); DOORIO();
 strcpy(mstring,DOOR_MSG); strcpy(DOOR_MSG,'\0'); strcpy(DOOR_MSG1,'\0'); }

//************************
//*****  Line Input  *****
//************************

void LineInput(char ostring[],char mstring[],int len)
{ DOOR_DATA=41; DOOR_VALUE=len; strcpy(DOOR_MSG,mstring); strcpy(DOOR_MSG1,ostring);
 DOORIO(); strcpy(mstring,DOOR_MSG); strcpy(DOOR_MSG,'\0'); strcpy(DOOR_MSG1,'\0'); DROP; }

//***********************
//*****  Show File  *****
//***********************

void showfile(char mstring[])
{ DOOR_DATA=30; strcpy(DOOR_MSG,mstring); DOORIO(); }