/*
 * mock_driver.c
 * 
 * Mock Driver for RAIDGuard X GUI Server
 * Provides simulated RAID controller for testing without hardware
 */

#include "mock_driver.h"
#include <time.h>

// =============================================================================
// Global Variables
// =============================================================================

static MOCK_CTRL_INFO g_mockCtrl[MAX_DTR_IN_HOST];
static UCHAR g_mockEventQueue[100][MAX_EDB_SZ];
static int g_mockEventHead = 0;
static int g_mockEventTail = 0;
static int g_mockEventCount = 0;
static bool g_bInitialized = false;

// Configuration
static int g_controllerCount = 1;
static bool g_verbose = false;

// =============================================================================
// Initialization
// =============================================================================

void mock_set_verbose(bool verbose) {
    g_verbose = verbose;
}

bool mock_is_verbose(void) {
    return g_verbose;
}

void mock_init(void) {
    if (g_bInitialized) return;
    
    memset(g_mockCtrl, 0, sizeof(g_mockCtrl));
    memset(g_mockEventQueue, 0, sizeof(g_mockEventQueue));
    g_mockEventHead = 0;
    g_mockEventTail = 0;
    g_mockEventCount = 0;
    
    // Initialize default controller
    g_controllerCount = 1;
    g_mockCtrl[0].bStatus = CTLR_STATUS_ALIVE;
    memcpy(g_mockCtrl[0].bCtlrSN, "MOCK00000001\0", 16);
    memcpy(g_mockCtrl[0].bModelName, "Accusys GEN2\0", 20);
    
    // Fill mock page data
    mock_fill_page0(0);
    mock_fill_page1(0);
    mock_fill_page7(0);
    mock_fill_page10(0);
    mock_fill_page11(0);
    mock_fill_page14(0);
    mock_fill_page20(0);
    mock_fill_page27(0);
    
    // Register default events
    mock_register_default_events();
    
    g_bInitialized = true;
    
    if (g_verbose) {
        printf("[MOCK] Driver initialized\n");
    }
}

void mock_cleanup(void) {
    if (!g_bInitialized) return;
    
    memset(g_mockCtrl, 0, sizeof(g_mockCtrl));
    memset(g_mockEventQueue, 0, sizeof(g_mockEventQueue));
    g_mockEventCount = 0;
    g_bInitialized = false;
    
    if (g_verbose) {
        printf("[MOCK] Driver cleanup complete\n");
    }
}

// =============================================================================
// Page Data Fillers
// =============================================================================

void mock_fill_page0(int ctrlIndex) {
    MOCK_CTRL_INFO *ctrl = &g_mockCtrl[ctrlIndex];
    unsigned char *buf = ctrl->bPage0Data;
    
    memset(buf, 0, 1024);
    
    // Serial Number (Offset 0-15, 16 bytes)
    memcpy(buf + 0, ctrl->bCtlrSN, 16);
    
    // Model Name (Offset 16-47, 32 bytes)
    memcpy(buf + 16, ctrl->bModelName, 20);
    
    // Firmware Version (Offset 64-71, 8 bytes)
    memcpy(buf + 64, "3.8.0.0\0", 8);
    
    // BIOS Version (Offset 72-79, 8 bytes)
    memcpy(buf + 72, "1.2.3.4\0", 8);
    
    // Status (Offset 96)
    buf[96] = 0x01;  // Online
    
    // Number of RAID Ports (Offset 104)
    buf[104] = 4;
    
    // Number of Disks (Offset 105)
    buf[105] = 8;
    
    // Controller Number (Offset 106)
    buf[106] = ctrlIndex;
    
    if (g_verbose) {
        printf("[MOCK] Page 0 filled for controller %d\n", ctrlIndex);
    }
}

void mock_fill_page1(int ctrlIndex) {
    unsigned char *buf = g_mockCtrl[ctrlIndex].bPage1Data;
    memset(buf, 0, 1024);
    
    // RAID 0: Normal
    buf[0] = 0x01;  // Status: Normal
    buf[1] = 0x05;  // RAID Level: RAID 5
    buf[2] = 0x04;  // Disk Count
    
    // RAID 1: Normal
    buf[128] = 0x01;
    buf[129] = 0x06;  // RAID 6
    buf[130] = 0x06;  // 6 disks
    
    if (g_verbose) {
        printf("[MOCK] Page 1 filled for controller %d\n", ctrlIndex);
    }
}

