#include <stdio.h>
#include <ctype.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <strings.h>
#include <sysexits.h>
#include <sys/time.h>

extern const char *__progname;

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

static int nfolders;
static FOLDER **folders;
static unsigned int *flags;
#define F_DISTINCT  0x00000001
#define F_CANTOPEN  0x00000002
#define F_CANTWRITE 0x00000004
#define F_LOCKED    0x00000008
#define F_ERROR (F_CANTOPEN|F_CANTWRITE)
static MESSAGE **msgs;
static int nfail;
static char **seqs;
static int nseqs;
static int do_unseen = 1;

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 get_folder_list(int ac, char **av)
{
 int errs;
 int i;

 errs = 0;
 for (ac--,av++;ac;ac--,av++)
  { if (!strcmp(*av,"-u"))
     { do_unseen = 1;
       continue;
     }
    if (!strcmp(*av,"-U"))
     { do_unseen = 0;
       continue;
     }
    if ((ac > 1) && !strcmp(*av,"-s"))
     { add_seq(av[1]);
       ac --;
       av ++;
       continue;
     }
    break;
  }
 nfolders = 0;
 folders = 0;
 for (;ac;ac--,av++)
  { FOLDER *f;
    char *ep;
    if ((**av == '+') && folder_lookup(1+*av,&f,&ep) && !*ep)
     { nfolders ++;
       folders = realloc(folders,nfolders*sizeof(FOLDER *));
       folders[nfolders-1] = f;
     }
    else
     { fprintf(stderr,"%s: `%s': not a folder\n",__progname,*av);
       errs ++;
     }
  }
 if (errs) exit(1);
 if (nfolders == 0)
  { const char *fname;
    FOLDER *f;
    char *ep;
    fname = profile_lookup(system_get_profile(),"inbox");
    if (fname)
     { if (!folder_lookup(fname,&f,&ep) || *ep)
	{ /* {inbox} is invalid - where to complain to? */
	  fprintf(stderr,"%s: warning: invalid {inbox}\n",__progname);
	  fname = 0;
	}
     }
    if (! fname)
     { if (! folder_lookup("inbox",&f,0))
	{ fprintf(stderr,"%s: can't find a valid folder\n",__progname);
	  exit(EX_CONFIG);
	}
     }
    nfolders = 1;
    folders = malloc(sizeof(FOLDER *));
    *folders = f;
  }
 flags = malloc(nfolders*sizeof(*flags));
 for (i=0;i<nfolders;i++) flags[i] = 0;
}

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 nap(double time)
{
 struct timeval tv;

 tv.tv_sec = time;
 if (tv.tv_sec > time) tv.tv_sec --;
 tv.tv_usec = (time - tv.tv_sec) * 1000000;
 if (tv.tv_usec >= 1000000)
  { tv.tv_usec -= 1000000;
    tv.tv_sec ++;
  }
 select(0,0,0,0,&tv);
}

static double backoff_nap(int loops, unsigned int *vp)
{
 int v;

 v = *vp;
 v = (v >> 1) ^ ((v & 1) ? 0xedb88320 : 0);
 *vp = v;
 return((.1*loops)+(1e-9*(int)(v&0x1fffffff)));
}

/* We have to be careful here to avoid danger of deadlock when two messages
   get delivered to the same folders in different orders.  Essentially, the
   way we avoid deadlock is to never do a blocking folder_lock unless we're
   holding no other folder locks.  We avoid livelock by varying the backoff
   nap time if we end up going around the loop too often. */
static void lock_all_folders(void)
{
 int i;
 int lastfail;
 int loops;
 unsigned int backoff_val;

 backoff_val = getpid();
 loops = 0;
 while (1)
  { lastfail = -1;
    for (i=0;i<nfolders;i++)
     { if (flags[i] & F_CANTOPEN) continue;
       if (flags[i] & F_LOCKED) continue;
       if (folder_lock(folders[i],FOLDER_NOWAIT|FOLDER_EXCLUSIVE) < 0)
	{ if (errno != EWOULDBLOCK)
	   { fprintf(stderr,"%s: can't lock +%s: %s\n",__progname,folder_name(folders[i]),strerror(errno));
	     flags[i] |= F_CANTOPEN;
	     continue;
	   }
	  lastfail = i;
	}
       else
	{ flags[i] |= F_LOCKED;
	}
     }
    if (lastfail < 0) return;
    for (i=0;i<nfolders;i++)
     { if (flags[i] & F_LOCKED)
	{ folder_unlock(folders[i]);
	  flags[i] &= ~F_LOCKED;
	}
     }
    if (folder_lock(folders[lastfail],FOLDER_WAIT|FOLDER_EXCLUSIVE) < 0)
     { fprintf(stderr,"%s: can't lock +%s: %s\n",__progname,folder_name(folders[lastfail]),strerror(errno));
       flags[lastfail] |= F_CANTOPEN;
       continue;
     }
    flags[lastfail] |= F_LOCKED;
    loops ++;
    if (loops > 30)
     { fprintf(stderr,"%s: apparent livelock locking folders\n",__progname);
       exit(EX_SOFTWARE);
     }
    if (loops > 3) nap(backoff_nap(loops,&backoff_val));
  }
}

