#include "billingkom.h"

struct commandnames commandnames[] = { { "SHOWTIME",           kom_showtime          },
                                       { "SHOWVERSION",        kom_showversion       },
                                       { "WHERE",              kom_where             },
                                       { "QUIT",               kom_quit              },
                                       { "LISTSUBJECTS",       kom_listsubjects      },
                                       { "LISTPARKED",         kom_listparked        },
                                       { "LISTUNREAD",         kom_listunread        },
                                       { "LISTGROUPS",         kom_listgroups        },
                                       { "NEXTGROUP",          kom_nextgroup         },
                                       { "SKIPTREE",           kom_skiptree          },
                                       { "DUMPMESSAGE",        kom_dumpmessage       },
                                       { "READMESSAGE",        kom_readmessage       },
                                       { "READAGAIN",          kom_readagain         },
                                       { "READPARENT",         kom_readparent        },
                                       { "FORWARDS",           kom_forwards          },
                                       { "BACKWARDS",          kom_backwards         },
                                       { "NEXTMESSAGE",        kom_nextmessage       },
                                       { "NEXTREPLY",          kom_nextreply         },
                                       { "LISTCOMMANDS",       kom_listcommands      },
                                       { "SETUNREAD",          kom_setunread         },
                                       { "SHOWFILE",           kom_showfile          },
                                       { "GOTOGROUP",          kom_gotogroup         },
                                       { "POSTPONE",           kom_postpone          },
                                       { "POSTPONEDUNREAD",    kom_postponedunread   },
                                       { "EXECUTE",            kom_execute           },
                                       { "DELETEMESSAGE",      kom_deletemessage     },
                                       { "SCREENLENGTH",       kom_screenlength      },
                                       { "LINEWIDTH",          kom_linewidth         },
                                       { "LISTFLAGS",          kom_listflags         },
                                       { "FLAGON",             kom_flagon            },
                                       { "FLAGOFF",            kom_flagoff           },
                                       { "SUBSCRIBE",          kom_subscribe         },
                                       { "UNSUBSCRIBE",        kom_unsubscribe       },
                                       { "PARK",               kom_park              },
                                       { "UNPARK",             kom_unpark            },
                                       { "POSTMESSAGE",        kom_postmessage       },
                                       { "MAILMESSAGE",        kom_mailmessage       },
                                       { "FOLLOWUP",           kom_followup          },
                                       { "REPLY",              kom_reply             },
                                       { "EDITMESSAGE",        kom_editmessage       },
                                       { "FORWARDMAIL",        kom_forwardmail       },
                                       { "FORWARDPOST",        kom_forwardpost       },
                                       { "SELECT",             kom_select            },
                                       { "LISTSELECTED",       kom_listselected      },
                                       { "NEXTSELECTED",       kom_nextselected      },
                                       { "SHOWHELP",           kom_showhelp          },
                                       { NULL, NULL } };

struct commandnames editcommandnames[] = { { "ADDRECIPIENT",     editkom_addrecipient      },
                                           { "REMRECIPIENT",     editkom_remrecipient      },
                                           { "MOVEGROUP",        editkom_movegroup         },
                                           { "SHOWHEADER",       editkom_showheader        },
                                           { "SETSUBJECT",       editkom_setsubject        },
                                           { "SETATTRIBUTES",    editkom_setattributes     },
                                           { "SETORGANIZATION",  editkom_setorganization   },
                                           { "SETDISTRIBUTION",  editkom_setdistribution   },
                                           { "SETFOLLOWUPGROUP", editkom_setfollowupgroup  },
                                           { "SETREPLYTO",       editkom_setreplyto        },
                                           { "SETATTACHMENT",    editkom_setattachment     },
                                           { "EDITTEXT",         editkom_editmessage       },
                                           { "CANCELMESSAGE",    editkom_cancelmessage     },
                                           { "SAVEMESSAGE",      editkom_savemessage       },
                                           { "PARKMESSAGE",      editkom_parkmessage       },
                                           { "LISTCOMMANDS",     editkom_listcommands      },
                                           { "SHOWHELP",         editkom_showhelp          },
                                           { "SHOWFILE",         kom_showfile              },
                                           { NULL, NULL } };