void mock_fill_page7(int ctrlIndex) {
    unsigned char *buf = g_mockCtrl[ctrlIndex].bPage7Data;
    memset(buf, 0, 512);
    
    // LUN 0 mapping
    buf[0] = 0x00;  // LUN 0
    buf[1] = 0x00;  // RAID ID 0
    buf[2] = 0x01;  // Enable
    
    if (g_verbose) {
        printf("[MOCK] Page 7 filled for controller %d\n", ctrlIndex);
    }
}

void mock_fill_page10(int ctrlIndex) {
    unsigned char *buf = g_mockCtrl[ctrlIndex].bPage10Data;
    memset(buf, 0, 1024);
    
    // RAID Info Block 0
    buf[0] = 0x01;  // Status: Normal
    buf[1] = 0x05;  // RAID 5
    buf[2] = 0x04;  // 4 disks
    buf[3] = 0x00;  // Stripe Size
    
    // Capacity (Offset 8-15, 8 bytes)
    buf[8] = 0x00;
    buf[9] = 0x00;
    buf[10] = 0x00;
    buf[11] = 0x10;  // 1 TB
    buf[12] = 0x00;
    buf[13] = 0x00;
    buf[14] = 0x00;
    buf[15] = 0x00;
    
    if (g_verbose) {
        printf("[MOCK] Page 10 filled for controller %d\n", ctrlIndex);
    }
}

void mock_fill_page11(int ctrlIndex) {
    memset(g_mockCtrl[ctrlIndex].bPage11Data, 0, 1024);
    g_mockCtrl[ctrlIndex].bPage11Data[0] = 0x01;
}

void mock_fill_page14(int ctrlIndex) {
    unsigned char *buf = g_mockCtrl[ctrlIndex].bPage14Data;
    memset(buf, 0, 1024);
    
    // Event Log Structure (16 events, 64 bytes each)
    // Each event: 32 bytes data + 32 bytes message
    // Offset 0-15: Event Type (4 bytes), Timestamp (4 bytes), Slot/EID (4 bytes), Status (4 bytes)
    // Offset 16-31: Reserved
    // Offset 32-63: Event Message (32 bytes)
    
    time_t now = time(NULL);
    
    // Event 0: Controller started
    buf[0] = 0x01;  // Event Type: System
    buf[1] = 0x00;
    buf[2] = 0x00;
    buf[3] = 0x00;
    *(unsigned int*)(buf + 4) = (unsigned int)(now - 3600);  // 1 hour ago
    *(unsigned int*)(buf + 8) = 0xFFFFFFFF;  // Controller
    buf[12] = 0x01;  // Status: Info
    memcpy(buf + 32, "Controller started successfully    ", 32);
    
    // Event 1: Disk online
    buf[64] = 0x02;  // Event Type: Disk
    buf[65] = 0x00;
    buf[66] = 0x00;
    buf[67] = 0x00;
    *(unsigned int*)(buf + 68) = (unsigned int)(now - 1800);  // 30 min ago
    *(unsigned int*)(buf + 72) = 0x02;  // Slot 2
    buf[76] = 0x01;  // Status: Info
    memcpy(buf + 96, "Disk online                         ", 32);
    
    // Event 2: RAID normal
    buf[128] = 0x03;  // Event Type: RAID
    buf[129] = 0x00;
    buf[130] = 0x00;
    buf[131] = 0x00;
    *(unsigned int*)(buf + 132) = (unsigned int)(now - 900);  // 15 min ago
    *(unsigned int*)(buf + 136) = 0x00;  // RAID ID 0
    buf[140] = 0x01;  // Status: Info
    memcpy(buf + 160, "RAID-01 status: Normal             ", 32);
    
    // Event 3: Temperature warning
    buf[192] = 0x02;  // Event Type: Disk
    buf[193] = 0x00;
    buf[194] = 0x00;
    buf[195] = 0x00;
    *(unsigned int*)(buf + 196) = (unsigned int)(now - 600);  // 10 min ago
    *(unsigned int*)(buf + 200) = 0x03;  // Slot 3
    buf[204] = 0x02;  // Status: Warning
    memcpy(buf + 224, "Disk temperature warning: 45C      ", 32);
    
    // Event 4: Power supply normal
    buf[256] = 0x05;  // Event Type: Power
    buf[257] = 0x00;
    buf[258] = 0x00;
    buf[259] = 0x00;
    *(unsigned int*)(buf + 260) = (unsigned int)(now - 300);  // 5 min ago
    *(unsigned int*)(buf + 264) = 0x00;  // PS 0
    buf[268] = 0x01;  // Status: Info
    memcpy(buf + 288, "Power supply 1 online              ", 32);
    
    // Event 5: Fan normal
    buf[320] = 0x04;  // Event Type: Enclosure
    buf[321] = 0x00;
    buf[322] = 0x00;
    buf[323] = 0x00;
    *(unsigned int*)(buf + 324) = (unsigned int)(now - 120);  // 2 min ago
    *(unsigned int*)(buf + 328) = 0x00;  // Fan 0
    buf[332] = 0x01;  // Status: Info
    memcpy(buf + 352, "Fan speed normal: 5200 RPM        ", 32);
    
    // Event 6: Network up
    buf[384] = 0x06;  // Event Type: Network
    buf[385] = 0x00;
    buf[386] = 0x00;
    buf[387] = 0x00;
    *(unsigned int*)(buf + 388) = (unsigned int)(now - 60);  // 1 min ago
    *(unsigned int*)(buf + 392) = 0x00;  // Port 0
    buf[396] = 0x01;  // Status: Info
    memcpy(buf + 416, "Network port link up               ", 32);
    
    // Event 7: Battery OK
    buf[448] = 0x01;  // Event Type: System
    buf[449] = 0x00;
    buf[450] = 0x00;
    buf[451] = 0x00;
    *(unsigned int*)(buf + 452) = (unsigned int)now;  // Now
    *(unsigned int*)(buf + 456) = 0xFFFFFFFF;  // Controller
    buf[460] = 0x01;  // Status: Info
    memcpy(buf + 480, "Battery backup unit initialized    ", 32);
    
    // Event count at offset 960 (0x3C0)
    buf[960] = 8;  // 8 events stored
    
    if (g_verbose) {
        printf("[MOCK] Page 14 filled for controller %d (8 events)\n", ctrlIndex);
    }
}

