/**
 * @file test_scp03_se050.c
 * @brief SE050 Hardware Platform SCP03 Connection Test
 * 
 * Tests actual SE050 hardware connection using chip-specific PlatformSCP03 keys.
 * Supports SE050C0, SE050C1, and SE050E2 via compile-time options.
 * 
 * Usage:
 *   make SE050_CHIP=SE050C0 test_se050
 *   make SE050_CHIP=SE050C1 test_se050
 *   make SE050_CHIP=SE050E2 test_se050
 * 
 * License: MIT (Clean-room implementation)
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <linux/i2c.h>
#include <linux/i2c-dev.h>

#include "se050_wireguard.h"
#include "se050_crypto_utils.h"
#include "se050_scp03_keys.h"

/* ============================================================================
 * Chip Selection and Key Mapping
 * ============================================================================ */

#ifndef SE050_CHIP
#define SE050_CHIP 0  /* Default: SE050C0 */
#endif

/* Chip type constants */
#define CHIP_SE050C0    0
#define CHIP_SE050C1    1
#define CHIP_SE050E2    2

#if SE050_CHIP == CHIP_SE050C0
    #define CHIP_NAME "SE050C0"
    #define SE050_DEFAULT_I2C_ADDR 0x90
    #define ENC_KEY SE050C0_ENC_KEY
    #define MAC_KEY SE050C0_MAC_KEY
    #define DEK_KEY SE050C0_DEK_KEY
#elif SE050_CHIP == CHIP_SE050C1
    #define CHIP_NAME "SE050C1"
    #define SE050_DEFAULT_I2C_ADDR 0x90
    #define ENC_KEY SE050C1_ENC_KEY
    #define MAC_KEY SE050C1_MAC_KEY
    #define DEK_KEY SE050C1_DEK_KEY
#elif SE050_CHIP == CHIP_SE050E2
    #define CHIP_NAME "SE050E2"
    #define SE050_DEFAULT_I2C_ADDR 0x90
    #define ENC_KEY SE050E2_ENC_KEY
    #define MAC_KEY SE050E2_MAC_KEY
    #define DEK_KEY SE050E2_DEK_KEY
#else
    #error "Invalid SE050_CHIP. Use SE050C0, SE050C1, or SE050E2"
#endif

/* ============================================================================
 * Test Result Tracking
 * ============================================================================ */

static int test_passed = 0;
static int test_failed = 0;

#define TEST_ASSERT(cond, msg) \
    do { \
        if (cond) { \
            printf("[PASS] %s\n", msg); \
            test_passed++; \
        } else { \
            printf("[FAIL] %s\n", msg); \
            test_failed++; \
        } \
    } while(0)

#define TEST_ASSERT_EQ(a, b, msg) \
    do { \
        if ((a) == (b)) { \
            printf("[PASS] %s\n", msg); \
            test_passed++; \
        } else { \
            printf("[FAIL] %s (expected %d, got %d)\n", msg, (int)(b), (int)(a)); \
            test_failed++; \
        } \
    } while(0)

/* ============================================================================
 * Real I2C HAL Implementation
 * ============================================================================ */

typedef struct {
    int fd;
    uint8_t slave_addr;
    const char *dev_path;
} real_i2c_ctx_t;

static int real_i2c_init(real_i2c_ctx_t *ctx, const char *dev_path, uint8_t addr)
{
    int fd = open(dev_path, O_RDWR);
    if (fd < 0) {
        perror("I2C open failed");
        return -1;
    }
    
    if (ioctl(fd, I2C_SLAVE, addr) < 0) {
        perror("I2C set slave address failed");
        close(fd);
        return -1;
    }
    
    ctx->fd = fd;
    ctx->slave_addr = addr;
    ctx->dev_path = dev_path;
    
    return 0;
}

static int real_i2c_read(real_i2c_ctx_t *ctx, uint8_t *buffer, int length)
{
    if (ctx->fd < 0 || !buffer || length <= 0) {
        return -1;
    }
    
    int bytes_read = read(ctx->fd, buffer, length);
    if (bytes_read < 0) {
        perror("I2C read failed");
    }
    
    return bytes_read;
}

