//
// Created by rick on 01-03-21.
//

#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>

#include <acpi.h>

#include <myke/acpi.h>
#include <myke/tasks/task.h>
#include <myke/tasks/locking.h>
#include <myke/libk/libk.h>

ACPI_STATUS AcpiOsInitialize() {
    return AE_OK;
}

ACPI_STATUS AcpiOsTerminate() {
    return AE_OK;
}

ACPI_PHYSICAL_ADDRESS AcpiOsGetRootPointer() {
    ACPI_PHYSICAL_ADDRESS addr = 0;
    AcpiFindRootPointer(&addr);
    return addr;
}

ACPI_STATUS AcpiOsPredefinedOverride(const struct acpi_predefined_names *names, ACPI_STRING *newval) {
    *newval = NULL;
    return AE_OK;
}

ACPI_STATUS AcpiOsTableOverride(struct acpi_table_header *existingTable, struct acpi_table_header **newTable) {
    *newTable = NULL;
    return AE_OK;
}

void *AcpiOsMapMemory(ACPI_PHYSICAL_ADDRESS physicalAddress, ACPI_SIZE length) {
    return ACPI_TO_POINTER(physicalAddress);
}

void AcpiOsUnmapMemory(void *logicalAddress, ACPI_SIZE size) {
}

void *AcpiOsAllocate(ACPI_SIZE size) {
    return malloc(size);
}

void AcpiOsFree(void *mem) {
    free(mem);
}

uint8_t AcpiOsReadable(void *mem, ACPI_SIZE len) {
    return 1;
}

uint8_t AcpiOsWritable(void *mem, ACPI_SIZE len) {
    return 1;
}

ACPI_THREAD_ID AcpiOsGetThreadId() {
    return task_get_current_tid();
}

ACPI_STATUS AcpiOsExecute(ACPI_EXECUTE_TYPE type, ACPI_OSD_EXEC_CALLBACK func, void *context) {
    task_spawn(func, context);
    return AE_OK;
}

void AcpiOsSleep(uint64_t milliseconds) {
    k_panics("not supported sleep");
    // todo
}

void AcpiOsStall(uint32_t microseconds) {
    k_panics("not supported stall");
    // todo
}

ACPI_STATUS AcpiOsCreateMutex(ACPI_MUTEX*handle) {
    *handle = mutex_create();
    return AE_OK;
}

void AcpiOsDeleteMutex(ACPI_MUTEX handle) {
    mutex_free(handle);
}

ACPI_STATUS AcpiOsAcquireMutex(ACPI_MUTEX mutex, uint16_t timeout) {
    if (timeout != ACPI_WAIT_FOREVER) {
        k_panics("sem timeout not supported");
    }
    mutex_acquire(mutex);
    return AE_OK;
}

void AcpiOsReleaseMutex(ACPI_MUTEX mutex) {
    mutex_release(mutex);
}

ACPI_STATUS AcpiOsCreateSemaphore(uint32_t maxUnits, uint32_t initialUnits, ACPI_SEMAPHORE*semaphore) {
    *semaphore = semaphore_create(initialUnits);
//    k_panics("semaphores don't work");
    return AE_OK;
}

ACPI_STATUS AcpiOsDeleteSemaphore(ACPI_SEMAPHORE semaphore) {
    semaphore_free(semaphore);
    return AE_OK;
}

ACPI_STATUS AcpiOsWaitSemaphore(ACPI_SEMAPHORE semaphore, uint32_t units, uint16_t timeout) {
    if (timeout != ACPI_WAIT_FOREVER) {
        k_panics("sem timeout not supported");
    }
    for (int i = 0; i < units; ++i) {
        semaphore_wait(semaphore);
    }
    return AE_OK;
}

ACPI_STATUS AcpiOsSignalSemaphore(ACPI_SEMAPHORE semaphore, uint32_t units) {
    for (int i = 0; i < units; ++i) {
        semaphore_signal(semaphore);
    }
    return AE_OK;
}

ACPI_STATUS AcpiOsCreateLock(ACPI_SPINLOCK*spinlock) {
    *spinlock = spinlock_create();
    return AE_OK;
}

void AcpiOsDeleteLock(ACPI_SPINLOCK spinlock) {
    spinlock_free(spinlock);
}

ACPI_CPU_FLAGS AcpiOsAcquireLock(ACPI_SPINLOCK lock) {
    spinlock_acquire(lock);
    return 0;
}

void AcpiOsReleaseLock(ACPI_SPINLOCK lock, ACPI_CPU_FLAGS flags) {
    spinlock_release(lock);
}

ACPI_STATUS AcpiOsInstallInterruptHandler(uint32_t interruptLevel, ACPI_OSD_HANDLER handler, void *context) {
    k_panics("Interrupt not supported yet");
    return AE_ERROR;
}

ACPI_STATUS AcpiOsRemoveInterruptHandler(uint32_t interruptNumber, ACPI_OSD_HANDLER handler) {
    k_panics("Interrupt not supported yet (r)");
    return AE_ERROR;
}

