#include "c_Test.h"
#include "c_InStream.h"
#include "c_BinaryInStream.h"
#include <math.h>
#include "c_BufferInputStream.h"

TEST_CASE(test_polymorphic_binary_in_stream_pipeline) {
    /*
     * Mock payload data layout block generated by a valid serialization pass:
     * - Bit 1: 1
     * - Bits 2-5: 0x0A (4 bits)
     * - Byte: 0xFE (8 bits)
     * - Char: 'C' (8 bits)
     * - UInt16: 0xABCD (16 bits)
     * - UInt32: 0x12345678 (32 bits)
     * - UInt64: 0x1122334455667788ULL
     * - Float: -2.0f (32 bits)
     * - Double: 3.1415926535
     * - String: "DAG\0" (32 bits)
     * Explicit byte sequence block array footprint:
     */
    unsigned char mock_raw_payload[] = {
        0xD7, 0xF2, 0x1D, 0x5E, 0x68, 0x91, 0xA2, 0xB3,
        0xC0, 0x89, 0x11, 0x9A, 0x22, 0xAB, 0x33, 0xBC,
        0x46, 0x00, 0x00, 0x00, 0x02, 0x00, 0x49, 0x0F,
        0xDA, 0xA2, 0x08, 0xBA, 0x22, 0x22, 0x0A, 0x38,
    };
    c_size_t payload_len = sizeof(mock_raw_payload);

    c_InStream_t* mem_input_stream = NULL;
    /* 1. Spin up the concrete memory buffer reader subclass instance */
    c_err_t err = c_BufferInputStream_Create(&mem_input_stream, mock_raw_payload, payload_len, NULL);
    ASSERT_INT_EQ(C_SUCCESS, err);

    /* 2. Bind the unpacking adapter pipeline over the polymorphic interface */
    c_BinaryInStream_t bin_in;
    err = c_BinaryInStream_Init(&bin_in, mem_input_stream);
    ASSERT_INT_EQ(C_SUCCESS, err);

    /* 3. Execute extraction queries sequentially and assert exact matches */
    int bit_val = 0;
    err = c_BinaryInStream_ReadBit(&bin_in, &bit_val);
    ASSERT_INT_EQ(C_SUCCESS, err);
    ASSERT_INT_EQ(1, bit_val);

    uint32_t bits_val = 0;
    err = c_BinaryInStream_ReadBits(&bin_in, 4, &bits_val);
    ASSERT_INT_EQ(C_SUCCESS, err);
    ASSERT_LL_EQ(0x0A, bits_val);

    int byte_val = 0;
    err = c_BinaryInStream_ReadByte(&bin_in, &byte_val);
    ASSERT_INT_EQ(C_SUCCESS, err);
    ASSERT_INT_EQ(0xFE, byte_val);

    char char_val = 0;
    err = c_BinaryInStream_ReadChar(&bin_in, &char_val);
    ASSERT_INT_EQ(C_SUCCESS, err);
    ASSERT_INT_EQ('C', char_val);

    uint16_t u16_val = 0;
    err = c_BinaryInStream_ReadUInt16(&bin_in, &u16_val);
    ASSERT_INT_EQ(C_SUCCESS, err);
    ASSERT_INT_EQ(0xABCD, u16_val);

    uint32_t u32_val = 0;
    err = c_BinaryInStream_ReadUInt32(&bin_in, &u32_val);
    ASSERT_INT_EQ(C_SUCCESS, err);
    ASSERT_LL_EQ(0x12345678, u32_val);

    uint64_t u64_val = 0;
    err =  c_BinaryInStream_ReadUInt64(&bin_in, &u64_val);
    ASSERT_INT_EQ(C_SUCCESS, err);
    ASSERT_INT_EQ(0x1122334455667788ULL, u64_val);

    float f32_val = 0.0f;
    err = c_BinaryInStream_ReadFloat(&bin_in, &f32_val);
    ASSERT_INT_EQ(C_SUCCESS, err);
    ASSERT_DOUBLE_EQ_MSG(-2.0, (double)f32_val, "Polymorphic ReadFloat alignment precision failed");

    double d64_val = 0.0;
    err = c_BinaryInStream_ReadDouble(&bin_in, &d64_val);
    ASSERT_INT_EQ(C_SUCCESS, err);
    ASSERT_DOUBLE_EQ_MSG(3.1415926535, d64_val, "Polymorphic ReadDouble alignment precision failed");

    char string_buf[8]={0};
    err = c_BinaryInStream_ReadString(&bin_in, string_buf, sizeof(string_buf));
    ASSERT_INT_EQ(C_ERR_OUTOFBOUND, err);
    ASSERT_INT_EQ(0, strcmp("DAG", string_buf));

    /* 4. Tear down infrastructure safely via the abstraction layer handle */
    c_InStream_Destroy(mem_input_stream);
}

int main(void) {
    TEST_START(Polymorphic_InStream_Pipeline_Suite);
    RUN_TEST(test_polymorphic_binary_in_stream_pipeline);
    TEST_REPORT();
    RETURN_TEST_STATUS;
}