static int real_i2c_write(real_i2c_ctx_t *ctx, const uint8_t *buffer, int length)
{
    if (ctx->fd < 0 || !buffer || length <= 0) {
        return -1;
    }
    
    int bytes_written = write(ctx->fd, buffer, length);
    if (bytes_written < 0) {
        perror("I2C write failed");
    }
    
    return bytes_written;
}

static void real_i2c_close(real_i2c_ctx_t *ctx)
{
    if (ctx->fd >= 0) {
        close(ctx->fd);
        ctx->fd = -1;
    }
}

/* ============================================================================
 * SE050 APDU Commands
 * ============================================================================ */

#define SE050_INS_OPEN_SESSION  0x70
#define SE050_INS_CLOSE_SESSION 0x71
#define SE050_INS_GET_VERSION   0x6F

/* ============================================================================
 * Test Case 1: I2C Connection Check
 */
static void test_i2c_connection(const char *i2c_bus)
{
    printf("\n=== Test 1: I2C Connection Check ===\n");
    printf("Chip: %s\n", CHIP_NAME);
    printf("I2C Bus: %s\n", i2c_bus);
    printf("I2C Address: 0x%02X\n", SE050_DEFAULT_I2C_ADDR);
    
    real_i2c_ctx_t i2c;
    
    int ret = real_i2c_init(&i2c, i2c_bus, SE050_DEFAULT_I2C_ADDR);
    if (ret == 0) {
        TEST_ASSERT(1, "I2C connection established");
        
        uint8_t buffer[4];
        int bytes_read = real_i2c_read(&i2c, buffer, 4);
        if (bytes_read > 0) {
            printf("Device response: ");
            for (int i = 0; i < bytes_read; i++) {
                printf("%02X ", buffer[i]);
            }
            printf("\n");
            TEST_ASSERT(1, "Device responded to I2C read");
        } else {
            printf("[INFO] Device may be in sleep mode\n");
            TEST_ASSERT(1, "I2C bus accessible");
        }
        
        real_i2c_close(&i2c);
    } else {
        TEST_ASSERT(0, "I2C connection failed");
        printf("[WARN] Check I2C connection and permissions\n");
    }
}

/* ============================================================================
 * Test Case 2: Session Creation with SCP03
 */
static void test_session_with_scp03(const char *i2c_bus)
{
    printf("\n=== Test 2: Session Creation with SCP03 ===\n");
    printf("Chip: %s\n", CHIP_NAME);
    
    real_i2c_ctx_t i2c;
    se050_i2c_hal_t hal;
    se050_session_ctx_t *session = NULL;
    
    int ret = real_i2c_init(&i2c, i2c_bus, SE050_DEFAULT_I2C_ADDR);
    TEST_ASSERT_EQ(ret, 0, "I2C initialization");
    
    memset(&hal, 0, sizeof(hal));
    hal.handle = &i2c;
    hal.slave_addr = SE050_DEFAULT_I2C_ADDR;
    hal.dev_path = i2c_bus;
    
    se050_status_t status = se050_session_create(&session, &hal);
    TEST_ASSERT_EQ(status, SE050_OK, "Session creation");
    
    if (session) {
        status = se050_session_scp03_init(session);
        TEST_ASSERT_EQ(status, SE050_OK, "SCP03 initialization");
        
        /* Use chip-specific keys */
        status = se050_session_scp03_set_keys(session, ENC_KEY, MAC_KEY, DEK_KEY);
        TEST_ASSERT_EQ(status, SE050_OK, "Set chip-specific PlatformSCP03 keys");
        
        se050_session_delete(session);
        TEST_ASSERT(1, "Session cleanup successful");
    }
    
    real_i2c_close(&i2c);
}

/* ============================================================================
 * Test Case 3: SCP03 Command Encryption (Real Hardware)
 */