struct command *firstcommand,*firsteditcommand;

extern char *commandsfile;

char *defaulthasselected,*defaulthascomment,*defaulthastext,*defaulthasgroup,*defaulttime;

bool readcommands(void)
{
   FILE *fp;
   char s[1000];
   long c,d,e,line;
   struct command *newcommand,*lastcommand,*lasteditcommand;

   if(!(fp=fopen(commandsfile,"r")))
   {
      printf("Can't read commands file %s\n",commandsfile);
      return(FALSE);
   }

   lastcommand=NULL;
   lasteditcommand=NULL;

   firstcommand=NULL;
   firsteditcommand=NULL;

   line=0;

   while(fgets(s,999,fp))
   {
      line++;

      if(strlen(s)>0 && s[strlen(s)-1]=='\n')
         s[strlen(s)-1]=0;

      if(s[0]!=0 && s[0]!='#')
      {
         for(c=0;s[c]!=',' && s[c]!=0;c++);

         if(s[c]!=',')
         {
            printf("%s, line %ld: Wrong syntax\n",commandsfile,line);
            return(FALSE);
         }

         s[c]=0;
         c++;

         while(s[c]==' ')
            c++;

         if(!(newcommand=(struct command *)malloc(sizeof(struct command))))
         {
            fclose(fp);
            return(FALSE);
         }

         mystrncpy(newcommand->command,s,100);

         for(d=c;s[d]!=' ' && s[d]!=0;d++);

         if(s[d]==' ')
         {
            s[d]=0;
            d++;
         }

         while(s[d]==' ')
            d++;

         mystrncpy(newcommand->data,&s[d],100);

         newcommand->next=NULL;

         if(newcommand->command[0]=='-')
         {
            strcpy(newcommand->command,&newcommand->command[1]);

            if(!firsteditcommand)
               firsteditcommand=newcommand;

            if(lasteditcommand)
               lasteditcommand->next=newcommand;

            for(e=0;editcommandnames[e].name;e++)
               if(stricmp(editcommandnames[e].name,&s[c])==0) break;

            if(editcommandnames[e].name)
            {
               newcommand->func=editcommandnames[e].func;
            }
            else
            {
               printf("%s, line %ld: Unknown command %s\n",commandsfile,line,&s[c]);
               fclose(fp);
               return(FALSE);
            }

            lasteditcommand=newcommand;
         }
         else
         {
            if(!firstcommand)
               firstcommand=newcommand;

            if(lastcommand)
               lastcommand->next=newcommand;

            for(e=0;commandnames[e].name;e++)
               if(stricmp(commandnames[e].name,&s[c])==0) break;

            if(commandnames[e].name)
            {
               newcommand->func=commandnames[e].func;

               if(stricmp("SHOWTIME",&s[c])==0)
                  defaulttime=newcommand->command;

               if(stricmp("NEXTGROUP",&s[c])==0)
                  defaulthasgroup=newcommand->command;

               if(stricmp("NEXTMESSAGE",&s[c])==0)
                  defaulthastext=newcommand->command;

               if(stricmp("NEXTREPLY",&s[c])==0)
                  defaulthascomment=newcommand->command;

               if(stricmp("NEXTSELECTED",&s[c])==0)
                  defaulthasselected=newcommand->command;
            }
            else
            {
               printf("%s, line %ld: Unknown command %s\n",commandsfile,line,&s[c]);
               fclose(fp);
               return(FALSE);
            }

            lastcommand=newcommand;
         }
      }
   }

   fclose(fp);

   if(!firstcommand)
   {
      printf("No commands configured\n");
      return(FALSE);
   }

   return(TRUE);
}

void freecommands(void)
{
   struct command *c,*c2;

   c=firstcommand;

   while(c)
   {
      c2=c->next;
      free(c);
      c=c2;
   }

   c=firsteditcommand;

   while(c)
   {
      c2=c->next;
      free(c);
      c=c2;
   }
}