#include <stdio.h>
#include <stdlib.h>
#include "client.h"
#include "../proto/xmon-proto-1.h"

static char *field_names[]= { FIELD_NAMES };

static int xmtype[ARRAY_SIZE];
static struct xmsysinfo xminfo[ARRAY_SIZE];
static time_t xmtime[ARRAY_SIZE];
static int field=FIELD_DEFAULT;
int xid_stored_first=0, xid_stored_last=-1;

int value_type_field(int xid, int field)
{
	int type;
	int fieldflag=1<<field;

	if (xid<xid_stored_first || xid>xid_stored_last)
		return VALUE_UNDEFINED;
	type=xmtype[xid % ARRAY_SIZE];
	if (type==VALUE_KNOWN)
	{
		struct xmsysinfo *info=&xminfo[xid % ARRAY_SIZE];
		if (!(info->flags & fieldflag)) 
			return VALUE_UNDEFINED;
		if (field==FIELD_MEMFREE 
			&& (!(info->flags & XM_SYSINFO_TOTALRAM)
				|| !info->totalram))
			return VALUE_UNDEFINED;
		if (field==FIELD_SWAPFREE 
			&& (!(info->flags & XM_SYSINFO_TOTALSWAP)
				|| !info->totalswap))
			return VALUE_UNDEFINED;
	}
	return type;
}

int value_type(int xid)
{
	return value_type_field(xid, field);
}

double value_get_field(int xid, int field)
{
	struct xmsysinfo *info=&xminfo[xid % ARRAY_SIZE];
	switch(field)
	{
	case FIELD_LOAD0:
		return (double)info->loads[0]/(1<<XM_LOAD_SHIFT);
	case FIELD_LOAD1:
		return (double)info->loads[1]/(1<<XM_LOAD_SHIFT);
	case FIELD_LOAD2:
		return (double)info->loads[2]/(1<<XM_LOAD_SHIFT);
	case FIELD_PROCS:
		return (double)info->procs/50;
	case FIELD_MEMFREE:
		return (double)info->freeram/info->totalram;
	case FIELD_SWAPFREE:
		return (double)info->freeswap/info->totalswap;
	case FIELD_RTT:
		return (double)info->rtt/1000;
	default:
		return 0;
	}
}

time_t value_get_time(int xid)
{
	return xmtime[xid % ARRAY_SIZE];
}

double value_get(int xid)
{
	return value_get_field(xid, field);
}

void values_get(int xid, int field_start, int field_end, int *types, double *values, time_t *times)
{
	int i;
	for (i=field_start; i<=field_end; i++)
		*types++=value_type_field(xid, i);
	if (values)
		for (i=field_start; i<=field_end; i++)
			*values++=value_get_field(xid, i);
	if (times)
		*times++=value_get_time(xid);
}

void multivalues_get(int start, int end, int field_start, int field_end, int *types, double *values, time_t *times)
{
	int xid,i;
	int real_start=start, real_end=end;

	if (real_start<xid_stored_first)
	{
		real_start=xid_stored_first;
		if (real_start>real_end) real_start=real_end+1;
	}
	if (real_end>xid_stored_last)
	{
		real_end=xid_stored_last;
		if (real_end<real_start) real_end=real_start-1;
	}

	for (xid=start; xid<real_start; xid++)
		for (i=field_start; i<=field_end; i++)
			*types++=VALUE_UNDEFINED;
	for (xid=real_start; xid<=real_end; xid++)
		for (i=field_start; i<=field_end; i++)
			*types++=value_type_field(xid, i);
	for (xid=real_end+1; xid<=end; xid++)
		for (i=field_start; i<=field_end; i++)
			*types++=VALUE_UNDEFINED;
	if (values)
	{
		for (xid=start; xid<real_start; xid++)
			for (i=field_start; i<=field_end; i++)
				*values++=0;
		for (xid=real_start; xid<=real_end; xid++)
			for (i=field_start; i<=field_end; i++)
				*values++=value_get_field(xid, i);
		for (xid=real_end+1; xid<=end; xid++)
			for (i=field_start; i<=field_end; i++)
				*values++=0;
	}

	if (times)
	{
		for (xid=start; xid<real_start; xid++)
			*times++=0;
		for (xid=real_start; xid<=real_end; xid++)
			*times++=value_get_time(xid);
		for (xid=real_end+1; xid<=end; xid++)
			*times++=0;
	}
}

int field_number(void)
{
	return FIELD_LAST;
}

char *field_name_field(int field)
{
	return field_names[field];
}

char *field_name(void)
{
	return field_names[field];
}

void field_next(void)
{
	if (++field==FIELD_LAST) field=0;
}

void field_prev(void)
{
	if (!field--) field=FIELD_LAST-1;
}

void array_fill(int start, int finish, int type, time_t time)
{
	int index;
	if (start<finish-ARRAY_SIZE+1) start=finish-ARRAY_SIZE+1;
	index=start % ARRAY_SIZE;
	while (start++<=finish) {xmtype[index]=type; xmtime[index]=time; index++;}
	if (xid_stored_last<finish) xid_stored_last=finish;
	if (xid_stored_first<xid_stored_last-ARRAY_SIZE+1)
		xid_stored_first=xid_stored_last-ARRAY_SIZE+1;
}

void array_store(int xid, int type, struct xmsysinfo *info, time_t time)
{
	int index;
	if (xid<xid_stored_first) return;
	if (xid>xid_stored_last)
	{
		int oldlast;
		oldlast=xid_stored_last;
		xid_stored_last=xid;
		if (xid_stored_first<xid_stored_last-ARRAY_SIZE+1)
			xid_stored_first=xid_stored_last-ARRAY_SIZE+1;
		array_fill(oldlast+1, xid-1, VALUE_UNDEFINED, 0);
	}
	index=xid % ARRAY_SIZE;
	xmtype[index]=type;
	xminfo[index]=*info;
	xmtime[index]=time;
}