/* ``The contents of this file are subject to the Erlang Public License,
 * Version 1.1, (the "License"); you may not use this file except in
 * compliance with the License. You should have received a copy of the
 * Erlang Public License along with this software. If not, it can be
 * retrieved via the world wide web at http://www.erlang.org/.
 * 
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 * 
 * The Initial Developer of the Original Code is Ericsson Utvecklings AB.
 * Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
 * AB. All Rights Reserved.''
 * 
 *     $Id$
 */

#include <stdio.h>
#include <string.h>
#include "erl_driver.h"

static ErlDrvData monitor_drv_start(ErlDrvPort, char *);
static void monitor_drv_stop(ErlDrvData data);
static ErlDrvSSizeT monitor_drv_control(ErlDrvData, unsigned int,
					char *, ErlDrvSizeT, char **, ErlDrvSizeT);
static void handle_monitor(ErlDrvData drv_data, ErlDrvMonitor *monitor);

#define OP_I_AM_IPID 1
#define OP_MONITOR_ME 2
#define OP_DEMONITOR_ME 3
#define OP_MONITOR_ME_LATER 4
#define OP_DO_DELAYED_MONITOR 5

typedef struct one_monitor {
    ErlDrvTermData pid;
    int later_id;
    ErlDrvMonitor mon;
    struct one_monitor *next;
} OneMonitor;


typedef struct {
    ErlDrvPort port;
    ErlDrvTermData ipid;
    int later_counter;
    OneMonitor *first;
} MyDrvData;


static ErlDrvEntry monitor_drv_entry = { 
    NULL /* init */,
    monitor_drv_start,
    monitor_drv_stop,
    NULL /* output */,
    NULL /* ready_input */,
    NULL /* ready_output */,
    "monitor_drv",
    NULL /* finish */,
    NULL /* handle */,
    monitor_drv_control,
    NULL /* timeout */,
    NULL /* outputv */,
    NULL /* ready_async */,
    NULL /* flush */,
    NULL /* call */,
    NULL /* event */,
    ERL_DRV_EXTENDED_MARKER,
    ERL_DRV_EXTENDED_MAJOR_VERSION,
    ERL_DRV_EXTENDED_MINOR_VERSION,
    0,
    NULL, /* handle2 */
    handle_monitor
};

DRIVER_INIT(monitor_drv)
{
    return &monitor_drv_entry;
}

static ErlDrvData
monitor_drv_start(ErlDrvPort port, char *command) {
    MyDrvData *data = driver_alloc(sizeof(MyDrvData));
    data->port = port;
    data->ipid = driver_term_nil;
    data->first = NULL;
    data->later_counter = 0;
    return (ErlDrvData) data;
}

static void monitor_drv_stop(ErlDrvData data)
{
    driver_free((void *) data);
}

static void handle_monitor(ErlDrvData drv_data, ErlDrvMonitor *monitor)
{
    
    MyDrvData *data = (MyDrvData *) drv_data;
    OneMonitor *p,*o;
    for (p = data->first, o = NULL; 
	 p != NULL && driver_compare_monitors(&p->mon,monitor); 
	 o = p, p = p->next)
	;
    if (!p) {
	fprintf(stderr,"Spooky Monitor executed!\r\n");
    } else {
	 ErlDrvTermData spec[] = {
	      ERL_DRV_ATOM, driver_mk_atom("monitor_fired"),
	      ERL_DRV_PORT, driver_mk_port(data->port),
	      ERL_DRV_PID, p->pid,
	      ERL_DRV_TUPLE, TERM_DATA(3)
	 };
	if (!o) {
	    data->first = p->next;
	} else {
	    o->next = p->next;
	}
	driver_free(p);
	erl_drv_send_term(driver_mk_port(data->port), data->ipid, spec, sizeof(spec)/sizeof(ErlDrvTermData));
    }
    
    return;
}