static void test_scp03_encrypt_hardware(const char *i2c_bus)
{
    printf("\n=== Test 3: SCP03 Command Encryption (Hardware) ===\n");
    printf("Chip: %s\n", CHIP_NAME);
    
    real_i2c_ctx_t i2c;
    se050_i2c_hal_t hal;
    se050_session_ctx_t *session = NULL;
    
    int ret = real_i2c_init(&i2c, i2c_bus, SE050_DEFAULT_I2C_ADDR);
    if (ret != 0) {
        TEST_ASSERT(0, "I2C not available - skipping");
        return;
    }
    
    memset(&hal, 0, sizeof(hal));
    hal.handle = &i2c;
    hal.slave_addr = SE050_DEFAULT_I2C_ADDR;
    hal.dev_path = i2c_bus;
    
    se050_status_t status = se050_session_create(&session, &hal);
    TEST_ASSERT_EQ(status, SE050_OK, "Session creation");
    
    if (!session) {
        real_i2c_close(&i2c);
        return;
    }
    
    status = se050_session_scp03_init(session);
    TEST_ASSERT_EQ(status, SE050_OK, "SCP03 initialization");
    
    status = se050_session_scp03_set_keys(session, ENC_KEY, MAC_KEY, DEK_KEY);
    TEST_ASSERT_EQ(status, SE050_OK, "Set PlatformSCP03 keys");
    
    uint8_t cmd[64];
    size_t cmd_len = 6;
    cmd[0] = 0x80;
    cmd[1] = 0x6F;  /* GET VERSION */
    cmd[2] = 0x00;
    cmd[3] = 0x00;
    cmd[4] = 0x00;
    cmd[5] = 0x00;
    
    status = se050_session_scp03_encrypt(session, cmd, &cmd_len);
    TEST_ASSERT_EQ(status, SE050_OK, "SCP03 command encryption");
    
    if (status == SE050_OK) {
        printf("Encrypted (%zu bytes): ", cmd_len);
        for (size_t i = 0; i < cmd_len && i < 16; i++) {
            printf("%02X ", cmd[i]);
        }
        printf("...\n");
        
        int written = real_i2c_write(&i2c, cmd, (int)cmd_len);
        if (written > 0) {
            TEST_ASSERT(1, "Command sent to SE050");
            
            uint8_t response[64];
            int bytes_read = real_i2c_read(&i2c, response, sizeof(response));
            
            if (bytes_read > 0) {
                TEST_ASSERT(1, "Response received");
                
                size_t resp_len = (size_t)bytes_read;
                uint16_t sw = se050_session_scp03_decrypt(session, cmd_len, response, &resp_len);
                printf("Status: 0x%04X\n", sw);
                
                if (sw == 0x9000) {
                    TEST_ASSERT(1, "SCP03 decryption successful");
                }
            }
        }
    }
    
    se050_session_delete(session);
    real_i2c_close(&i2c);
}

/* ============================================================================
 * Test Case 4: Full PlatformSCP03 Flow
 */
