// hal_main.c - HAL initialisation and HalGetApi
#include "hal_api.h"
#include "hal_apic.h"
#include <string.h>
#include <stdint.h>
#include <stdarg.h>
#include "printf.h"

// Declared in other hal_*.c files:
void HalScreenInitialize(uintptr_t fb, int w, int h, int stride, HAL_SCREEN* out);
void HalKeyboardInitialize(HAL_KEYBOARD* out);
KSTATUS HalTimerInitialize(uintptr_t lapicPhys, uintptr_t hpetPhys, HAL_TIMER *out);
void HalPciInitialize(HAL_PCI* out);
void HalDiskInitialize(HAL_DISK* out);
extern void HalSetDebugEnabled(int v);

// Defined in mm_virt.c - HAL needs it for MMIO window access.
static uint64_t gPhysBase = 0xFFFF880000000000ULL;

HAL_API gApi;
static int gInitialised = 0;
extern void (*gTimerCallback)(void);

// ---------------------------------------------------------------------------
// ACPI table walker - minimal, just enough to find APIC and HPET addresses.
// ---------------------------------------------------------------------------
#define ACPI_SIG(a,b,c,d) ((uint32_t)(a)|((uint32_t)(b)<<8)|((uint32_t)(c)<<16)|((uint32_t)(d)<<24))

#pragma pack(push, 1)
#pragma warning(disable : 4200)

// ACPI RSDP (Root System Description Pointer)
typedef struct {
    char Signature[8];
    uint8_t Checksum;
    char OEMID[6];
    uint8_t Revision;
    uint32_t RsdtAddress;
    uint32_t Length;
    uint64_t XsdtAddress;
    uint8_t ExtendedChecksum;
    uint8_t Reserved[3];
} RSDP;

// ACPI SDT Header
typedef struct {
    char Signature[4];
    uint32_t Length;
    uint8_t Revision;
    uint8_t Checksum;
    char OEMID[6];
    char OEMTableID[8];
    uint32_t OEMRevision;
    uint32_t CreatorID;
    uint32_t CreatorRevision;
} ACPISDTHeader;

// RSDT (Root System Description Table)
typedef struct {
    ACPISDTHeader Header;
    uint32_t PointerToOtherSDT[];
} RSDT;

// XSDT (Extended System Description Table)
typedef struct {
    ACPISDTHeader Header;
    uint64_t PointerToOtherSDT[];
} XSDT;

// MADT (Multiple APIC Description Table)
typedef struct {
    ACPISDTHeader Header;
    uint32_t LocalAPICAddress;
    uint32_t Flags;
    uint8_t Entries[];
} MADT;

#pragma pack(pop)

static uintptr_t gLapicPhys  = 0xFEE00000;
static uintptr_t gIoapicPhys = 0xFEC00000;
static uintptr_t gHpetPhys   = 0xFED00000;

int debugEnabled = 0;
int _fltused; // fuckass
static void hal_putchar(char c) {
    gApi.Screen.PrintChar(c, 0x00FF00, 0x000000);
}
void HalDbgPrint(const char* fmt, ...) {
    if (!debugEnabled) return;

    va_list args;
    va_start(args, fmt);
    vprintf(fmt, args);
    va_end(args);
}

static void *HalPhysToVirt(uint64_t phys) {
    return (void *)(phys + gPhysBase);
}

static void ParseMadt(MADT* madt) {
    gLapicPhys = madt->LocalAPICAddress;
    uint8_t* p   = (uint8_t *)(madt + 1);
    uint8_t* end = (uint8_t *)madt + madt->Header.Length;
    while (p < end) {
        uint8_t type = p[0], len = p[1];
        if (type == 1) {  // I/O APIC entry
            gIoapicPhys = *(uint32_t *)(p + 4);
        }
        p += len ? len : 1;
    }
}

static int validate_checksum(void* table, uint32_t length) {
    uint8_t sum = 0;
    uint8_t* bytes = (uint8_t*)table;
    for (uint32_t i = 0; i < length; i++) {
        sum += bytes[i];
    }
    return sum == 0;
}

