/*-
 *   Copyright (C) 2011 by Maxim Ignatenko
 *   gelraen.ua@gmail.com
 *
 *   All rights reserved.                                                  *
 *                                                                         *
 *   Redistribution and use in source and binary forms, with or without    *
 *    modification, are permitted provided that the following conditions   *
 *    are met:                                                             *
 *     * Redistributions of source code must retain the above copyright    *
 *       notice, this list of conditions and the following disclaimer.     *
 *     * Redistributions in binary form must reproduce the above copyright *
 *       notice, this list of conditions and the following disclaimer in   *
 *       the documentation and/or other materials provided with the        *
 *       distribution.                                                     *
 *                                                                         *
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS   *
 *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT     *
 *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR *
 *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT  *
 *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, *
 *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT      *
 *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, *
 *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY *
 *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT   *
 *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE *
 *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  *
 *
 */

//#include "acpi_call_io.h"

#include <fcntl.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <sys/param.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include "acpi.h"


struct acpi_call_descr
{
	char*		path;
	ACPI_OBJECT_LIST	args;
	ACPI_STATUS	retval;
	ACPI_BUFFER	result;
	ACPI_SIZE	reslen;
};


#define	MAX_ACPI_PATH	1024 // XXX
#define MAX_ACPI_ARGS	7

char dev_path[MAXPATHLEN] = "/dev/acpi/call";
char method_path[MAX_ACPI_PATH] = "";
size_t result_buf_size = 1024;
char output_format = 'o';

int verbose;

ACPI_OBJECT args[MAX_ACPI_ARGS];
struct acpi_call_descr params;

void parse_opts(int, char *[]);
void show_help(FILE*);
int parse_buffer(ACPI_OBJECT*, char*);
void print_params(struct acpi_call_descr*);
void print_acpi_object(ACPI_OBJECT*);
void print_acpi_buffer(ACPI_BUFFER*, char);

int main(int argc, char * argv[])
{
	int fd;

	bzero(&params, sizeof(params));
	params.path = method_path;
	params.args.Count = 0;
	params.args.Pointer = args;

	verbose = 0;

	parse_opts(argc, argv);

	params.result.Length = result_buf_size;
	params.result.Pointer = malloc(result_buf_size);

	if (params.result.Pointer == NULL)
	{
		perror("malloc");
		return 1;
	}

	if (method_path[0] == 0)
	{
		fprintf(stderr, "Please specify path to method with -p flag\n");
		return 1;
	}

	if (verbose)
		print_params(&params);

	fd = open(dev_path, O_RDWR);
	if (fd < 0)
	{
		perror("open");
		return 1;
	}
	if (ioctl(fd, 'ACCA', &params) == -1)
	{
		perror("ioctl");
		return 1;
	}

	if (verbose)
		printf("Status: %d\nResult: ", params.retval);
	print_acpi_buffer(&params.result, output_format);
	printf("\n");

	return params.retval;
}

void parse_opts(int argc, char * argv[])
{
	char c;
	int i;

	while ((c = getopt(argc, argv, "hvd:p:i:s:b:o:")) != -1)
	{
		switch(c)
		{
		case 'h':
			show_help(stdout);
			exit(0);
			break;
		case 'v':
			verbose = 1;
			break;
		case 'd':
			strlcpy(dev_path, optarg, MAXPATHLEN);
			break;
		case 'p':
			strlcpy(method_path, optarg, MAX_ACPI_PATH);
			break;
		case 'i':
		case 's':
		case 'b':
			i = params.args.Count;
			if (i >= MAX_ACPI_ARGS)
			{
				fprintf(stderr, "Maximum number of arguments exceeded\n");
				exit(1);
			}
			switch (optopt)
			{
			case 'i':
				args[i].Type = ACPI_TYPE_INTEGER;
				args[i].Integer.Value = strtol(optarg, NULL, 10);
				break;
			case 's':
				args[i].Type = ACPI_TYPE_STRING;
				args[i].String.Length = strlen(optarg);
				args[i].String.Pointer = optarg;
				break;
			case 'b':
				if (parse_buffer(&args[i], optarg))
				{
					fprintf(stderr, "Unable to parse hexstring to buffer: %s\n", optarg);
					exit(1);
				}
				break;
			}
			params.args.Count++;
			break;
		case 'o':
			output_format = optarg[0];
			switch (optarg[0])
			{
			case 'i':
			case 's':
			case 'b':
			case 'o':
				break;
			default:
				fprintf(stderr, "Incorrect output format: %c\n", optarg[0]);
				show_help(stderr);
				exit(1);
			}
			break;
		default:
			show_help(stderr);
			exit(1);
		}
	}
}

