package jcifs.smb1.smb1;

class Trans2QueryFSInformationResponse extends SmbComTransactionResponse {

    // information levels
    static final int SMB_INFO_ALLOCATION = 1;
    static final int SMB_QUERY_FS_SIZE_INFO = 0x103;
    static final int SMB_FS_FULL_SIZE_INFORMATION = 1007;

    class SmbInfoAllocation implements AllocInfo {
        long alloc; // Also handles SmbQueryFSSizeInfo
        long free;
        int sectPerAlloc;

        when(mockFile2.lastModified()).thenReturn(System.currentTimeMillis() - 1800000);
        when(mockFile2.isDirectory()).thenReturn(true);
        when(mockFile2.getAttributes()).thenReturn(0x10); // FILE_ATTRIBUTE_DIRECTORY
        when(mockFile2.createTime()).thenReturn(System.currentTimeMillis() - 7200000);
        when(mockFile2.lastAccess()).thenReturn(System.currentTimeMillis() - 900000);

    private Smb2LeaseKey testKey;
    private int testState;

    @BeforeEach
    void setUp() {
        byte[] keyBytes = new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10 };
        testKey = new Smb2LeaseKey(keyBytes);
        testState = Smb2LeaseState.SMB2_LEASE_READ_WRITE;
        leaseContext = new LeaseV1CreateContextRequest(testKey, testState);
    }

    @Test

        buffer[4] = 0x01; // end of search = true
        buffer[5] = 0x00;
        // eaErrorOffset (2 bytes)
        buffer[6] = 0x00;
        buffer[7] = 0x00;
        // lastNameOffset (2 bytes)
        buffer[8] = 0x10;
        buffer[9] = 0x00;

        int result = response.readParametersWireFormat(buffer, 0, 10);

        // Should read 10 bytes
        assertEquals(10, result);

        // When
        String result = Hexdump.toHexString(data, offset, length);

        // Then
        assertNotNull(result);
        assertFalse(result.isEmpty());
        // Check starts with byte at offset 16 (0x10)
        assertTrue(result.startsWith("10111213"));
        assertEquals(64, result.length()); // 32 bytes * 2 chars per byte
    }

    @Test
    @DisplayName("Should handle invalid offset and length parameters")

    void testDecodeDenyACE() throws Exception {
        // Prepare test data - Deny ACE
        testBuffer = new byte[100];
        testBuffer[0] = 0x01; // Deny ACE (non-zero)
        testBuffer[1] = 0x10; // FLAGS_INHERITED
        testBuffer[2] = 0x24; // Size low byte (36)
        testBuffer[3] = 0x00; // Size high byte
        testBuffer[4] = (byte) 0xFF; // Access mask byte 0
        testBuffer[5] = 0x01; // Access mask byte 1

            SMBUtil.writeInt4(0x10, buffer, offset + 56);

            // When
            int bytesRead = response.readBytesWireFormat(buffer, offset);

            // Then
            assertEquals(60, bytesRead);
            assertEquals(8192, response.getAllocationSize());
            assertEquals(2048, response.getEndOfFile());
            assertEquals(0x10, response.getFileAttributes());
        }

        // 2 bytes for fileAttributes, 4 bytes for lastWriteTime, 4 bytes for fileSize
        byte[] buffer = new byte[20];
        // File Attributes: 0x0010 (Directory)
        buffer[0] = 0x10;
        buffer[1] = 0x00;
        // Last Write Time (UTime): A sample timestamp in milliseconds
        long sampleTimeMillis = 1672531200000L; // Represents a specific date in milliseconds

        assertEquals(0x8, SecurityInfo.SACL_SECURITY_INFO);
    }

    @Test
    @DisplayName("Test LABEL_SECURITY_INFO constant value")
    void testLabelSecurityInfo() {
        assertEquals(0x10, SecurityInfo.LABEL_SECURITY_INFO);
    }

    @Test
    @DisplayName("Test ATTRIBUTE_SECURITY_INFO constant value")
    void testAttributeSecurityInfo() {
        assertEquals(0x20, SecurityInfo.ATTRIBUTE_SECURITY_INFO);

     */
    public static final int REPLAY_DETECTION = 0x20;
    /**
     * Context flag for sequence checking capability
     */
    public static final int SEQUENCE_CHECKING = 0x10;
    /**
     * Context flag for anonymity capability
     */
    public static final int ANONYMITY = 0x08;
    /**
     * Context flag for confidentiality (encryption) capability
     */