/*ProfiPacket - packet radio terminal program
  Copyright (C) 1999  Alexander Feigl

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  Author:

  Alexander Feigl
  Burachstraße 51

  D-88250 Weingarten

  Mail : Alexander.Feigl@gmx.de
*/


#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "GUIProtos.h"
#include "global.h"
#include "MHeard.h"

#include "QSO/Filetrans.h"
#include "QSO/Convert.h"

#include <libraries/mui.h>

#include <libraries/asl.h>

#include <devices/timer.h>

#include <exec/lists.h>
#include <exec/memory.h>

#include <dos/exall.h>

#include <clib/muimaster_protos.h>
#include <clib/exec_protos.h>
#include <clib/dos_protos.h>
#include <clib/alib_protos.h>
#include <clib/intuition_protos.h>
#include <clib/utility_protos.h>

#ifdef __GNUC__

extern void *DOSBase;
extern void *SysBase;
extern void *IntuitionBase;
extern void *UtilityBase;
extern void *MUIMasterBase;

#define NO_INLINE_STDARG
#include <inline/muimaster.h>
#include <inline/dos.h>
#include <inline/exec.h>
#include <inline/intuition.h>
#include <inline/utility.h>
#undef RawDoFmt
#endif

#ifndef MAKE_ID
#define MAKE_ID(a,b,c,d) ((ULONG) (a)<<24 | (ULONG) (b)<<16 | (ULONG) (c)<<8 | (ULONG) (d))
#endif

void FillHook(struct Hook *MyHook,void (*Function)(),void *FunctionData);

static void GUIFT_Control(struct Hook *MyHook,unsigned long *Param,void *Object,
                         void *Data);
static void GUIFIL_Control(struct Hook *MyHook,unsigned long *Param,void *Object,
                         void *Data);
static void GUIFIL_IdentifyFile(void);




static Object *ftobject[16];
#define ftobject(xx) ftobject[xx]
Object *FileTransferWindow;
static struct Hook fthook;
static unsigned char *ftarray[16];

static int transfertype;






static Object *filobject[16];
#define filobject(xx) filobject[xx]
Object *FilterWindow;
static struct Hook filhook;
static unsigned char *filarray[16];



void GUIFT_FileTransfer(void)
{

   if (FileTransferWindow==NULL)
    {
     ftarray[0]=GUI_String(609);
     ftarray[1]=GUI_String(610);
     ftarray[2]=GUI_String(611);
     ftarray[3]=GUI_String(612);
     ftarray[4]=GUI_String(613);
     ftarray[5]=NULL;

     FillHook(&fthook,(void *) GUIFT_Control,NULL);

     FileTransferWindow =
                 WindowObject,
                     MUIA_Window_Title, GUI_String(606),
                     MUIA_Window_ID   , MAKE_ID('F','T','R','A'),

                     WindowContents,

                       VGroup,
                           Child,ColGroup(2),

                             Child,Label2(GUI_String(607)),
                             Child,ftobject(1)=PopaslObject,
                                 MUIA_Popstring_String,String(NULL,196),
                                 MUIA_Popstring_Button,PopButton(MUII_PopFile),
                                 ASLFR_TitleText,GUI_String(606),
                                 End,

                             Child,Label(GUI_String(608)),
                             Child,ftobject(2)=Cycle(ftarray),

                             End,

                           Child,HGroup,
                             Child,ftobject(3)=SimpleButton(GUI_String(614)),
                             Child,ftobject(4)=SimpleButton(GUI_String(615)),
                             Child,ftobject(5)=SimpleButton(GUI_String(16)),
                             End,
                           End,
                     End;

    if (FileTransferWindow==NULL)
        {
            GUI_LowMemory();
            return;
        }

    DoMethod(Application,OM_ADDMEMBER,FileTransferWindow);

     {
      int i;
      for (i=1;i<6;++i) set(ftobject(i),MUIA_CycleChain,1);
     }

    DoMethod(FileTransferWindow,MUIM_Notify,MUIA_Window_CloseRequest,TRUE,
             FileTransferWindow,3,MUIM_CallHook,&fthook,0);

     {
      int i;
      for (i=3;i<6;++i)
       {
        DoMethod(ftobject(i),MUIM_Notify,MUIA_Pressed,FALSE,
                 FileTransferWindow,3,MUIM_CallHook,&fthook,i);
       }
     }


    DoMethod(ftobject(1),MUIM_Notify,MUIA_String_Contents,MUIV_EveryTime,
             FileTransferWindow,4,MUIM_CallHook,&fthook,1,MUIV_TriggerValue);

    DoMethod(ftobject(2),MUIM_Notify,MUIA_Cycle_Active,MUIV_EveryTime,
             FileTransferWindow,4,MUIM_CallHook,&fthook,2,MUIV_TriggerValue);


    transfertype=FILEFORMAT_AUTOBINARY;
    nnset(ftobject(2),MUIA_Cycle_Active,transfertype);
   }

  {
   unsigned long status;

   get(FileTransferWindow,MUIA_Window_Open,&status);
   if (status==TRUE) return;
  }

 set(FileTransferWindow,MUIA_Window_Open,TRUE);
 return;
}