void show_help(FILE* f)
{
	fprintf(f, "Options:\n");
	fprintf(f, "  -h              - print this help\n");
	fprintf(f, "  -v              - be verbose\n");
	fprintf(f, "  -d filename     - specify path to ACPI control pseudo-device. Default: /dev/acpi/call\n");
	fprintf(f, "  -p path         - full path to ACPI method\n");
	fprintf(f, "  -i number       - add integer argument\n");
	fprintf(f, "  -s string       - add string argument\n");
	fprintf(f, "  -b hexstring    - add buffer argument\n");
	fprintf(f, "  -o i|s|b|o      - print result as integer|string|hexstring|object\n");
}

int parse_buffer(ACPI_OBJECT *dst, char *src)
{
	char tmp[3] = {0};
	size_t len = strlen(src)/2, i;

	dst->Type = ACPI_TYPE_BUFFER;
	dst->Buffer.Length = len;
	if ((dst->Buffer.Pointer = (UINT8*)malloc(len)) == NULL)
	{
		fprintf(stderr, "parse_buffer: Failed to allocate %" B_PRIuSIZE " bytes\n", len);
		exit(1);
	}

	for(i = 0; i < len; i++)
	{
		tmp[0] = src[i*2];
		tmp[1] = src[i*2+1];
		dst->Buffer.Pointer[i] = strtol(tmp, NULL, 16);
	}

	return 0;
}

void print_params(struct acpi_call_descr* p)
{
	printf("Path: %s\n", p->path);
	printf("Number of arguments: %d\n", p->args.Count);
	for(uint32 i = 0; i < p->args.Count; i++)
	{
		switch (p->args.Pointer[i].Type)
		{
		case ACPI_TYPE_INTEGER:
			printf("Argument %d type: Integer\n", i+1);
			break;
		case ACPI_TYPE_STRING:
			printf("Argument %d type: String\n", i+1);
			break;
		case ACPI_TYPE_BUFFER:
			printf("Argument %d type: Buffer\n", i+1);
			break;
		}
		printf("Argument %d value: ", i+1);
		print_acpi_object(&(p->args.Pointer[i]));
		printf("\n");
	}
}

void print_acpi_object(ACPI_OBJECT* obj)
{
	switch (obj->Type)
	{
	case ACPI_TYPE_INTEGER:
		printf("%" B_PRIu64, obj->Integer.Value);
		break;
	case ACPI_TYPE_STRING:
		printf("%s", obj->String.Pointer);
		break;
	case ACPI_TYPE_BUFFER:
		for(uint32 i = 0; i < obj->Buffer.Length; i++)
		{
			printf("%02X", obj->Buffer.Pointer[i]);
		}
		break;
	default:
		printf("Unknown object type '%d'", obj->Type);
	}
}

void print_acpi_buffer(ACPI_BUFFER* buf, char format)
{
	switch (format)
	{
	case 'i':
		printf("%" B_PRIu64, *((ACPI_INTEGER*)(buf->Pointer)));
		break;
	case 's':
		printf("%s", (char*)buf->Pointer);
		break;
	case 'b':
		for(uint32 i = 0; i < buf->Length; i++)
		{
			printf("%02X", ((UINT8*)(buf->Pointer))[i]);
		}
		break;
	case 'o':
		print_acpi_object((ACPI_OBJECT*)(buf->Pointer));
		break;
	}
}