void mock_fill_page20(int ctrlIndex) {
    unsigned char *buf = g_mockCtrl[ctrlIndex].bPage20Data;
    memset(buf, 0, 512);
    
    buf[0] = 2;   // Fan Count
    buf[1] = 2;   // Power Supply Count
    buf[2] = 4;   // Temperature Sensor Count
    buf[3] = 1;   // Heat Sink Count
    buf[4] = 1;   // Power Supply Fan Count
    
    buf[0x10] = 0x50;
    buf[0x11] = 0x14;
    buf[0x12] = 0x40;
    buf[0x13] = 0x13;
    
    buf[0x18] = 0xA0;
    buf[0x19] = 0x0F;
    
    buf[0x20] = 35;
    buf[0x21] = 32;
    buf[0x22] = 38;
    buf[0x23] = 30;
    
    buf[0x40] = 0x00;
    buf[0x41] = 0x00;
    buf[0x42] = 0x01;
    buf[0x43] = 0x00;
    
    buf[0x50] = 0x00;
    buf[0x51] = 0x00;
    
    buf[0x60] = 0x01;
    buf[0x61] = 0x64;
    buf[0x62] = 0x00;
    
    buf[0x00] = 0x00;
    
    if (g_verbose) {
        printf("[MOCK] Page 20 filled for controller %d (Enclosure Info)\n", ctrlIndex);
    }
}

