/*  04-Aug-94 [olio] SUMSFolder now return WARN (5), if no msgs
**                   matched the filter..
*/

#include "sumstl.h"

#include <stdio.h>

#include "umsfilter.h"

#ifdef __SASC
#include <dos.h>
#endif

/* SMAKE */



// Version String
// --------------

static char VersionString[] = "$VER: sumsfolder "VERSION;

static char UsageString[] = "\
   U=User     : user name.\n\
   P=Password : user's password.\n\
  FI=Filter   : filter specification.\n\
  FO=Folder   : folder to set.\n\
   S=Server   : server name.\n\
   Q=Quiet    : work quietly\n\
   T=Tiny     : use tiny output\n\n\
";


// Template
// --------

static char *TemplateString = "U=User=Name/A,P=Password/A,FI=Filter/A,FO=Folder/A,S=Server/K,Q=Quiet/S,T=Tiny/S";
enum opts {
	OPT_USER, OPT_PASSWORD, OPT_FILTER, OPT_FOLDER, OPT_SERVER, OPT_QUIET, OPT_TINY,
	OPT_COUNT};
static LONG opts[OPT_COUNT];


// Globals
// -------

extern struct DosLibrary *DOSBase;

struct Library *UMSBase = NULL;
UMSAccount Account = NULL;

struct BitSpec
 {
  char *name;
  LONG bit;
  BOOL global;
 };

struct BitSpec BitSpecs[] =
 {
  {"Archive"    , UMSUSTATF_Archive    ,FALSE},
  {"Junk"       , UMSUSTATF_Junk       ,FALSE},
  {"PostPoned"  , UMSUSTATF_PostPoned  ,FALSE},
  {"Selected"   , UMSUSTATF_Selected   ,FALSE},
  {"Old"        , UMSUSTATF_Old        ,FALSE},
  {"WriteAccess", UMSUSTATF_WriteAccess,FALSE},
  {"ReadAccess" , UMSUSTATF_ReadAccess ,FALSE},
  {"ViewAccess" , UMSUSTATF_ViewAccess ,FALSE},
  {"Owner"      , UMSUSTATF_Owner      ,FALSE},
  {"UFlag0"     , (1<<0 )              ,FALSE},
  {"UFlag1"     , (1<<1 )              ,FALSE},
  {"UFlag2"     , (1<<2 )              ,FALSE},
  {"UFlag3"     , (1<<3 )              ,FALSE},
  {"UFlag4"     , (1<<4 )              ,FALSE},
  {"UFlag5"     , (1<<5 )              ,FALSE},
  {"UFlag6"     , (1<<6 )              ,FALSE},
  {"UFlag7"     , (1<<7 )              ,FALSE},
  {"UFlag8"     , (1<<8 )              ,FALSE},
  {"UFlag9"     , (1<<9 )              ,FALSE},
  {"UFlagA"     , (1<<10)              ,FALSE},
  {"UFlagB"     , (1<<11)              ,FALSE},
  {"UFlagC"     , (1<<12)              ,FALSE},
  {"UFlagD"     , (1<<13)              ,FALSE},
  {"UFlagE"     , (1<<14)              ,FALSE},
  {"UFlagF"     , (1<<15)              ,FALSE},
  {"Deleted"    , UMSGSTATF_Deleted    ,TRUE },
  {"Expired"    , UMSGSTATF_Expired    ,TRUE },
  {"Exported"   , UMSGSTATF_Exported   ,TRUE },
  {"Orphan"     , UMSGSTATF_Orphan     ,TRUE },
  {"Link"       , UMSGSTATF_Link       ,TRUE },
  {"HardLink"   , UMSGSTATF_HardLink   ,TRUE },
  {NULL,0,0 }
 };

struct BitSpec *FindBit(char *name)

{
 struct BitSpec *b=BitSpecs;

 while (b->name)
  {
   if (!stricmp(b->name,name)) return(b);
   b++;
  }
 return(NULL);
}


// CTRL-C Stuff
// ------------

int brk(void)

{
 return 0;
}

// Main Function
// -------------

void main(int argc,char *argv[])