static void WalkAcpi(uintptr_t rsdpPhys) {
    if (!rsdpPhys) return;

    // Map RSDP into virtual memory
    RSDP* rsdp = (RSDP*)(rsdpPhys + gPhysBase);

    if (memcmp(rsdp->Signature, "RSD PTR ", 8) != 0) {
        HalDbgPrint("HAL: Invalid RSDP signature!\n");
        return;
    }

    ACPISDTHeader* sdtHeader = NULL;
    uint32_t count = 0;
    int isXsdt = 0;

    // Safely find and validate the XSDT (ACPI 2.0+)
    if (rsdp->Revision >= 2 && rsdp->XsdtAddress != 0) {
        XSDT* xsdt = (XSDT*)(rsdp->XsdtAddress + gPhysBase);
        
        if (validate_checksum(xsdt, xsdt->Header.Length) && 
            memcmp(xsdt->Header.Signature, "XSDT", 4) == 0) {
            
            sdtHeader = &xsdt->Header;
            count = (xsdt->Header.Length - sizeof(ACPISDTHeader)) / 8;
            isXsdt = 1;
        }
    }

    // Fallback to safely finding and validating the RSDT (ACPI 1.0)
    if (sdtHeader == NULL && rsdp->RsdtAddress != 0) {
        RSDT* rsdt = (RSDT*)((uintptr_t)rsdp->RsdtAddress + gPhysBase);
        
        if (validate_checksum(rsdt, rsdt->Header.Length) && 
            memcmp(rsdt->Header.Signature, "RSDT", 4) == 0) {
            
            sdtHeader = &rsdt->Header;
            count = (rsdt->Header.Length - sizeof(ACPISDTHeader)) / 4;
            isXsdt = 0;
        }
    }

    if (sdtHeader == NULL) {
        HalDbgPrint("HAL: No valid XSDT or RSDT found!\n");
        return;
    }

    // Walk the tables
    for (uint32_t i = 0; i < count; i++) {
        uintptr_t tablePhys = 0;
        
        if (isXsdt) {
            tablePhys = ((XSDT*)sdtHeader)->PointerToOtherSDT[i];
        } else {
            tablePhys = ((RSDT*)sdtHeader)->PointerToOtherSDT[i];
        }

        // Paranoid alignment check to reject firmware garbage pointers
        if (!tablePhys || (tablePhys & 3) != 0) continue;

        ACPISDTHeader* header = (ACPISDTHeader*)(tablePhys + gPhysBase);

        // Ensure the table isn't corrupt before parsing
        if (!validate_checksum(header, header->Length)) continue;

        // Parse MADT
        if (memcmp(header->Signature, "APIC", 4) == 0) {
            ParseMadt((MADT*)header);
        } 
        // Parse HPET
        else if (memcmp(header->Signature, "HPET", 4) == 0) {
            // HPET base address block is located at offset 44 
            // (which is 8 bytes past the 36-byte ACPISDTHeader)
            gHpetPhys = *(uint64_t*)((uint8_t*)header + 44) & ~0xFFFULL;
        }
    }
}

// ---------------------------------------------------------------------------
KSTATUS HalInitialize(const HAL_INIT_PARAMS* initParams) {
    if (gInitialised) return STATUS_ALREADY_EXISTS;
    gPhysBase = initParams->PhysicalWindowBase;
    gApi.PhysToVirt = HalPhysToVirt;
    debugEnabled = initParams->DebugEnabled;

    // Screen first so DbgPrint works immediately.
    HalScreenInitialize(initParams->FramebufferBase + initParams->PhysicalWindowBase,
                        (int)initParams->FramebufferWidth,
                        (int)initParams->FramebufferHeight,
                        (int)initParams->FramebufferStride,
                        &gApi.Screen);

    printf_set_putchar(hal_putchar);

    HalDbgPrint("HAL: screen %dx%d\n",
            initParams->FramebufferWidth, initParams->FramebufferHeight);

    // Parse ACPI to find LAPIC / IOAPIC / HPET addresses.
    if (initParams->RsdpPhysical) WalkAcpi(initParams->RsdpPhysical);
    HalDbgPrint("HAL: LAPIC=%016llx IOAPIC=%016llx HPET=%016llx\n",
            gLapicPhys, gIoapicPhys, gHpetPhys);

    HalApicInitialize(gLapicPhys, gIoapicPhys);
    HalKeyboardInitialize(&gApi.Keyboard);

    KSTATUS ts = HalTimerInitialize(gLapicPhys, gHpetPhys, &gApi.Timer);
    if (!KSUCCESS(ts)) HalDbgPrint("HAL: HPET unavailable, using fallback\n");

    HalPciInitialize(&gApi.Pci);
    HalDiskInitialize(&gApi.Disk);

    gApi.Intc.RouteIrq    = HalApicRouteIrq;
    gApi.Intc.MaskIrq     = HalApicMaskIrq;
    gApi.Intc.UnmaskIrq   = HalApicUnmaskIrq;
    gApi.Intc.SendEoi     = HalApicSendEoi;

    gApi.Version = HAL_API_VERSION;
    gInitialised = 1;

    HalDbgPrint("HAL: initialisation complete.\n");
    return STATUS_SUCCESS;
}

void HalRegisterScheduler(void (*pKeSchedulerTick)(void)) {
    gTimerCallback = pKeSchedulerTick;
}

const HAL_API* HalGetApi(void) { return &gApi; }