void mock_fill_page27(int ctrlIndex) {
    unsigned char *buf = g_mockCtrl[ctrlIndex].bPage27Data;
    memset(buf, 0, 512);
    
    // Disk 0
    buf[0] = 0x00;   // Slot 0
    buf[1] = 0x01;   // Status: Online
    buf[2] = 0x00;   // Type: HDD
    
    // Disk 1
    buf[16] = 0x01;   // Slot 1
    buf[17] = 0x01;   // Status: Online
    
    // Disk 2
    buf[32] = 0x02;
    buf[33] = 0x01;
    
    // Disk 3
    buf[48] = 0x03;
    buf[49] = 0x01;
    
    // Disk 4 (Spare)
    buf[64] = 0x04;
    buf[65] = 0x01;
    buf[66] = 0x02;  // Spare
    
    // Disk 5-7 Offline
    buf[80] = 0x05;
    buf[81] = 0x00;  // Offline
    
    if (g_verbose) {
        printf("[MOCK] Page 27 filled for controller %d\n", ctrlIndex);
    }
}

void mock_register_default_events(void) {
    // Disk Online Event (Slot 2)
    UCHAR diskOnline[] = {
        0x01, 0x00, 0x00, 0x00,  // Event Type: Disk Online
        0x00, 0x00, 0x00, 0x00,  // Timestamp
        0x02, 0x00, 0x00, 0x00,  // Slot 2
        0x01, 0x00, 0x00, 0x00   // Status: OK
    };
    mock_push_event(diskOnline, 16);
}

// =============================================================================
// Driver Functions
// =============================================================================

UCHAR mock_DevIoControl(
    UCHAR bDevNo,
    ULONG lControlCode,
    ULONG lInSize,
    char *pInBuf,
    ULONG lOutSize,
    char *pOutBuf,
    USHORT *pusInBandErrCode) {
    
    if (!g_bInitialized) mock_init();
    
    if (bDevNo >= MAX_DTR_IN_HOST) {
        *pusInBandErrCode = 0xFF;
        return 0x01;
    }
    
    // Handle different IOCTL codes
    switch (lControlCode) {
        case 0x9001:  // GET_CONTROLLER_INFO
            if (g_verbose) {
                printf("[MOCK] IOCTL: GET_CONTROLLER_INFO ctrl=%d\n", bDevNo);
            }
            memcpy(pOutBuf, g_mockCtrl[bDevNo].bPage0Data, 
                   lOutSize > 1024 ? 1024 : lOutSize);
            break;
            
        case 0x9002:  // GET_RAID_INFO
            if (g_verbose) {
                printf("[MOCK] IOCTL: GET_RAID_INFO ctrl=%d\n", bDevNo);
            }
            memcpy(pOutBuf, g_mockCtrl[bDevNo].bPage1Data,
                   lOutSize > 1024 ? 1024 : lOutSize);
            break;
            
        case 0x9020:  // GET_INBAND_EVENT
            if (g_verbose) {
                printf("[MOCK] IOCTL: GET_INBAND_EVENT ctrl=%d\n", bDevNo);
            }
            {
                EVENT_INFO evt;
                UCHAR result = mock_GetCtlrEvent(bDevNo, &evt);
                if (result == SYSOK) {
                    memcpy(pOutBuf, evt.bEventBuf, 
                           lOutSize > 512 ? 512 : lOutSize);
                }
            }
            break;
            
        default:
            if (g_verbose) {
                printf("[MOCK] IOCTL: 0x%04lx (not handled, returning success)\n", 
                       lControlCode);
            }
            // Return success for unknown codes
            break;
    }
    
    *pusInBandErrCode = 0x0000;
    return SYSOK;
}

CHAR mock_QuaryDTR(UCHAR ucCtlrIndex, UCHAR *bPageBuf, UCHAR *pbHeatsink) {
    if (!g_bInitialized) mock_init();
    
    if (ucCtlrIndex >= g_controllerCount) {
        return 0;  // FALSE
    }
    
    // Return controller info
    memcpy(bPageBuf, g_mockCtrl[ucCtlrIndex].bPage0Data, 1024);
    *pbHeatsink = 0x00;
    
    if (g_verbose) {
        printf("[MOCK] QuaryDTR: controller %d, SN: %s\n", 
               ucCtlrIndex, g_mockCtrl[ucCtlrIndex].bCtlrSN);
    }
    
    return 1;  // TRUE
}

