/*
 * Copyright (C) 1996-8 Michael R. Elkins <me@cs.hmc.edu>
 * 
 *     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., 675 Mass Ave, Cambridge, MA 02139, USA.
 */ 

#define MAIN_C 1

#include "mutt.h"
#include "mutt_curses.h"
#include "keymap.h"
#include "mailbox.h"
#include "send.h"
#include "parse.h"

#include <string.h>
#include <stdlib.h>
#include <locale.h>
#include <unistd.h>
#include <errno.h>
#include <sys/stat.h>
#include <sys/utsname.h>

const char Notice[] = "\
Copyright (C) 1996-8 Michael R. Elkins <me@cs.hmc.edu>\n\
Mutt comes with ABSOLUTELY NO WARRANTY; for details type `mutt -vv'.\n\
Mutt is free software, and you are welcome to redistribute it\n\
under certain conditions; type `mutt -vv' for details.\n";

const char Copyright[] = "\
Copyright (C) 1996-8 Michael R. Elkins <me@cs.hmc.edu>\n\
\n\
    This program is free software; you can redistribute it and/or modify\n\
    it under the terms of the GNU General Public License as published by\n\
    the Free Software Foundation; either version 2 of the License, or\n\
    (at your option) any later version.\n\
\n\
    This program is distributed in the hope that it will be useful,\n\
    but WITHOUT ANY WARRANTY; without even the implied warranty of\n\
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n\
    GNU General Public License for more details.\n\
\n\
    You should have received a copy of the GNU General Public License\n\
    along with this program; if not, write to the Free Software\n\
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.\n";

void mutt_exit (int code)
{
  mutt_endwin (NULL);
  exit (code);
}

static void mutt_usage (void)
{
  puts ("Usage:\n\
mutt [ -nzZ ] [ -F <muttrc> ] [ -m <type> ] [ -f <mailbox> ]\n\
mutt [ -nx ] [ -a <file> ] [ -F <muttrc> ] [ -H <file> ] [ -i <file> ] [ -s <subj> ] [ -b <addr> ] [ -c <addr> ] <addr> [ ... ]\n\
mutt [ -n ] [ -F <muttrc> ] -p\n\
mutt -v\n\
\n\
-a <file>\tattach a file to the message\n\
-b <address>\tspecify a blind carbon-copy (BCC) address\n\
-c <address>\tspecify a carbon-copy (CC) address\n\
-f <mailbox>\tspecify which mailbox to read\n\
-F <muttrc>\tspecify an alternate muttrc file\n\
-H <file>\tspecify a draft file to read header from\n\
-i <file>\tspecify a file which Mutt should include in the reply\n\
-m <type>\tspecify a default mailbox type\n\
-n\t\tcauses Mutt not to read the system Muttrc\n\
-p\t\trecall a postponed message\n\
-R\t\topen mailbox in read-only mode\n\
-s <subj>\tspecify a subject (must be in quotes if it has spaces)\n\
-v\t\tshow version and compile-time definitions\n\
-x\t\tsimulate the mailx send mode\n\
-y\t\tselect a mailbox specified in your `mailboxes' list\n\
-z\t\texit immediately if there are no messages in the mailbox\n\
-Z\t\topen the first folder with new message, exit immediately if none\n\
-h\t\tthis help message");

  exit (0);
}