static ErlDrvSSizeT
monitor_drv_control(ErlDrvData drv_data,
		     unsigned int command,
		     char *ibuf, ErlDrvSizeT ilen,
		     char **rbuf, ErlDrvSizeT rlen)
{
    MyDrvData *data = (MyDrvData *) drv_data;
    char *answer = NULL;
    char buff[64];
    ErlDrvSSizeT alen;

    switch (command) {
    case OP_I_AM_IPID:
	data->ipid = driver_caller(data->port);
	answer = "ok";
	break;
    case OP_MONITOR_ME:
	{
	    int res;
	    OneMonitor *om = driver_alloc(sizeof(OneMonitor));
	    om->pid = driver_caller(data->port);
	    om->later_id = 0;
	    res = driver_monitor_process(data->port,om->pid,&(om->mon));
	    if (res < 0) {
		answer = "error";
		driver_free(om);
	    } else if (res > 0) {
		answer = "noproc";
		driver_free(om);
	    } else {
		om->next = data->first;
		data->first = om;
		answer = "ok";
	    }
	    break;
	}
    case OP_DEMONITOR_ME:
	{
	    int res;
	    OneMonitor *p,*q = NULL;
	    int found = 0;
	    ErlDrvTermData pid = driver_caller(data->port);
	    for (p = data->first; p != NULL; p = p->next) {
		if (p->pid == pid) {
		    q = p;
		    ++found;
		}
	    }
	    if (q == NULL) {
		answer = "not_monitored";
	    } else {
		if (q->later_id > 0) {
		    if (found > 1) {
			answer = "delayd_but_more";
		    } else {
			answer = "delayed";
		    }
		} else {
		    res = driver_demonitor_process(data->port, &(q->mon));
		    if (res < 0) {
			answer = "error";
		    } else if (res > 0) {
			if (found > 1) {
			    answer = "gone_but_more";
			} else {
			    answer = "gone";
			}
		    } else {
			if (found > 1) {
			    answer = "ok_but_more";
			} else {
			    answer = "ok";
			}
		    }
		}
		if (data->first == q) {
		    data->first = q->next;
		} else {
		    for (p = data->first; p != NULL; p = p->next) {
			if (p->next == q) {
			    p->next = q->next;
			    break;
			}
		    }
		}
		driver_free(q);
	    }
	    break;
	}
    case OP_MONITOR_ME_LATER:
	{
	    int res;
	    OneMonitor *om = driver_alloc(sizeof(OneMonitor));
	    om->pid = driver_caller(data->port);
	    om->later_id = (++(data->later_counter));
	    om->next = data->first;
	    data->first = om;
	    sprintf(buff,"ok:%d",om->later_id);
	    answer = buff;
	    break;
	}
    case OP_DO_DELAYED_MONITOR:
	{
	    int id = 0, sign = 1, in_number = 0;
	    OneMonitor *p, *q;
	    char *bp;
	    for (bp = ibuf; bp < (ibuf + ilen); ++bp) {
		if (*bp <= '9' && *bp >= '0') {
		    int x = *bp - '0';
		    in_number++;
		    id *= 10;
		    id += x;
		} else if (*bp == '-') {
		    if (in_number) {
			break;
		    } 
		    sign = -1;
		    ++in_number;
		} else {
		    if (in_number) {
			break;
		    }
		}
	    }
	    id *= sign;
	    q = NULL;
	    for (p = data->first; p != NULL; q = p, p = p->next) {
		if (p->later_id != 0 && p->later_id == id) {
		    break;
		}
	    }
	    if (p == NULL) {
		answer = "not_found";
	    } else {
		int res = driver_monitor_process(data->port,p->pid,&(p->mon));
		if (res != 0) {
		    if (res < 0) {
			answer = "error";
		    } else {
			answer = "noproc";
		    }
		    if (q == NULL) {
			data->first = p->next;
		    } else {
			q->next = p->next;
		    }
		    driver_free(p);
		} else {
		    p->later_id = 0;
		    answer = "ok";
		}
	    }
	    break;
	}
    default:
	answer = "unknown_op";
    }
    if (answer == NULL) {
	answer = "internal_error";
    }
    alen = strlen(answer);
    if (alen >= rlen) {
	*rbuf = driver_alloc(alen+1);
    }
    strcpy(*rbuf,answer);
    return alen;
}