static void create_messages(void)
{
 int i;
 int j;
 char buf[8192];
 int nr;

 if (do_unseen)
  { const char *useq;
    useq = profile_lookup(system_get_profile(),"unseen-sequence");
    if (useq)
     { int nus;
       const char **usv;
       ws_split(useq,&nus,&usv);
       for (i=0;i<nus;i++) add_seq(usv[i]);
       free(usv);
     }
  }
 msgs = malloc(nfolders*sizeof(MESSAGE *));
 nfail = 0;
 lock_all_folders();
 for (i=0;i<nfolders;i++)
  { for (j=0;j<i;j++)
     { if (! (flags[j] & F_DISTINCT)) continue;
       msgs[i] = folder_new_link(folders[i],message_path(msgs[j]));
       if (msgs[i]) break;
     }
    if (j >= i)
     { msgs[i] = folder_new_create(folders[i]);
       if (! msgs[i])
	{ fprintf(stderr,"%s: can't create message in +%s: %s\n",__progname,folder_name(folders[i]),strerror(errno));
	  flags[i] |= F_CANTOPEN;
	  nfail ++;
	}
       else
	{ flags[i] |= F_DISTINCT;
	}
     }
    if (msgs[i])
     { SEQS *ss;
       int j;
       ss = seqs_open(folders[i]);
       if (ss)
	{ SEQ *cs;
	  SEQ *ns;
	  for (j=0;j<nseqs;j++) seq_add(seq_lookup(ss,seqs[j]),message_number(msgs[i]));
	  cs = seq_lookup(ss,"cur");
	  if (seq_get(cs,0,0,0) > 0)
	   { ns = seq_lookup(ss,"next");
	     if (seq_get(ns,0,0,0) < 1)
	      { seq_add(ns,message_number(msgs[i]));
	      }
	   }
	  seqs_close(ss);
	}
       else
	{ fprintf(stderr,"%s: can't open sequence database in +%s: %s\n",__progname,folder_name(folders[i]),strerror(errno));
	}
     }
  }
 while (1)
  { nr = read(0,&buf[0],sizeof(buf));
    if (nr <= 0)
     { if (nr < 0) fprintf(stderr,"%s: input read error: %s\n",__progname,strerror(errno));
       break;
     }
    for (i=0;i<nfolders;i++)
     { if ((flags[i] & (F_DISTINCT|F_ERROR)) == F_DISTINCT)
	{ if (fwrite(&buf[0],1,nr,message_fp(msgs[i])) != nr)
	   { fprintf(stderr,"%s: error writing message to %s: %s\n",__progname,message_path(msgs[i]),strerror(errno));
	     flags[i] |= F_CANTWRITE;
	     nfail ++;
	   }
	}
     }
  }
 for (i=0;i<nfolders;i++)
  { message_free(msgs[i]);
    folder_unlock(folders[i]);
  }
}

static int exitstatus(void)
{
 int i;
 int ofail;
 int wfail;

 if (! nfail) return(EX_OK);
 for (i=0;i<nfolders;i++)
  { if (! (flags[i] & F_DISTINCT)) continue;
    if ((flags[i] & F_ERROR) == 0) return(EX_OK);
    if (flags[i] & F_CANTOPEN) ofail ++;
    if (flags[i] & F_CANTWRITE) wfail ++;
  }
 return(ofail?EX_OSERR:wfail?EX_IOERR:EX_SOFTWARE);
}

int main(int, char **);
int main(int ac, char **av)
{
 if (system_lock(SYS_SHARED|SYS_WAIT) < 0)
  { fprintf(stderr,"%s: can't lock system: %s\n",__progname,strerror(errno));
    exit(EX_OSERR);
  }
 get_folder_list(ac,av);
 create_messages();
 system_unlock();
 exit(exitstatus());
}