static void show_version (void)
{
  struct utsname uts;

  printf ("Mutt %s, ", VERSION);
  puts (Notice);

  uname (&uts);

#ifdef _AIX
  printf ("System info: %s %s.%s", uts.sysname, uts.version, uts.release);
#elif defined (SCO)
  printf ("System info: SCO %s", uts.release);
#else
  printf ("System info: %s %s", uts.sysname, uts.release);
#endif

#ifdef NCURSES_VERSION
  printf (" [using ncurses %s]", NCURSES_VERSION);
#elif defined(USE_SLANG_CURSES)
  printf (" [using slang %d]", SLANG_VERSION);
#endif

  puts ("\n\nCompile time definitions:");

#ifdef DOMAIN
  printf ("DOMAIN=\"%s\"\n", DOMAIN);
#else
  puts ("-DOMAIN");
#endif

#ifdef HIDDEN_HOST
  fputs ("+HIDDEN_HOST  ", stdout);
#else
  fputs ("-HIDDEN_HOST  ", stdout);
#endif

#ifdef HOMESPOOL
  fputs ("+HOMESPOOL  ", stdout);
#else
  fputs ("-HOMESPOOL  ", stdout);
#endif
 
#ifdef USE_SETGID
  fputs ("+USE_SETGID  ", stdout);
#else
  fputs ("-USE_SETGID  ", stdout);
#endif

#ifdef USE_DOTLOCK
  fputs ("+USE_DOTLOCK  ", stdout);
#else
  fputs ("-USE_DOTLOCK  ", stdout);
#endif

#ifdef USE_FCNTL
  fputs ("+USE_FCNTL  ", stdout);
#else
  fputs ("-USE_FCNTL  ", stdout);
#endif

#ifdef USE_FLOCK
  puts ("+USE_FLOCK");
#else
  puts ("-USE_FLOCK");
#endif

#ifdef USE_POP
  fputs ("+USE_POP  ", stdout);
#else
  fputs ("-USE_POP  ", stdout);
#endif

#ifdef HAVE_REGCOMP
  fputs ("+HAVE_REGCOMP  ", stdout);
#else
  fputs ("-HAVE_REGCOMP  ", stdout);
#endif

#ifdef USE_GNU_RX
  fputs ("+USE_GNU_RX  ", stdout);
#else
  fputs ("-USE_GNU_RX  ", stdout);
#endif

#ifdef HAVE_COLOR
  fputs ("+HAVE_COLOR  ", stdout);
#else
  fputs ("-HAVE_COLOR  ", stdout);
#endif

#ifdef _PGPPATH
#ifdef HAVE_PGP5
  fputs ("+HAVE_PGP5  ", stdout);
#endif
#endif

#ifdef BUFFY_SIZE
  puts ("+BUFFY_SIZE");
#else
  puts ("-BUFFY_SIZE");
#endif

  printf ("SENDMAIL=\"%s\"\n", SENDMAIL);
  printf ("MAILPATH=\"%s\"\n", MAILPATH);
  printf ("SHAREDIR=\"%s\"\n", SHAREDIR);

#ifdef ISPELL
  printf ("ISPELL=\"%s\"\n", ISPELL);
#else
  puts ("-ISPELL");
#endif

#ifdef _PGPPATH
  printf ("_PGPPATH=\"%s\"\n", _PGPPATH);
#endif

  exit (0);
}

static void start_curses (void)
{
  km_init (); /* must come before mutt_init */

#ifdef USE_SLANG_CURSES
  SLtt_Ignore_Beep = 1; /* don't do that #*$@^! annoying visual beep! */
  SLsmg_Display_Eight_Bit = 128; /* characters above this are printable */
#endif
  if (initscr () == NULL)
  {
    puts ("Error initializing terminal.");
    exit (1);
  }
  ci_start_color ();
  keypad (stdscr, TRUE);
  cbreak ();
  noecho ();
#if HAVE_TYPEAHEAD
  typeahead (-1);       /* simulate smooth scrolling */
#endif
  mutt_signal_init ();
#if HAVE_META
  meta (stdscr, TRUE);
#endif
}

#define M_IGNORE  (1<<0)	/* -z */
#define M_BUFFY   (1<<1)	/* -Z */
#define M_NOSYSRC (1<<2)	/* -n */
#define M_RO      (1<<3)	/* -R */
#define M_SELECT  (1<<4)	/* -y */

