#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include "aml/parser.h"
#include "aml/object.h"
#include "table.h"

/*
static struct acpi_table_header *read_table(FILE *fp)
{
        fseek(fp, 0, SEEK_END);
        size_t len = ftell(fp);
        fseek(fp, 0, SEEK_SET);

        struct acpi_table_header *table = malloc(len);
        if (!table) {
                return NULL;
        }

        fread(table, 1, len, fp);

        return table;
}

int main(int argc, const char **argv)
{
        if (argc < 2) {
                fprintf(stderr, "usage: %s <AML file>\n", argv[0]);
                return -1;
        }

        const char *filepath = argv[1];
        FILE *fp = fopen(filepath, "rb");
        if (!fp) {
                perror("open");
                return -1;
        }

        struct acpi_table_header *table = read_table(fp);
        fclose(fp);

        if (!table) {
                perror("read_table");
                return -1;
        }

        struct aml_object *root;

        parse_aml(table, &root);

        printf("\n\n");
        aml_object_print(root, 0);
        free(table);

        return 0;
}
*/

/*
static struct acpi_namespace *create_test_namespace(void)
{
	struct acpi_namespace *ns = acpi_namespace_create();

	struct acpi_object *root = acpi_object_create("\\", ACPI_OBJECT_NAMESPACE);
	ns->root = root;

	struct acpi_object *pr = acpi_object_create("_PR", ACPI_OBJECT_NAMESPACE);
	struct acpi_object *cpu0 = acpi_object_create("CPU0", ACPI_OBJECT_CPU);
	acpi_object_add_child(pr, cpu0);

	struct acpi_object *sb = acpi_object_create("_SB", ACPI_OBJECT_NAMESPACE);
	struct acpi_object *lid0 = acpi_object_create("LID0", ACPI_OBJECT_DEVICE);
	struct acpi_object *lid0_hid = acpi_object_create("_HID", ACPI_OBJECT_VALUE);
	struct acpi_object *lid0_sta = acpi_object_create("_STA", ACPI_OBJECT_METHOD);
	acpi_object_add_child(lid0, lid0_hid);
	acpi_object_add_child(lid0, lid0_sta);

	struct acpi_object *pci0 = acpi_object_create("PCI0", ACPI_OBJECT_DEVICE);
	struct acpi_object *pci0_hid = acpi_object_create("_HID", ACPI_OBJECT_VALUE);
	struct acpi_object *pci0_cid = acpi_object_create("_CID", ACPI_OBJECT_VALUE);
	struct acpi_object *pci0_rp03 = acpi_object_create("RP03", ACPI_OBJECT_NAMESPACE);
	struct acpi_object *pci0_rp03_pxp3 = acpi_object_create("PXP3", ACPI_OBJECT_POWER_RESOURCE);
	struct acpi_object *pci0_gfx0 = acpi_object_create("GFX0", ACPI_OBJECT_DEVICE);
	struct acpi_object *pci0_gfx0_adr = acpi_object_create("_ADR", ACPI_OBJECT_VALUE);
	struct acpi_object *pci0_gfx0_dd01 = acpi_object_create("DD01", ACPI_OBJECT_DEVICE);
	struct acpi_object *pci0_gfx0_dd01_bcl = acpi_object_create("_BCL", ACPI_OBJECT_METHOD);
	acpi_object_add_child(pci0_gfx0_dd01, pci0_gfx0_dd01_bcl);
	acpi_object_add_child(pci0_gfx0, pci0_gfx0_adr);
	acpi_object_add_child(pci0_gfx0, pci0_gfx0_dd01);
	acpi_object_add_child(pci0_rp03, pci0_rp03_pxp3);
	acpi_object_add_child(pci0, pci0_hid);
	acpi_object_add_child(pci0, pci0_cid);
	acpi_object_add_child(pci0, pci0_rp03);
	acpi_object_add_child(pci0, pci0_gfx0);

	acpi_object_add_child(sb, lid0);
	acpi_object_add_child(sb, pci0);

	struct acpi_object *tz = acpi_object_create("_TZ", ACPI_OBJECT_NAMESPACE);
	struct acpi_object *tz_fn00 = acpi_object_create("FN00", ACPI_OBJECT_POWER_RESOURCE);
	struct acpi_object *tz_fan0 = acpi_object_create("FAN0", ACPI_OBJECT_DEVICE);
	struct acpi_object *tz_fan0_hid = acpi_object_create("_HID", ACPI_OBJECT_VALUE);
	struct acpi_object *tz_tz00 = acpi_object_create("TZ00", ACPI_OBJECT_THERMAL_ZONE);
	acpi_object_add_child(tz_fan0, tz_fan0_hid);
	acpi_object_add_child(tz, tz_fn00);
	acpi_object_add_child(tz, tz_fan0);
	acpi_object_add_child(tz, tz_tz00);

	struct acpi_object *gpe = acpi_object_create("_GPE", ACPI_OBJECT_NAMESPACE);

	acpi_object_add_child(root, pr);
	acpi_object_add_child(root, sb);
	acpi_object_add_child(root, tz);
	acpi_object_add_child(root, gpe);

	return ns;
}
*/

int main(int argc, const char **argv)
{
	if (argc < 2) {
		fprintf(stderr, "usage: %s <AML file>\n", argv[0]);
		return -1;
	}

	struct acpi_table *table;
	enum loader_status loader_status = acpi_table_load(argv[1], &table);
	if (loader_status != LOADER_OK) {
		fprintf(stderr, "cannot load '%s': %s\n", argv[1], loader_status_string(loader_status));
		return -1;
	}

	void *table_payload;
	size_t payload_len;
	acpi_table_get_payload(table, &table_payload, &payload_len);

	struct acpi_namespace *ns = acpi_namespace_create();

	struct aml_parser parser;
	aml_parser_init(&parser, table_payload, payload_len);
	parser.revision = table->revision;

	enum parse_status parser_status = aml_parser_parse_into_namespace(&parser, ns);
	if (parser_status != PARSE_OK) {
		fprintf(stderr, "error occurred while parsing '%s': %s\n", argv[1], parse_status_string(parser_status));
	}

	if (ns->root) {
		acpi_object_print(ns->root, 0);
	}

	acpi_table_destroy(table);
	return parser_status == PARSE_OK ? 0 : -1;
}