/* This module, and the entire FvwmAuto program, and the concept for
 * interfacing this module to the Window Manager, are all original work
 * by Robert Nation
 *
 * Copyright 1994, Robert Nation. No guarantees or warantees or anything
 * are provided or implied in any way whatsoever. Use this program at your
 * own risk. Permission to use this program for any purpose is given,
 * as long as the copyright is kept intact.
 *
 * reworked by A.Kadlec (albrecht@auto.tuwien.ac.at) 09/96
 * to support an arbitrary enter_fn & leave_fn (command line arguments)
 * completely reworked, while I was there.
 *
 * Modified by John Aughey (jha@cs.purdue.edu) 11/96
 * to not perform any action when entering the root window
 *
 * Minor patch by C. Hines 12/96.
 *
 */
/* 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "config.h"

#if HAVE_SYS_BSDTYPES_H
#include <sys/bsdtypes.h> /* Saul */
#endif

#include <stdio.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <sys/wait.h>
#include <sys/time.h>

#include <unistd.h>
#include <ctype.h>
#include <stdlib.h>
#include "libs/Module.h"
#include "libs/fvwmlib.h"
#include "libs/fvwmsignal.h"

/* here is the old double parens trick. */
/* #define DEBUG */
#ifdef DEBUGTOFILE
#define DEBUG
#endif
#ifdef DEBUG
#define myfprintf(X) \
  fprintf X;\
  fflush (stderr);
#else
#define myfprintf(X)
#endif


static RETSIGTYPE TerminateHandler(int signo);

/***********************************************************************
 *
 *  Procedure:
 *  Termination procedure : *not* a signal handler
 *
 ***********************************************************************/
void DeadPipe(int nonsense)
{
  (void)nonsense;
  myfprintf((stderr,"Leaving via DeadPipe\n"));
  exit(0);
}

/***********************************************************************
 *
 *  Procedure:
 *  Signal handler that tells the module to quit
 *
 ***********************************************************************/
static RETSIGTYPE
TerminateHandler(int signo)
{
  fvwmSetTerminate(signo);
}

/***********************************************************************
 *
 *  Procedure:
 *	main - start of module
 *
 ***********************************************************************/