int main (int argc, char **argv)
{
  char folder[_POSIX_PATH_MAX] = "";
  char *subject = NULL;
  char *includeFile = NULL;
  char *draftFile = NULL;
  char *newMagic = NULL;
  HEADER *msg = NULL;
  LIST *attach = NULL;
  int sendflags = 0;
  int flags = 0;
  int version = 0;
  int i;
  extern char *optarg;
  extern int optind;

  SRAND (time (NULL));
  setlocale (LC_CTYPE, "");
  umask (077);

#ifdef USE_SETGID
  /* Determine the user's default gid and the gid to use for locking the spool
   * mailbox on those systems which require setgid "mail" to write to the
   * directory.  This function also resets the gid to "normal" since the
   * effective gid will be "mail" when we start (Mutt attempts to run
   * non-setgid whenever possible to reduce the possibility of security holes).
   */

  /* Get the default gid for the user */
  UserGid = getgid ();

  /* it is assumed that we are setgid to the correct gid to begin with */
  MailGid = getegid ();

  /* reset the effective gid to the normal gid */
  if (SETEGID (UserGid) != 0)
  {
    perror ("setegid");
    exit (0);
  }
#endif

  memset (Options, 0, sizeof (Options));

  while ((i = getopt (argc, argv, "a:b:F:f:c:d:H:s:i:hm:npRvxyzZ")) != EOF)
    switch (i)
    {
      case 'a':
	{
	  LIST *t;

	  t = attach;
	  while (t && t->next)
	    t = t->next;
	  if (t)
	  {
	    t->next = mutt_new_list ();
	    t = t->next;
	  }
	  else
	    attach = t = mutt_new_list ();
	  t->data = safe_strdup (optarg);
	}
	break;

      case 'F':

	strfcpy (Muttrc, optarg, sizeof (Muttrc));
	break;

      case 'f':

	strfcpy (folder, optarg, sizeof (folder));
	break;

      case 'b':
      case 'c':

	if (!msg)
	  msg = mutt_new_header ();
	if (!msg->env)
	  msg->env = mutt_new_envelope ();
	rfc822_parse_adrlist (i == 'b' ? &msg->env->bcc : &msg->env->cc,
			      optarg, "@");
	break;

      case 'd':
#ifdef DEBUG
	debuglevel = atoi (optarg);
	printf ("Debugging at level %d.\n", debuglevel);
#else
	printf ("DEBUG was not defined during compilation.  Ignored.\n");
#endif
	break;

      case 'H':

	draftFile = optarg;
	break;

      case 'i':

	includeFile = optarg;
	break;

      case 'm':

	/* should take precedence over .muttrc setting, so save it for later */
	newMagic = optarg; 
	break;

      case 'n':

	flags |= M_NOSYSRC;
	break;

      case 'p':

	sendflags |= SENDPOSTPONED;
	break;

      case 'R':

	flags |= M_RO; /* read-only mode */
	break;

      case 's':

	subject = optarg;
	break;

      case 'v':

	version++;
	break;

      case 'x': /* mailx compatible send mode */

	sendflags |= SENDMAILX;
	break;

      case 'y': /* My special hack mode */

	flags |= M_SELECT;
	break;

      case 'z':

	flags |= M_IGNORE;
	break;

      case 'Z':

	flags |= M_BUFFY | M_IGNORE;
	break;

      default:

	mutt_usage ();
    }

  switch (version)
  {
    case 1:

      show_version ();
      break;

    case 2:

      printf ("Mutt %s, %s", VERSION, Copyright);
      exit (0);
  }

  /* Check for a batch send. */
  if (!isatty (0))
  {
    set_option (OPTNOCURSES);
    sendflags = SENDBATCH;
  }

  /*
   * This must come before mutt_init() because curses needs to be started
   * before calling the init_pair() function to set the color scheme.
   */
  if (!option (OPTNOCURSES))
    start_curses ();

  /* set defaults and read init files */
  mutt_init (flags & M_NOSYSRC);

  if (newMagic)
    mx_set_magic (newMagic);

  if (!option (OPTNOCURSES))
  {
    SETCOLOR (MT_COLOR_NORMAL);
    clear ();
  }

  if (sendflags & SENDPOSTPONED)
  {
    if (!option (OPTNOCURSES))
      mutt_flushinp ();
    ci_send_message (SENDPOSTPONED, NULL, NULL, NULL);
    mutt_endwin (NULL);
  }
  else if (subject || msg || sendflags || draftFile || includeFile || attach ||
	   optind < argc)
  {
    FILE *fin = NULL;
    char buf[LONG_STRING];
    char *tempfile = NULL;

    if (!option (OPTNOCURSES))
      mutt_flushinp ();

    if (!msg)
      msg = mutt_new_header ();

    if (!draftFile)
    {
      if (!msg->env)
	msg->env = mutt_new_envelope ();

      for (i = optind; i < argc; i++)
	rfc822_parse_adrlist (&msg->env->to, argv[i], "@");

      if (!msg->env->to && !msg->env->cc)
      {
	if (!option (OPTNOCURSES))
	  mutt_endwin (NULL);
	fputs ("No recipients specified.\n", stderr);
	exit (1);
      }

      msg->env->subject = safe_strdup (subject);

      if (includeFile)
      {
	mutt_mktemp (buf);
	tempfile = safe_strdup (buf);
	fin = fopen (includeFile, "r");
      }
    }
    else
    {
      if (strcmp ("-", draftFile) == 0)
	fin = stdin;
      else if ((fin = fopen (draftFile, "r")) == NULL)
      {
	if (!option (OPTNOCURSES))
	  mutt_endwin (NULL);
	perror (draftFile);
	exit (1);
      }
      mutt_mktemp (buf);
      tempfile = safe_strdup (buf);

      msg->env = mutt_read_rfc822_header (fin, NULL);
    }

    if (tempfile)
    {
      FILE *fout;

      if ((fout = fopen (tempfile, "w")) == NULL)
      {
	if (!option (OPTNOCURSES))
	  mutt_endwin (NULL);
	perror (tempfile);
	fclose (fin);
	free (tempfile);
      }

      mutt_copy_stream (fin, fout);
      fclose (fout);
      fclose (fin);
    }

    if (attach)
    {
      LIST *t = attach;
      BODY *a = NULL;

      while (t)
      {
	if (a)
	{
	  a->next = mutt_make_attach (t->data);
	  a = a->next;
	}
	else
	  msg->content = a = mutt_make_attach (t->data);
	if (!a)
	{
	  if (!option (OPTNOCURSES))
	    mutt_endwin (NULL);
	  fprintf (stderr, "%s: unable to attach file.\n", t->data);
	  mutt_free_list (&attach);
	  exit (1);
	}
	t = t->next;
      }
      mutt_free_list (&attach);
    }

    ci_send_message (sendflags, msg, tempfile, NULL);

    if (!option (OPTNOCURSES))
      mutt_endwin (NULL);
  }
  else
  {
    if (flags & M_BUFFY)
    {
      if (mutt_buffy_check () == 0)
      {
	mutt_endwin ("No mailbox with new mail.");
	exit (1);
      }
      folder[0] = 0;
      mutt_buffy (folder);
    }
    else if (flags & M_SELECT)
    {
      folder[0] = 0;
      mutt_select_file (folder, sizeof (folder), 1);
      if (!folder[0])
      {
	mutt_endwin (NULL);
	exit (0);
      }
    }

    if (!folder[0])
      strfcpy (folder, Spoolfile, sizeof (folder));
    mutt_expand_path (folder, sizeof (folder));

    if (flags & M_IGNORE)
    {
      struct stat st;

      /* check to see if there are any messages in the folder */
      if (stat (folder, &st) != 0)
      {
	mutt_endwin (strerror (errno));
	exit (1);
      }

      if (st.st_size == 0)
      {
	mutt_endwin ("Mailbox is empty.");
	exit (1);
      }
    }

    mutt_folder_hook (folder);

    if ((Context = mx_open_mailbox (folder, ((flags & M_RO) || option (OPTREADONLY)) ? M_READONLY : 0, NULL)) != NULL)
    {
      mutt_index_menu ();
      mutt_endwin (NULL);
    }
    else
      mutt_endwin (Errorbuf);
  }

  exit (0);
}