#include <errno.h>
#include <expat.h>
#include <getopt.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <curl/curl.h>
#include <sys/time.h>
#include <rrd.h>
#include <signal.h>

CURL *curl;
XML_Parser parser;
char *currelem;
int parseError;
float power, current;

void usage(void);
void work(char *rrdfile);

void initcurl(char *host);
void process(void);
void exitcurl(void);

size_t parseCallback(char *contents, size_t length, size_t nmemb, void *userp);
void startElement(void *userdata, const XML_Char *name, const XML_Char **attr);
void endElement(void *userdata, const XML_Char *name);
void charHandler(void *userdata, const XML_Char *data, int len);

void initrrd(char *name);
void updaterrd(char *rrdfile, float power, float current);

char *opt_user="admin";
char *opt_pass="1234";
char *opt_port="10000";
int  opt_debug=0;

int main(int argc, char **argv) {
	int i, opt;

	while ((opt=getopt(argc, argv, "u:p:P:D"))!=-1) {
		switch(opt) {
		case 'u':
			opt_user=optarg; break;
		case 'p':
			opt_pass=optarg; break;
		case 'P':
			opt_port=optarg; break;
		case 'D':
			opt_debug++; break;
		default:
			usage();
		}
	}
	if (argc != optind+2) {
		usage();
	}
	initcurl(argv[optind]);
	// initrrd seems to destroy optind.
	char *x=argv[optind+1];
	initrrd(x);
	work(x);
}

void usage(void) {
	fprintf(stderr, "Usage: edimaxd [-u user] [-p password] [-P port] "
		"hostname rrdname\n"
		"\tuser and port are admin and 10000, and shouldn't "
		"need to be set\n"
		"\tpassword is 1234. Change if you set your edimax password.\n"
		"\thostname is the host name or ip address of your edimax\n"
		"\trrdname is the name of the rrd file to write.\n"
		);
	exit(1);
}

volatile static int killed=0;
void killme(int sig) {
	killed=sig;
}

void work(char *rrdfile) {
	struct timeval tv;
	struct timespec spec;
	
	signal(SIGINT, killme);
	signal(SIGTERM, killme);
	if (!opt_debug) {
		daemon(0, 0);
	}

	while (!killed) {
		gettimeofday(&tv, NULL);
		spec.tv_sec=0;
		spec.tv_nsec=1000000000l - tv.tv_usec*1000;
		while (nanosleep(&spec, &spec)==-1 && errno == EINTR)
			;
		process();
		updaterrd(rrdfile, power, current);
		if (opt_debug) {
			printf("power: %8.2f current: %8.2f\n", power, current);
		}
	}
	exitcurl();
}

char *getpower=
"<?xml version=\"1.0\" encoding=\"UTF8\"?>"
	"<SMARTPLUG id=\"edimax\">"
	"<CMD id=\"get\">"
	"<NOW_POWER>"
	"<Device.System.Power.NowCurrent/>"
	"<Device.System.Power.NowPower/>"
	"</NOW_POWER>"
	"</CMD>"
	"</SMARTPLUG>";

/* libcurl interface */

void initcurl(char *host) {
	char buf[200];

	curl_global_init(CURL_GLOBAL_ALL);
	if ((curl=curl_easy_init())==NULL) {
		fprintf(stderr, "error initializing curl\n");
		exit(1);
	}
	curl_easy_setopt(curl, CURLOPT_USERNAME, "admin");
	curl_easy_setopt(curl, CURLOPT_PASSWORD, "1234");
	curl_easy_setopt(curl, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
	curl_easy_setopt(curl, CURLOPT_PORT, 10000);
	snprintf(buf, sizeof buf, "http://%s/smartplug.cgi", host);

	curl_easy_setopt(curl, CURLOPT_URL, buf);
	curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, strlen(getpower));
	curl_easy_setopt(curl, CURLOPT_POSTFIELDS, getpower);

	curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, parseCallback);

}

void process() {
	CURLcode res;
	parseError=0;
	if ((parser=XML_ParserCreate(NULL))==NULL) {
		fprintf(stderr, "error initializing parser\n");
		exit(1);
	}
	XML_SetElementHandler(parser, startElement, endElement);
	XML_SetCharacterDataHandler(parser, charHandler);

	power=current=0.0;
	res=curl_easy_perform(curl);
	if (res!=CURLE_OK) {
		fprintf(stderr, "curl error: %s\n",
			curl_easy_strerror(res));
		exit(1);
	}
	else if (!parseError) {
		if (XML_Parse(parser, NULL, 0, 1)) {
			parseError=XML_GetErrorCode(parser);
		}
	}
	if (parseError) {
		fprintf(stderr, "Parse Error %s\n", XML_ErrorString(parseError));
		exit(1);
	}

	XML_ParserFree(parser);
}

void exitcurl(void) {
	curl_easy_cleanup(curl);
}


size_t parseCallback(char *contents, size_t length, size_t nmemb, void *userp) {
	int errcode;
	size_t size=length*nmemb;
	if (parseError)
		return 0;
	if (*contents=='<' && contents[1]=='?') {
		/* Edimax specifies the encoding as UTF8, which is
		 * illegal; it should be UTF-8.
		 */
		XML_Parse(parser, "<?xml version=\"1.0\" encoding=\"utf-8\"?>",
			38, 0);
		contents+=37;
		size-=37;
	}
	if (XML_Parse(parser, contents, size, 0)==0) {
		parseError=XML_GetErrorCode(parser);
	}
	return length*nmemb;;
}

/* libxml interface */

void startElement(void *userdata, const XML_Char *name, const XML_Char **attr) {
	if (currelem)
		free(currelem);
	currelem=strdup(name);
}

void endElement(void *userdata, const XML_Char *name) {
}

void charHandler(void *userdata, const XML_Char *data, int len) {
	if (!currelem)
		return;
	if (!strcmp(currelem, "Device.System.Power.NowPower")) {
		power=atof(data);
	} else if (!strcmp(currelem, "Device.System.Power.NowCurrent")) {
		current=atof(data);
	}
}

/* librrd interface */

void initrrd(char *name) {
	char *args[]={
		"create",
		"--step=1",
		name,
		"DS:Current:GAUGE:5:0:16",
		"DS:Power:GAUGE:5:0:3000",
		// 1 hour of 1-second-data
		"RRA:AVERAGE:0.5:1:3600",
		"RRA:MIN:0.5:1:3600",
		"RRA:MAX:0.5:1:3600",
		// 1 day of 5-minute-data
		"RRA:AVERAGE:0.5:300:288",
		"RRA:MIN:0.5:300:288",
		"RRA:MAX:0.5:300:288",
		// 30 days of 1-hour-data
		"RRA:AVERAGE:0.5:3600:720",
		"RRA:MIN:0.5:3600:720",
		"RRA:MAX:0.5:3600:720",
		// 5 years of 1-day-data
		"RRA:AVERAGE:0.5:86400:1825",
		"RRA:MIN:0.5:86400:1825",
		"RRA:MAX:0.5:86400:1825",
	};
	rrd_create(sizeof(args)/sizeof(*args), args);
}

void updaterrd(char *rrdfile, float power, float current) {
	char pbuf[100];
	char *args[]={
		"update",
		rrdfile,
		"--",
		pbuf
	};
	snprintf(pbuf, sizeof pbuf, "N:%f:%f", current, power);
	rrd_update(4, args);
}