static void GUIFT_Control(struct Hook *MyHook,unsigned long *Param,void *Object,
                         void *Data)
{
 switch (*(Param))
  {
   case 0:
   case 5:
     set(FileTransferWindow,MUIA_Window_Open,FALSE);
     break;
   case 1:
     break;
   case 2:
     transfertype=*(Param+1);
     break;
   case 3:
    {
     unsigned char *fname;
     int err;
     get(ftobject(1),MUIA_String_Contents,&fname);
     set(FileTransferWindow,MUIA_Window_Open,FALSE);
     err=StartFiletransfer(ActiveChannel,transfertype,fname);
     switch (err)
      {
       case TRANSERROR_ALREADYTRANSFER:
         GUI_DisplayEventWindow(GUI_String(118));
         break;
       case TRANSERROR_NOSERVER:
         GUI_DisplayEventWindow(GUI_String(120));
         break;
       case TRANSERROR_NOTCONNECTED:
         GUI_DisplayEventWindow(GUI_String(117));
         break;
       case TRANSERROR_NOTFOUND:
         GUI_DisplayEventWindow(GUI_String(119));
         break;            
      }
     break;
    } 
   case 4:
    {
     unsigned char *fname;
     int err;
     get(ftobject(1),MUIA_String_Contents,&fname);
     set(FileTransferWindow,MUIA_Window_Open,FALSE);
    
      {
       BPTR lock;
       lock=Lock(fname,-2);
       if (lock!=NULL)
        {
         int result;
         unsigned long size;
         const unsigned char *args[4];
         struct FileInfo finf;
         
         size=0;
         if (GetFileInfo(fname,&finf)==0) size=finf.filesize;          
         args[0]=fname;
         args[1]=(unsigned char *) size;
         
         UnLock(lock);
         /* file exists */
         result=GUI_HandleRequest(0,121,transfertype>=3?123:122,(void *) args);
         if (result==0) break;
         if (result==1) 
          {
           DeleteFile(fname);
          }
         if ( ( (result==2) && (transfertype<3) ) ||
              ( (result==3) && (transfertype>=3) ) )
            
          {
           set(FileTransferWindow,MUIA_Window_Open,TRUE);
           DoMethod(ftobject(1),MUIM_Popstring_Open);
           break;
          }
        }
      }
     err=StartFilereceive(ActiveChannel,transfertype,fname);
     switch (err)
      {
       case TRANSERROR_ALREADYTRANSFER:
         GUI_DisplayEventWindow(GUI_String(118));
         break;
       case TRANSERROR_NOSERVER:
         GUI_DisplayEventWindow(GUI_String(120));
         break;
       case TRANSERROR_NOTCONNECTED:
         GUI_DisplayEventWindow(GUI_String(117));
         break;
       case TRANSERROR_NOTFOUND:
         GUI_DisplayEventWindow(GUI_String(119));
         break;            
      }
     break;
    } 
  }
 return;
}