int
main(int argc, char **argv)
{
  char *enter_fn="Silent Raise";	/* default */
  char *leave_fn=NULL;
  unsigned long m_mask;
  unsigned long last_win = 0;	/* last window handled */
  unsigned long focus_win = 0;	/* current focus */
  unsigned long raised_win = 0;
  fd_set_size_t fd_width;
  int fd[2];
  int timeout;
  int sec = 0;
  int usec = 0;
  struct timeval value;
  struct timeval *delay;
  fd_set in_fdset;
  char raise_immediately;
#ifdef DEBUG
  int count = 0;
  char big_int_area[32];
#endif

#ifdef DEBUGTOFILE
  freopen(".FvwmAutoDebug","w",stderr);
#endif

  if(argc < 7 || argc > 9)
  {
    fprintf(stderr,"FvwmAuto can use one to three arguments.\n");
    exit(1);
  }

  /* Dead pipes mean fvwm died */
#ifdef HAVE_SIGACTION
  {
    struct sigaction  sigact;

    sigemptyset(&sigact.sa_mask);
    sigaddset(&sigact.sa_mask, SIGPIPE);
    sigaddset(&sigact.sa_mask, SIGINT);
    sigaddset(&sigact.sa_mask, SIGHUP);
    sigaddset(&sigact.sa_mask, SIGQUIT);
    sigaddset(&sigact.sa_mask, SIGTERM);
#ifdef SA_RESTART
    sigact.sa_flags = SA_RESTART;
# else
    sigact.sa_flags = 0;
#endif
    sigact.sa_handler = TerminateHandler;

    sigaction(SIGPIPE, &sigact, NULL);
    sigaction(SIGINT,  &sigact, NULL);
    sigaction(SIGHUP,  &sigact, NULL);
    sigaction(SIGQUIT, &sigact, NULL);
    sigaction(SIGTERM, &sigact, NULL);
  }
#else
  /* We don't have sigaction(), so fall back to less robust methods.  */
#ifdef USE_BSD_SIGNALS
  fvwmSetSignalMask( sigmask(SIGPIPE) |
                     sigmask(SIGINT)  |
                     sigmask(SIGHUP)  |
                     sigmask(SIGQUIT) |
                     sigmask(SIGTERM) );
#endif

  signal(SIGPIPE, TerminateHandler);
  signal(SIGINT,  TerminateHandler);
  signal(SIGHUP,  TerminateHandler);
  signal(SIGQUIT, TerminateHandler);
  signal(SIGTERM, TerminateHandler);
#ifdef HAVE_SIGINTERRUPT
  siginterrupt(SIGPIPE, 0);
  siginterrupt(SIGINT, 0);
  siginterrupt(SIGHUP, 0);
  siginterrupt(SIGQUIT, 0);
  siginterrupt(SIGTERM, 0);
#endif
#endif

  fd[0] = atoi(argv[1]);
  fd[1] = atoi(argv[2]);

  if ((timeout = atoi(argv[6])))
  {
    sec = timeout / 1000;
    usec = (timeout % 1000) * 1000;
    delay = &value;
    raise_immediately = 0;
  }
  else
  {
    raise_immediately = 1;
    delay = NULL;
  }

  if (argv[7])			/* if specified */
  {
    char *token;

    if (argc >= 8 && *argv[7] && !StrEquals(argv[7],"NOP")) /* not empty */
      enter_fn=argv[7];		/* override default */
    else if (argc >= 8)
      enter_fn=NULL;		/* nop */

    /* This is a hack to prevent user interaction with old configs. */
    if (enter_fn)
    {
      token = PeekToken(enter_fn, NULL);
      if (!StrEquals(token, "Silent"))
        enter_fn = safestrdup(CatString2("Silent ", enter_fn));
    }
    if (argc >= 9 && argv[8] && *argv[8] && !StrEquals(argv[8],"NOP"))
      /* leave function specified */
      leave_fn=argv[8];
    if (leave_fn)
    {
      token = PeekToken(leave_fn, NULL);
      if (!StrEquals(token, "Silent"))
        leave_fn = safestrdup(CatString2("Silent ", leave_fn));
    }
  }

  /* Exit if nothing to do. */
  if (!enter_fn && !leave_fn)
    return -1;

  m_mask = M_FOCUS_CHANGE;
  /* Disable special raise/lower support on general actions. *
   * This works as expected in most of cases. */
  if (matchWildcards("*Raise*", CatString2(enter_fn, leave_fn)) ||
      matchWildcards("*Lower*", CatString2(enter_fn, leave_fn)))
    m_mask |= M_RAISE_WINDOW | M_LOWER_WINDOW;

  /* migo (04/May/2000): It is simply incorrect to listen to raise/lower
   * packets and change the state if the action itself has no raise/lower.
   * Detecting whether to listen or not by the action name is good enough.
  m_mask = M_FOCUS_CHANGE | M_RAISE_WINDOW | M_LOWER_WINDOW;
   */

  SetMessageMask(fd, m_mask);
  /* tell fvwm we're running */
  SendFinishedStartupNotification(fd);
  /* tell fvwm that we want to be lock on send */
  SetSyncMask(fd, m_mask);

  fd_width = fd[1] + 1;
  FD_ZERO(&in_fdset);

  while( !isTerminated )
  {
    char raise_window_now;
    static char have_new_window = 0;

    FD_SET(fd[1], &in_fdset);

    myfprintf((stderr, "\nstart %d (ri = %d, hnw = %d, usec = %d)\n",
               count++, raise_immediately, have_new_window, usec));
    if (!raise_immediately)
    {
      /* fill in struct - modified by select() */
      delay->tv_sec = sec;
      delay->tv_usec = usec;
    }
    else
    {
      /* delay is already a NULL pointer */
    }
#ifdef DEBUG
    sprintf(big_int_area, "%d usecs", (int)delay->tv_usec);
    myfprintf((stderr, "select: delay = %s\n",
               (have_new_window) ? big_int_area : "infinite" ));
#endif
    if (fvwmSelect(fd_width,
                   &in_fdset, NULL, NULL,
                   (have_new_window) ? delay : NULL) == -1)
    {
      myfprintf((stderr, "select: error! (%s)\n", strerror(errno)));
      break;
    }

    raise_window_now = 0;
    if (FD_ISSET(fd[1], &in_fdset))
    {
      FvwmPacket *packet = ReadFvwmPacket(fd[1]);
      if ( packet == NULL )
      {
        myfprintf((stderr, "Leaving because of null packet\n"));
        break;
      }

      myfprintf((stderr, "pw = 0x%x, fw=0x%x, rw = 0x%x, lw=0x%x\n",
		 (int)packet->body[0], (int)focus_win, (int)raised_win,
		 (int)last_win));

      switch (packet->type)
      {
      case M_FOCUS_CHANGE:
        /* it's a focus package */
        focus_win = packet->body[0];
        myfprintf((stderr, "focus change\n"));

        if (focus_win != raised_win)
        {
          myfprintf((stderr, "its a new window\n"));
          have_new_window = 1;
          raise_window_now = raise_immediately;
        }
#ifdef DEBUG
        else fprintf(stderr, "no new window\n");
#endif
        break;

      case M_RAISE_WINDOW:
        myfprintf((stderr, "raise packet 0x%x\n", (int)packet->body[0]));
        raised_win = packet->body[0];
        if (have_new_window && focus_win == raised_win)
        {
          myfprintf((stderr, "its the old window: don't raise\n"));
          have_new_window = 0;
        }
        break;

      case M_LOWER_WINDOW:
        myfprintf((stderr, "lower packet 0x%x\n", (int)packet->body[0]));
        if (have_new_window && focus_win == packet->body[0])
        {
          myfprintf((stderr,
                     "window was explicitly lowered, don't raise it again\n"));
          have_new_window = 0;
        }
        break;
      } /* switch */
      SendUnlockNotification(fd);
    }
    else
    {
      if (have_new_window)
      {
        myfprintf((stderr, "must raise now\n"));
        raise_window_now = 1;
      }
    }

    if (raise_window_now)
    {
      myfprintf((stderr, "raising 0x%x\n", (int)focus_win));

      if (last_win && leave_fn)
      {
        /* if focus_win isn't the root */
        SendInfo(fd, leave_fn, last_win);
      }

      if (focus_win && enter_fn)
      {
        /* if focus_win isn't the root */
        SendInfo(fd, enter_fn, focus_win);
        raised_win = focus_win;
      }

      /* switch to wait mode again */
      last_win = focus_win;
      have_new_window = 0;
    }
  } /* while */

  return 0;
}