static void test_platform_scp03_full_flow(const char *i2c_bus)
{
    printf("\n=== Test 4: Full PlatformSCP03 Authentication Flow ===\n");
    printf("Chip: %s\n", CHIP_NAME);
    
    real_i2c_ctx_t i2c;
    se050_i2c_hal_t hal;
    se050_session_ctx_t *session = NULL;
    
    int ret = real_i2c_init(&i2c, i2c_bus, SE050_DEFAULT_I2C_ADDR);
    if (ret != 0) {
        TEST_ASSERT(0, "I2C not available - skipping");
        return;
    }
    
    memset(&hal, 0, sizeof(hal));
    hal.handle = &i2c;
    hal.slave_addr = SE050_DEFAULT_I2C_ADDR;
    hal.dev_path = i2c_bus;
    
    se050_status_t status = se050_session_create(&session, &hal);
    TEST_ASSERT_EQ(status, SE050_OK, "Step 1: Session creation");
    
    if (!session) {
        real_i2c_close(&i2c);
        return;
    }
    
    status = se050_session_scp03_init(session);
    TEST_ASSERT_EQ(status, SE050_OK, "Step 2: SCP03 initialization");
    
    status = se050_session_scp03_set_keys(session, ENC_KEY, MAC_KEY, DEK_KEY);
    TEST_ASSERT_EQ(status, SE050_OK, "Step 3: PlatformSCP03 key provisioning");
    
    uint8_t open_cmd[16];
    size_t open_cmd_len = 4;
    open_cmd[0] = 0x80;
    open_cmd[1] = 0x70;  /* OPEN_SESSION */
    open_cmd[2] = 0x00;
    open_cmd[3] = 0x00;
    
    status = se050_session_scp03_encrypt(session, open_cmd, &open_cmd_len);
    TEST_ASSERT_EQ(status, SE050_OK, "Step 4: Encrypt OPEN_SESSION");
    
    int written = real_i2c_write(&i2c, open_cmd, (int)open_cmd_len);
    if (written > 0) {
        TEST_ASSERT(1, "Step 5: Command sent");
        
        uint8_t response[64];
        int bytes_read = real_i2c_read(&i2c, response, sizeof(response));
        
        if (bytes_read > 0) {
            TEST_ASSERT(1, "Step 6: Response received");
            
            size_t resp_len = (size_t)bytes_read;
            uint16_t sw = se050_session_scp03_decrypt(session, open_cmd_len, response, &resp_len);
            printf("Session status: 0x%04X\n", sw);
            
            if (sw == 0x9000) {
                TEST_ASSERT(1, "Step 7: PlatformSCP03 authentication successful!");
                printf("\n*** PlatformSCP03 connected with %s ***\n", CHIP_NAME);
            } else {
                TEST_ASSERT(0, "PlatformSCP03 authentication failed");
            }
        }
    }
    
    if (session) se050_session_delete(session);
    real_i2c_close(&i2c);
}

/* ============================================================================
 * Print Usage
 */
static void print_usage(const char *prog)
{
    printf("Usage: %s [options]\n", prog);
    printf("\nOptions:\n");
    printf("  -b <bus>     I2C bus device (default: /dev/i2c-1)\n");
    printf("  -h           Show this help\n");
    printf("\nCompile-time chip selection:\n");
    printf("  make SE050_CHIP=SE050C0 test_se050\n");
    printf("  make SE050_CHIP=SE050C1 test_se050\n");
    printf("  make SE050_CHIP=SE050E2 test_se050\n");
}

/* ============================================================================
 * Main Test Runner
 */
int main(int argc, char *argv[])
{
    const char *i2c_bus = "/dev/i2c-1";
    
    for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], "-b") == 0 && i + 1 < argc) {
            i2c_bus = argv[++i];
        } else if (strcmp(argv[i], "-h") == 0) {
            print_usage(argv[0]);
            return 0;
        }
    }
    
    printf("========================================\n");
    printf("SE050 Hardware Platform SCP03 Test\n");
    printf("========================================\n");
    printf("Chip Type: %s\n", CHIP_NAME);
    printf("I2C Bus: %s\n", i2c_bus);
    printf("PlatformSCP03 Keys: Chip-specific\n");
    printf("========================================\n");
    
    printf("\nKey Fingerprints:\n");
    printf("  ENC: %02X%02X%02X%02X...\n", ENC_KEY[0], ENC_KEY[1], ENC_KEY[2], ENC_KEY[3]);
    printf("  MAC: %02X%02X%02X%02X...\n", MAC_KEY[0], MAC_KEY[1], MAC_KEY[2], MAC_KEY[3]);
    printf("  DEK: %02X%02X%02X%02X...\n", DEK_KEY[0], DEK_KEY[1], DEK_KEY[2], DEK_KEY[3]);
    
    test_i2c_connection(i2c_bus);
    test_session_with_scp03(i2c_bus);
    test_scp03_encrypt_hardware(i2c_bus);
    test_platform_scp03_full_flow(i2c_bus);
    
    printf("\n========================================\n");
    printf("Test Summary\n");
    printf("========================================\n");
    printf("Passed: %d\n", test_passed);
    printf("Failed: %d\n", test_failed);
    printf("Total:  %d\n", test_passed + test_failed);
    printf("========================================\n");
    
    if (test_failed == 0) {
        printf("\n✓ All tests passed! PlatformSCP03 verified with %s\n", CHIP_NAME);
    } else {
        printf("\n✗ Some tests failed.\n");
    }
    
    return test_failed > 0 ? 1 : 0;
}