void GUIFT_FileFilter(void)
{

   if (FilterWindow==NULL)
    {
     filarray[0]=GUI_String(609);
     filarray[1]=GUI_String(610);
     filarray[2]=GUI_String(611);
     filarray[3]=GUI_String(612);
     filarray[4]=GUI_String(613);
     filarray[5]=NULL;

     FillHook(&filhook,(void *) GUIFIL_Control,NULL);

     FilterWindow =
                 WindowObject,
                     MUIA_Window_Title, GUI_String(617),
                     MUIA_Window_ID   , MAKE_ID('F','I','L','T'),

                     WindowContents,

                       VGroup,

                           Child,ColGroup(2),

                             Child,Label2(GUI_String(618)),
                             Child,filobject(1)=PopaslObject,
                                 MUIA_Popstring_String,String(NULL,196),
                                 MUIA_Popstring_Button,PopButton(MUII_PopFile),
                                 ASLFR_TitleText,GUI_String(618),
                                 End,
                             End,
                           Child,VGroup,
                             Child,filobject(2)=SimpleButton(GUI_String(619)),
                             Child,filobject(3)=SimpleButton(GUI_String(620)),
                             Child,filobject(4)=SimpleButton(GUI_String(621)),
                             Child,filobject(5)=SimpleButton(GUI_String(622)),
                             Child,filobject(6)=SimpleButton(GUI_String(623)),
                             Child,filobject(7)=SimpleButton(GUI_String(624)),
                             Child,filobject(8)=TextObject,
                                     MUIA_Text_SetMin,FALSE,
                                     MUIA_Background,MUII_TextBack,
                                     MUIA_Frame,MUIV_Frame_Text,
                                     End,
                             End,
                           End,
                     End;

    if (FilterWindow==NULL)
        {
            GUI_LowMemory();
            return;
        }

    DoMethod(Application,OM_ADDMEMBER,FilterWindow);

     {
      int i;
      for (i=1;i<8;++i) 
       {
        set(filobject(i),MUIA_CycleChain,1);
        if ( (i>=2) && (i<=7) )
	     {
	       DoMethod(filobject(i),MUIM_Notify,MUIA_Pressed,FALSE,
	   	            filobject(i),3,MUIM_CallHook,&filhook,i);
	     }  
       }
     }

    DoMethod(FilterWindow,MUIM_Notify,MUIA_Window_CloseRequest,TRUE,
             FilterWindow,3,MUIM_CallHook,&filhook,0);



    DoMethod(filobject(1),MUIM_Notify,MUIA_String_Contents,MUIV_EveryTime,
             FilterWindow,4,MUIM_CallHook,&filhook,1,MUIV_TriggerValue);

  
   }

  {
   unsigned long status;

   get(FilterWindow,MUIA_Window_Open,&status);
   if (status==TRUE) return;
  }
 GUIFIL_IdentifyFile();
 set(FilterWindow,MUIA_Window_Open,TRUE);
 return;
}