UCHAR mock_GetCtlrEvent(UCHAR bCtlrNo, EVENT_INFO *pEvent_info) {
    if (!g_bInitialized) mock_init();
    
    if (g_mockEventCount <= 0) {
        pEvent_info->bStatus = 0;
        return 0x02;  // SYSFAIL_EVENT_EMPTY
    }
    
    // Get event from queue
    memcpy(pEvent_info->bEventBuf, g_mockEventQueue[g_mockEventHead], MAX_EDB_SZ);
    pEvent_info->bStatus = 1;
    
    // Move head
    g_mockEventHead = (g_mockEventHead + 1) % 100;
    g_mockEventCount--;
    
    if (g_verbose) {
        printf("[MOCK] GetCtlrEvent: event retrieved, remaining: %d\n", 
               g_mockEventCount);
    }
    
    return SYSOK;
}

// =============================================================================
// Configuration Functions
// =============================================================================

void mock_set_controller_count(int count) {
    if (count < 1) count = 1;
    if (count > MAX_DTR_IN_HOST) count = MAX_DTR_IN_HOST;
    g_controllerCount = count;
}

void mock_set_controller_serial(int index, const char *sn) {
    if (index < 0 || index >= MAX_DTR_IN_HOST) return;
    memcpy(g_mockCtrl[index].bCtlrSN, sn, 16);
}

void mock_set_controller_model(int index, const char *model) {
    if (index < 0 || index >= MAX_DTR_IN_HOST) return;
    memcpy(g_mockCtrl[index].bModelName, model, 32);
}

void mock_set_controller_status(int index, UCHAR status) {
    if (index < 0 || index >= MAX_DTR_IN_HOST) return;
    g_mockCtrl[index].bStatus = status;
}

// =============================================================================
// Event Simulation
// =============================================================================

void mock_push_event(UCHAR *eventData, int length) {
    if (length > MAX_EDB_SZ) length = MAX_EDB_SZ;
    if (g_mockEventCount >= 100) {
        // Queue full, remove oldest
        g_mockEventHead = (g_mockEventHead + 1) % 100;
        g_mockEventCount--;
    }
    
    memcpy(g_mockEventQueue[g_mockEventTail], eventData, length);
    g_mockEventTail = (g_mockEventTail + 1) % 100;
    g_mockEventCount++;
    
    if (g_verbose) {
        printf("[MOCK] Event pushed, count: %d\n", g_mockEventCount);
    }
}

void mock_clear_events(void) {
    g_mockEventHead = 0;
    g_mockEventTail = 0;
    g_mockEventCount = 0;
    
    if (g_verbose) {
        printf("[MOCK] Events cleared\n");
    }
}

void mock_generate_disk_event(int slot, int eventType) {
    UCHAR event[16];
    memset(event, 0, 16);
    
    event[0] = eventType & 0xFF;  // Event Type
    event[3] = slot & 0xFF;       // Slot Number
    
    mock_push_event(event, 16);
}

void mock_generate_raid_event(int raidId, int eventType) {
    UCHAR event[16];
    memset(event, 0, 16);
    
    event[0] = eventType & 0xFF;  // Event Type
    event[3] = raidId & 0xFF;     // RAID ID
    
    mock_push_event(event, 16);
}

// =============================================================================
// Configuration File (Stub)
// =============================================================================

int mock_load_config(const char *filename) {
    // TODO: Parse JSON config file
    if (g_verbose) {
        printf("[MOCK] Config file loading not implemented: %s\n", filename);
    }
    return 0;
}

void mock_print_config(void) {
    printf("=== Mock Configuration ===\n");
    printf("Controller Count: %d\n", g_controllerCount);
    for (int i = 0; i < g_controllerCount; i++) {
        printf("Controller %d:\n", i);
        printf("  SN: %s\n", g_mockCtrl[i].bCtlrSN);
        printf("  Model: %s\n", g_mockCtrl[i].bModelName);
        printf("  Status: %s\n", 
               g_mockCtrl[i].bStatus == CTLR_STATUS_ALIVE ? "Online" : "Offline");
    }
    printf("Pending Events: %d\n", g_mockEventCount);
    printf("=========================\n");
}

// =============================================================================
// Accessors for testing
// =============================================================================

MOCK_CTRL_INFO* mock_get_ctrl_info(int index) {
    if (index < 0 || index >= MAX_DTR_IN_HOST) return NULL;
    return &g_mockCtrl[index];
}

int mock_get_event_queue_count(void) {
    return g_mockEventCount;
}