{
 int erg=20;
 int anz;
 int fi;
 struct RDArgs *args_ptr;

 onbreak(brk);

 if ((argc<2) || (argv[1][0]=='?'))
  {
   struct BitSpec *b=BitSpecs;
   int i;

   fprintf (stderr,"\33[1m%s\33[0m, written by Matthias Scheler, Public Domain.\n\nTemplate: %s\n%s",
            &VersionString[6],TemplateString,UsageString);
   fprintf (stderr,"    bit-specs : ");

   i=0;
   while (b->name)
    {
     fprintf (stderr,"%s%c ",b->name,(b+1)->name ? ',' : '.');
     b++;
     if (++i==6)
      {
       i=0;
       fprintf (stderr,"\n                ");
      }
    }

   fprintf (stderr,"\n\n");
  }

 {
  int i;

  for (i=0; i<OPT_COUNT; i++)
   opts[i]=NULL;
 }

 if (args_ptr = ReadArgs(TemplateString, opts, NULL))
  {
   if (UMSBase=OpenLibrary(UMSNAME,UMSVERSION))
    {
     if (Account=UMSRLogin((char *)opts[OPT_SERVER],(char *)opts[OPT_USER],(char *)opts[OPT_PASSWORD]))
      {
       if (!(fi=UmsFilterExpression((char *)opts[OPT_FILTER],Account,0,0,1)))
        {
         UMSMsgNum MsgNum;
         char *Fields[UMSNUMFIELDS];

         (void)UMSSelectTags(Account,
                             UMSTAG_SelWriteLocal,TRUE,
                             UMSTAG_SelUnset,2L,
                             TAG_DONE);
         (void)UMSSelectTags(Account,
                             UMSTAG_SelMask,
                              UMSUSTATF_ViewAccess|UMSUSTATF_ReadAccess|UMSUSTATF_WriteAccess,
                             UMSTAG_SelMatch,
                              UMSUSTATF_ViewAccess|UMSUSTATF_ReadAccess|UMSUSTATF_WriteAccess,
                             UMSTAG_SelWriteLocal,TRUE,
                             UMSTAG_SelSet,2L,
                             TAG_DONE);

         anz=0;
         while (MsgNum=UMSSearchTags(Account,
                       UMSTAG_SearchLocal,TRUE,
                       UMSTAG_SearchMask,3L,
                       UMSTAG_SearchMatch,3L,
                       TAG_DONE))
          {
           if (!UMSReadMsgTags(Account,
                               UMSTAG_RMsgNum,MsgNum,
                               UMSTAG_RNoUpdate,TRUE,
                               UMSTAG_RTextFields,&Fields[0],
                               UMSTAG_RReadAll,TRUE,
                               TAG_DONE))
            {
             fprintf (stderr,"error reading message #%d: %s\n",MsgNum,UMSErrTxt(Account));
             break;
            }

           Fields[UMSCODE_Folder]=(char *)opts[OPT_FOLDER];
           if (!UMSWriteMsgTags(Account,
                                UMSTAG_WMsgNum,MsgNum,
                                UMSTAG_WNoUpdate,TRUE,
                                UMSTAG_WTextFields,&Fields[0],
                                TAG_DONE))
            {
             fprintf (stderr,"error writing message #%d: %s\n",MsgNum,UMSErrTxt(Account));

             UMSFreeMsg (Account,MsgNum);
             break;
            }

           UMSFreeMsg (Account,MsgNum);
           (void)UMSSelectTags(Account,
                               UMSTAG_SelWriteLocal,TRUE,
                               UMSTAG_SelMsg,MsgNum,
                               UMSTAG_SelUnset,1L,
                               TAG_DONE);

           if (SetSignal(0L,SIGBREAKF_CTRL_C)&SIGBREAKF_CTRL_C)
            {
             fprintf (stderr,"*** BREAK\n");
             break;
            }

           anz++;
          }

         if (MsgNum==0L)
          {
           if (!opts[OPT_QUIET])
            if (opts[OPT_TINY]) printf ("set folder for %d Msgs to \"%s\".\n",anz,(char *)opts[OPT_FOLDER]);
            else printf ("set folder for %d Msgs (%s) to \"%s\".\n",anz,(char *)opts[OPT_FILTER],(char *)opts[OPT_FOLDER]);
           erg=0;
           if (anz==0) erg=5;
          }
        }
       else fprintf (stderr,"\7Expression Error %ld\n",fi);

       UMSLogout( Account);
      }
     else fprintf (stderr,"\7UMS-Login failed.\n");

     CloseLibrary (UMSBase);
    }
   else fprintf (stderr,"\7Could not open %s V%d.\n",UMSNAME,UMSVERSION);

   FreeArgs(args_ptr);
  }
 else
  {
   PrintFault(IoErr(), NULL);
   exit(RETURN_ERROR);
  }

 exit (erg);
}