#include <stdio.h>
#include <errno.h>
#include <ctype.h>
#include <stdlib.h>
#include <unistd.h>
#include <strings.h>

extern const char *__progname;

#include "seq.h"
#include "folder.h"
#include "system.h"
#include "msgarg.h"
#include "profile.h"
#include "context.h"
#include "message.h"

static int pflag = 0;
static int fflag = 0;
static int uflag = 0;
static int nseqs = 0;
static char **seqs;
#define UNKNOWN          0
#define MOVE_MSG_MSG     1
#define MOVE_MSGS_FOLDER 2
static int opmode = UNKNOWN;
static FOLDER *tofolder;
static MESSAGE *frommsg = 0;
static int nargs;
static char **argstr;
static ARG *args;
static FOLDER *curfolder;
static FOLDER *msgfolder;
static const char *rmbak;
static int rmbak_len;

static void add_seq(const char *s)
{
 int i;

 for (i=0;i<nseqs;i++) if (!strcmp(s,seqs[i])) return;
 nseqs ++;
 seqs = realloc(seqs,nseqs*sizeof(*seqs));
 seqs[nseqs-1] = strdup(s);
}

static void ws_split(const char *s, int *np, const char ***vp)
{
 int n;
 const char **v;
 const char *s0;
 char *t;

 n = 0;
 v = 0;
 while (1)
  { while (*s && isspace(*s)) s ++;
    if (! *s) break;
    s0 = s;
    while (*s && !isspace(*s)) s ++;
    t = malloc((s-s0)+1);
    bcopy(s0,t,s-s0);
    t[s-s0] = '\0';
    v = realloc(v,(n+1)*sizeof(*v));
    v[n++] = t;
  }
 *np = n;
 *vp = v;
}

static void crack_arglist(int ac, char **av)
{
 char *arg;
 int errs;

 for (ac--,av++;ac;ac--,av++)
  { if (!strcmp(*av,"-f"))
     { fflag = 1;
       continue;
     }
    if (!strcmp(*av,"-p"))
     { pflag = 1;
       continue;
     }
    if (!strcmp(*av,"-u"))
     { uflag = 1;
       continue;
     }
    if ((ac > 1) && !strcmp(*av,"-s"))
     { add_seq(av[1]);
       ac --;
       av ++;
       continue;
     }
    break;
  }
 nargs = 0;
 args = malloc(ac*sizeof(ARG));
 argstr = malloc(ac*sizeof(char *));
 errs = 0;
 for (;ac;ac--,av++)
  { arg = *av;
    if (! msgarg_parse(arg,args+nargs,0))
     { fprintf(stderr,"%s: invalid argument `%s'\n",__progname,arg);
       errs ++;
     }
    else
     { argstr[nargs] = arg;
       nargs ++;
     }
  }
 if (errs) exit(1);
 if (uflag)
  { const char *useq;
    useq = profile_lookup(system_get_profile(),"unseen-sequence");
    if (useq)
     { int nus;
       const char **usv;
       int i;
       ws_split(useq,&nus,&usv);
       for (i=0;i<nus;i++) add_seq(usv[i]);
       free(usv);
     }
  }
}

static int delete_it(MESSAGE *m)
{
 static char *rmbuf = 0;
 static int rmblen = 0;
 const char *p;
 const char *lc;
 int l;
 int rv;

 if (rmbak == 0)
  { rv = unlink(message_path(m));
  }
 else
  { p = message_path(m);
    lc = rindex(p,'/');
    if (lc) lc++; else lc = p;
    l = (lc-p) + rmbak_len + strlen(lc) + 1;
    if (l > rmblen)
     { free(rmbuf);
       rmblen = l + 8;
       rmbuf = malloc(rmblen);
     }
    bcopy(p,rmbuf,lc-p);
    sprintf(rmbuf+(lc-p),rmbak,lc);
    rv = rename(p,rmbuf);
  }
 if (rv < 0) return(-1);
 l = message_number(m);
 folder_deleted_messages(msgfolder,&l,1);
 return(0);
}

static void incoming_message(MESSAGE *m)
{
 SEQS *ss;
 int j;

 ss = seqs_open(message_folder(m));
 if (ss)
  { for (j=0;j<nseqs;j++) seq_add(seq_lookup(ss,seqs[j]),message_number(m));
    seqs_close(ss);
  }
 else
  { fprintf(stderr,"%s: can't open sequence database in +%s: %s\n",__progname,folder_name(message_folder(m)),strerror(errno));
  }
}