static void GUIFIL_IdentifyFile()
 {
  unsigned char *filename;
  struct FileInfo finfo;
  
  get(filobject(1),MUIA_String_Contents,&filename);
  if (GetFileInfo(filename,&finfo))
   {
    set(filobject(8),MUIA_Text_Contents,(unsigned long ) GUI_String(625));
    set(filobject(2),MUIA_Disabled,TRUE);
    set(filobject(3),MUIA_Disabled,TRUE);
    set(filobject(4),MUIA_Disabled,TRUE);
    set(filobject(5),MUIA_Disabled,TRUE);
    set(filobject(6),MUIA_Disabled,TRUE);
    set(filobject(7),MUIA_Disabled,TRUE);
    return;
   }
   {
    unsigned char charray[64];
    void *ptrarray[4];
    switch (finfo.fileformat)
     {
      case FILEFORMAT_TEXTAMIGA:
      case FILEFORMAT_AUTOBINARY:
        finfo.fileformat=FILEFORMAT_TEXTAMIGA;
        ptrarray[0]=GUI_String(626);
        set(filobject(2),MUIA_Disabled,TRUE);
        set(filobject(3),MUIA_Disabled,FALSE);
        set(filobject(4),MUIA_Disabled,TRUE);
        set(filobject(5),MUIA_Disabled,FALSE);
        set(filobject(6),MUIA_Disabled,FALSE);
        set(filobject(7),MUIA_Disabled,TRUE);
        break;
      default:
        ptrarray[0]=GUI_String(627);
        set(filobject(2),MUIA_Disabled,FALSE);
        set(filobject(3),MUIA_Disabled,TRUE);
        set(filobject(4),MUIA_Disabled,FALSE);
        set(filobject(5),MUIA_Disabled,TRUE);
        set(filobject(6),MUIA_Disabled,FALSE);
        set(filobject(7),MUIA_Disabled,TRUE);
        break;     
     }  
    switch (finfo.lftype)
     {
      case LFTYPE_LF:
        ptrarray[1]=GUI_String(630);
        break;
      case LFTYPE_CRLF:
        ptrarray[1]=GUI_String(629);
        break;
      case LFTYPE_CR:
        ptrarray[1]=GUI_String(628);
        break;        
     }
    RawDoFmt("%s %s",ptrarray,PutRawDoFmt,charray);
    set(filobject(8),MUIA_Text_Contents,(unsigned long ) charray);    
   }
 }

static void GUIFIL_Control(struct Hook *MyHook,unsigned long *Param,void *Object,
                         void *Data)
{
 int errmsg=0;
 
 switch (*(Param))
  {
   case 0:
     set(FilterWindow,MUIA_Window_Open,FALSE);
     break;
   case 1:
     GUIFIL_IdentifyFile();
     break;
   case 2:
     {
      unsigned char *filename;
  
      get(filobject(1),MUIA_String_Contents,&filename);
      if (ConvertFileToAmiga(filename))
       {
        errmsg=631;
       }
      GUIFIL_IdentifyFile();
      break;
     }
   case 3:
     {
      unsigned char *filename;
  
      get(filobject(1),MUIA_String_Contents,&filename);
      if (ConvertFileToPC(filename))
       {
        errmsg=631;
       }
      GUIFIL_IdentifyFile();
      break;
     }     
   case 4:
     { 
      unsigned char *filename;
      struct FileInfo finfo;
  
      get(filobject(1),MUIA_String_Contents,&filename);
      if (GetFileInfo(filename,&finfo))
       {
        errmsg=631;
        break;
       }

      finfo.fileformat=FILEFORMAT_TEXTAMIGA;
      
      if (SetFileInfo(filename,&finfo))
       {
        errmsg=631;
        break;
       }	 
      GUIFIL_IdentifyFile();
      break; 
     }
   case 5:
     { 
      unsigned char *filename;
      struct FileInfo finfo;
  
      get(filobject(1),MUIA_String_Contents,&filename);
      if (GetFileInfo(filename,&finfo))
       {
        errmsg=631;
        break;
       }

      finfo.fileformat=FILEFORMAT_TEXT;
      
      if (SetFileInfo(filename,&finfo))
       {
        errmsg=631;
        break;
       }	 
      GUIFIL_IdentifyFile();
      break; 
     }
   case 6:
     {
      unsigned char *filename;

      get(filobject(1),MUIA_String_Contents,&filename);
      if (!StripCRLF(filename,1))
       {
        errmsg=631;
       }
      GUIFIL_IdentifyFile();
      break;
     }
   case 7:
    break;     
  }
 if (errmsg) GUI_DisplayEventWindow(GUI_String(errmsg));
 
 return;
}