void AcpiOsPrintf(const char *format, ...) {
    va_list args;
    va_start(args, format);
    printf(format, args);
    va_end(args);
}

void AcpiOsVprintf(const char *format, va_list args) {
    vprintf(format, args);
}

uint64_t AcpiOsGetTimer() {
    k_panics("get timer not supported");
    return 0;
}

ACPI_STATUS AcpiOsSignal(UINT32 Function, void *Info) {
    return AE_OK;
}

void AcpiOsWaitEventsComplete(void) {}

ACPI_STATUS AcpiOsPhysicalTableOverride(ACPI_TABLE_HEADER *ExistingTable, ACPI_PHYSICAL_ADDRESS *NewAddress,
                                        UINT32 *NewTableLength) {
    *NewAddress = NULL;
    *NewTableLength = 0;
    return (AE_SUPPORT);
}

ACPI_STATUS AcpiOsReadPciConfiguration(
        ACPI_PCI_ID *PciId,
        UINT32 Register,
        UINT64 *Value,
        UINT32 Width) {
    k_panics("pci read not supported");
    *Value = 0;
    return (AE_OK);
}

ACPI_STATUS AcpiOsWritePciConfiguration(
        ACPI_PCI_ID *PciId,
        UINT32 Register,
        UINT64 Value,
        UINT32 Width) {
    k_panics("pci write not supported");
    return (AE_OK);
}

ACPI_STATUS AcpiOsEnterSleep(
        UINT8 SleepState,
        UINT32 RegaValue,
        UINT32 RegbValue) {

    return (AE_OK);
}

ACPI_STATUS AcpiOsReadMemory(
        ACPI_PHYSICAL_ADDRESS Address,
        UINT64 *Value,
        UINT32 Width) {

    switch (Width) {
        case 8:
            *Value = ((uint8_t *) Address)[0];
            break;
        case 16:
            *Value = ((uint16_t *) Address)[0];
            break;
        case 32:
            *Value = ((uint32_t *) Address)[0];
            break;
        case 64:
            *Value = ((uint64_t *) Address)[0];
            break;

        default:

            return (AE_BAD_PARAMETER);
            break;
    }

    return (AE_OK);
}

ACPI_STATUS AcpiOsWriteMemory(
        ACPI_PHYSICAL_ADDRESS Address,
        UINT64 Value,
        UINT32 Width) {

    switch (Width) {
        case 8:
            *((uint8_t *) Address) = Value;
            break;
        case 16:
            *((uint16_t *) Address) = Value;
            break;
        case 32:
            *((uint32_t *) Address) = Value;
            break;
        case 64:
            *((uint64_t *) Address) = Value;
            break;

        default:

            return (AE_BAD_PARAMETER);
            break;
    }

    return (AE_OK);
}

ACPI_STATUS AcpiOsReadPort(
        ACPI_IO_ADDRESS Address,
        UINT32 *Value,
        UINT32 Width) {
    k_panics("unsupported read");
    return AE_ERROR;
}

ACPI_STATUS AcpiOsWritePort(
        ACPI_IO_ADDRESS Address,
        UINT32 Value,
        UINT32 Width) {
    k_panics("unsupported write");
    return AE_ERROR;
}

void att_noreturn acpi_init(void *data) {
    ACPI_STATUS status;
    status = AcpiInitializeSubsystem();
    if (ACPI_FAILURE(status)) {
        k_panics("Failed to init acpi");
    }

    status = AcpiInitializeTables(NULL, 16, true);
    if (ACPI_FAILURE(status)) {
        k_panics("Failed to init tables");
    }

    status = AcpiLoadTables();
    if (ACPI_FAILURE(status)) {
        k_panics("Failed to load tables");
    }

    status = AcpiEnableSubsystem(ACPI_FULL_INITIALIZATION);
    if (ACPI_FAILURE(status)) {
        k_panics("Failed to enable acpi");
    }

    printf("ACPI Initialized");
    while (true) {
        task_suspend();
    }
}

void acpi_init_task() {
    task_spawn(acpi_init, NULL);
}

void att_noreturn acpi_shutdown() {
    ACPI_STATUS status;
    status = AcpiEnterSleepStatePrep(5);
    if (ACPI_FAILURE(status)) {
        k_panics("failed to prep shutdown");
    }
    status = AcpiEnterSleepState(5);
    if (ACPI_FAILURE(status)) {
        k_panics("failed to shutdown");
    }
    k_panics("Failed");
}

void att_noreturn acpi_restart() {
    ACPI_STATUS status;
    if (!(AcpiGbl_FADT.Flags & ACPI_FADT_RESET_REGISTER)) {
        k_panics("Could not restart, not available");
    }
    status = AcpiWrite(AcpiGbl_FADT.ResetValue, &AcpiGbl_FADT.ResetRegister);
    if (ACPI_FAILURE(status)) {
        k_panics("Failed with status");
    }
    k_panics("Failed");
}