static void do_messages(int *vec, int nv, void *cookie __attribute__((__unused__)))
{
 MESSAGE *m;
 MESSAGE *n;
 int i;
 int d;

 if (opmode == MOVE_MSG_MSG)
  { if (nv != 1)
     { fprintf(stderr,"%s: this usage requires exactly one message for each argument\n",__progname);
       exit(1);
     }
    if (frommsg)
     { MESSAGE *m;
       FOLDER *fromfolder;
       m = message_make(msgfolder,vec[0]);
       if (access(message_path(m),F_OK) >= 0)
	{ if (! fflag)
	   { fprintf(stderr,"%s: %d already exists in +%s\n",__progname,message_number(m),folder_name(message_folder(m)));
	     exit(1);
	   }
	  if (delete_it(m) < 0)
	   { fprintf(stderr,"%s: can't remove %d from +%s: %s\n",__progname,message_number(m),folder_name(message_folder(m)),strerror(errno));
	     exit(1);
	   }
	}
       /* Always link(), never rename(); want error if target exists! */
       if (link(message_path(frommsg),message_path(m)) < 0)
	{ fprintf(stderr,"%s: can't link %d in +%s to %d in +%s: %s\n",__progname,message_number(frommsg),folder_name(message_folder(frommsg)),message_number(m),folder_name(message_folder(m)),strerror(errno));
	  exit(1);
	}
       if (! pflag)
	{ if (unlink(message_path(frommsg)) < 0)
	   { fprintf(stderr,"%s: can't remove %d from +%s: %s\n",__progname,message_number(frommsg),folder_name(message_folder(frommsg)),strerror(errno));
	     exit(1);
	   }
	  d = message_number(frommsg);
	  folder_deleted_messages(message_folder(frommsg),&d,1);
	}
       incoming_message(m);
       message_free(m);
       fromfolder = message_folder(frommsg);
       message_free(frommsg);
       folder_unlock(fromfolder);
     }
    else
     { folder_lock(msgfolder,FOLDER_WAIT|FOLDER_SHARED);
       frommsg = message_make(msgfolder,vec[0]);
     }
    return;
  }
 for (i=0;i<nv;i++)
  { m = message_make(msgfolder,vec[i]);
    n = folder_new_link(tofolder,message_path(m));
    if (! n)
     { fprintf(stderr,"%s: can't link %d from +%s into +%s: %s\n",__progname,message_number(m),folder_name(message_folder(m)),folder_name(tofolder),strerror(errno));
       vec[i] = -1;
     }
    else
     { if (! pflag)
	{ if (unlink(message_path(m)) < 0)
	   { fprintf(stderr,"%s: message %d in +%s not removed: %s\n",__progname,message_number(m),folder_name(msgfolder),strerror(errno));
	     vec[i] = -1;
	   }
	}
       incoming_message(n);
       message_free(n);
     }
    message_free(m);
  }
 folder_deleted_messages(msgfolder,vec,nv);
}

static void check_rmbak(void)
{
 const char *cp;
 int nstr;

 if (rmbak == 0) return;
 rmbak_len = strlen(rmbak);
 cp = rmbak;
 nstr = 0;
 while (1)
  { cp = index(cp,'%');
    if (cp == 0) break;
    switch (*++cp)
     { case '%':
	  rmbak_len --;
	  break;
       case 's':
	  if (nstr > 0)
	   { fprintf(stderr,"%s: {rmbak} includes multiple %%s escapes\n",__progname);
	     exit(1);
	   }
	  nstr ++;
	  rmbak_len -= 2;
	  break;
       case '\0':
	  fprintf(stderr,"%s: {rmbak} includes %% at end of string\n",__progname);
	  exit(1);
	  break;
       default:
	  fprintf(stderr,"%s: {rmbak} includes unknown escape %%%c\n",__progname,*cp);
	  exit(1);
	  break;
     }
  }
}

static void usage(void)
{
 fprintf(stderr,"Usage: %s [-p] [-f] message message\n",__progname);
 fprintf(stderr,"       %s [-p] message [message...] +folder\n",__progname);
}

static void process_args(void)
{
 int a;
 char *s;

 if (nargs < 2)
  { usage();
    exit(1);
  }
 if ((nargs > 2) || (args[1].type == AT_NOMSG))
  { opmode = MOVE_MSGS_FOLDER;
    nargs --;
    if (!args[nargs].folder || (args[nargs].type != AT_NOMSG))
     { fprintf(stderr,"%s: when moving multiple messages, last arg must be folder reference\n",__progname);
       usage();
       exit(1);
     }
    folder_lookup(args[nargs].folder,&tofolder,0);
    if (folder_lock(tofolder,FOLDER_WAIT|FOLDER_EXCLUSIVE) < 0)
     { fprintf(stderr,"%s: %s: can't lock +%s: %s\n",__progname,argstr[a],folder_name(tofolder),strerror(errno));
       exit(1);
     }
  }
 else
  { opmode = MOVE_MSG_MSG;
  }
 system_lock(SYS_SHARED|SYS_WAIT|SYS_FAILEXIT);
 if (! pflag)
  { rmbak = profile_lookup(system_get_profile(),"rmbak");
    check_rmbak();
  }
 s = context_lookup("folder");
 if (s)
  { folder_lookup(s,&curfolder,0);
    free(s);
  }
 else
  { curfolder = 0;
  }
 for (a=0;a<nargs;a++)
  { if (args[a].folder)
     { folder_lookup(args[a].folder,&msgfolder,0);
     }
    else
     { msgfolder = curfolder;
     }
    if (args[a].type == AT_NOMSG)
     { curfolder = msgfolder;
       continue;
     }
    if (! msgfolder)
     { fprintf(stderr,"%s: %s: no current folder - must specify a folder\n",argstr[a],__progname);
       continue;
     }
    if (folder_lock(msgfolder,FOLDER_WAIT|(pflag?FOLDER_SHARED:FOLDER_EXCLUSIVE)) < 0)
     { fprintf(stderr,"%s: %s: can't lock +%s: %s\n",__progname,argstr[a],folder_name(msgfolder),strerror(errno));
       continue;
     }
    msgarg_handle(args+a,msgfolder,do_messages,0);
    folder_unlock(msgfolder);
  }
}

int main(int, char **);
int main(int ac, char **av)
{
 crack_arglist(ac,av);
 process_args();
 exit(0);
}