/* ====================================================================
   Licensed to the Apache Software Foundation (ASF) under one or more
   contributor license agreements.  See the NOTICE file distributed with
   this work for additional information regarding copyright ownership.
   The ASF licenses this file to You under the Apache License, Version 2.0
   (the "License"); you may not use this file except in compliance with
   the License.  You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
==================================================================== */

package org.apache.poi.hdgf.streams;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.io.IOException;
import java.io.InputStream;

import org.apache.poi.POIDataSamples;
import org.apache.poi.hdgf.chunks.Chunk;
import org.apache.poi.hdgf.chunks.ChunkFactory;
import org.apache.poi.hdgf.pointers.Pointer;
import org.apache.poi.hdgf.pointers.PointerFactory;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;
import org.apache.poi.util.IOUtils;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

public final class TestStreamComplex extends StreamTest {
	private byte[] contents;
	private final int trailerPointerAt = 0x24;
	private final int trailerDataAt = 0x8a94;
	private ChunkFactory chunkFactory;
	private PointerFactory ptrFactory;

	@BeforeEach
    void setUp() throws IOException {
		ptrFactory = new PointerFactory(11);
		chunkFactory = new ChunkFactory(11);

        InputStream is = POIDataSamples.getDiagramInstance().openResourceAsStream("Test_Visio-Some_Random_Text.vsd");
		POIFSFileSystem filesystem = new POIFSFileSystem(is);
		is.close();

		// Grab the document stream
		InputStream is2 = filesystem.createDocumentInputStream("VisioDocument");
		contents = IOUtils.toByteArray(is2);
		is2.close();

		filesystem.close();
	}

	/**
	 * Test creating the trailer, but not looking for children
	 */
	@Test
    void testTrailer() {
		// Find the trailer
		Pointer trailerPtr = ptrFactory.createPointer(contents, trailerPointerAt);

		assertEquals(20, trailerPtr.getType());
		assertEquals(trailerDataAt, trailerPtr.getOffset());

		Stream stream = Stream.createStream(trailerPtr, contents, chunkFactory, ptrFactory);
		assertTrue(stream instanceof TrailerStream);
		TrailerStream ts = (TrailerStream)stream;

		assertNotNull(ts.getChildPointers());
		assertNull(ts.getPointedToStreams());

		assertEquals(20, ts.getChildPointers().length);
		assertEquals(0x16, ts.getChildPointers()[0].getType());
		assertEquals(0x17, ts.getChildPointers()[1].getType());
		assertEquals(0x17, ts.getChildPointers()[2].getType());
		assertEquals(0xff, ts.getChildPointers()[3].getType());
	}

	@Test
    void testChunks() {
		Pointer trailerPtr = ptrFactory.createPointer(contents, trailerPointerAt);
		TrailerStream ts = (TrailerStream)
			Stream.createStream(trailerPtr, contents, chunkFactory, ptrFactory);

		// Should be 7th one
		Pointer chunkPtr = ts.getChildPointers()[5];
		assertFalse(chunkPtr.destinationHasStrings());
		assertTrue(chunkPtr.destinationHasChunks());
		assertFalse(chunkPtr.destinationHasPointers());

		Stream stream = Stream.createStream(chunkPtr, contents, chunkFactory, ptrFactory);
		assertNotNull(stream);
		assertTrue(stream instanceof ChunkStream);

		// Now find the chunks within it
		ChunkStream cs = (ChunkStream)stream;
		cs.findChunks();
	}

	@Test
    void testStrings() {
		Pointer trailerPtr = ptrFactory.createPointer(contents, trailerPointerAt);
		TrailerStream ts = (TrailerStream)
			Stream.createStream(trailerPtr, contents, chunkFactory, ptrFactory);

		// Should be the 1st one
		Pointer stringPtr = ts.getChildPointers()[0];
		assertTrue(stringPtr.destinationHasStrings());
		assertFalse(stringPtr.destinationHasChunks());
		assertFalse(stringPtr.destinationHasPointers());

		Stream stream = Stream.createStream(stringPtr, contents, chunkFactory, ptrFactory);
		assertNotNull(stream);
		assertTrue(stream instanceof StringsStream);
	}

	@Test
    void testPointerToStrings() {
		// The stream at 0x347f has strings
		// The stream at 0x4312 has a pointer to 0x347f
		// The stream at 0x44d3 has a pointer to 0x4312
		//  (it's the 2nd one of 3, and the block is compressed)

		TestPointer ptr44d3 = new TestPointer(true, 0x44d3, 0x51, 0x4e, (short)0x56);
		ptr44d3.hasPointers = true;
		PointerContainingStream s44d3 = (PointerContainingStream)
			Stream.createStream(ptr44d3, contents, chunkFactory, ptrFactory);

		// Type: 0d  Addr: 014ff644  Offset: 4312  Len: 48  Format: 54  From: 44d3
		Pointer ptr4312 = s44d3.getChildPointers()[1];
		assertEquals(0x0d, ptr4312.getType());
		assertEquals(0x4312, ptr4312.getOffset());
		assertEquals(0x48, ptr4312.getLength());
		assertEquals(0x54, ptr4312.getFormat());
		assertTrue(ptr4312.destinationHasPointers());
		assertFalse(ptr4312.destinationHasStrings());

		PointerContainingStream s4312 = (PointerContainingStream)
			Stream.createStream(ptr4312, contents, chunkFactory, ptrFactory);

		// Check it has 0x347f
		// Type: 1f  Addr: 01540004  Offset: 347f  Len: 8e8  Format: 46  From: 4312
		assertEquals(2, s4312.getChildPointers().length);
		Pointer ptr347f = s4312.getChildPointers()[0];
		assertEquals(0x1f, ptr347f.getType());
		assertEquals(0x347f, ptr347f.getOffset());
		assertEquals(0x8e8, ptr347f.getLength());
		assertEquals(0x46, ptr347f.getFormat());
		assertFalse(ptr347f.destinationHasPointers());
		assertTrue(ptr347f.destinationHasStrings());

		// Find the children of 0x4312
		assertNull(s4312.getPointedToStreams());
		s4312.findChildren(contents);
		// Should have two, both strings
		assertNotNull(s4312.getPointedToStreams());
		assertEquals(2, s4312.getPointedToStreams().length);
		assertTrue(s4312.getPointedToStreams()[0] instanceof StringsStream);
		assertTrue(s4312.getPointedToStreams()[1] instanceof StringsStream);
	}

	@Test
    void testTrailerContents() {
		Pointer trailerPtr = ptrFactory.createPointer(contents, trailerPointerAt);
		TrailerStream ts = (TrailerStream)
			Stream.createStream(trailerPtr, contents, chunkFactory, ptrFactory);

		assertNotNull(ts.getChildPointers());
		assertNull(ts.getPointedToStreams());
		assertEquals(20, ts.getChildPointers().length);

		ts.findChildren(contents);

		assertNotNull(ts.getChildPointers());
		assertNotNull(ts.getPointedToStreams());
		assertEquals(20, ts.getChildPointers().length);
		assertEquals(20, ts.getPointedToStreams().length);

		// Step down:
		// 8 -> 4 -> 5 -> 1 -> 0 == String
		assertNotNull(ts.getPointedToStreams()[8]);
		assertTrue(ts.getPointedToStreams()[8] instanceof PointerContainingStream);

		PointerContainingStream s8 =
			(PointerContainingStream)ts.getPointedToStreams()[8];
		assertNotNull(s8.getPointedToStreams());

		assertNotNull(s8.getPointedToStreams()[4]);
		assertTrue(s8.getPointedToStreams()[4] instanceof PointerContainingStream);

		PointerContainingStream s84 =
			(PointerContainingStream)s8.getPointedToStreams()[4];
		assertNotNull(s84.getPointedToStreams());

		assertNotNull(s84.getPointedToStreams()[5]);
		assertTrue(s84.getPointedToStreams()[5] instanceof PointerContainingStream);

		PointerContainingStream s845 =
			(PointerContainingStream)s84.getPointedToStreams()[5];
		assertNotNull(s845.getPointedToStreams());

		assertNotNull(s845.getPointedToStreams()[1]);
		assertTrue(s845.getPointedToStreams()[1] instanceof PointerContainingStream);

		PointerContainingStream s8451 =
			(PointerContainingStream)s845.getPointedToStreams()[1];
		assertNotNull(s8451.getPointedToStreams());

		assertNotNull(s8451.getPointedToStreams()[0]);
		assertTrue(s8451.getPointedToStreams()[0] instanceof StringsStream);
		assertTrue(s8451.getPointedToStreams()[1] instanceof StringsStream);
	}

	@Test
    void testChunkWithText() {
		// Parent ChunkStream is at 0x7194
		// This is one of the last children of the trailer
		Pointer trailerPtr = ptrFactory.createPointer(contents, trailerPointerAt);
		TrailerStream ts = (TrailerStream)
			Stream.createStream(trailerPtr, contents, chunkFactory, ptrFactory);

		ts.findChildren(contents);

		assertNotNull(ts.getChildPointers());
		assertNotNull(ts.getPointedToStreams());
		assertEquals(20, ts.getChildPointers().length);
		assertEquals(20, ts.getPointedToStreams().length);

		assertEquals(0x7194, ts.getChildPointers()[13].getOffset());
		assertEquals(0x7194, ts.getPointedToStreams()[13].getPointer().getOffset());

		PointerContainingStream ps7194 = (PointerContainingStream)
			ts.getPointedToStreams()[13];

		// First child is at 0x64b3
		assertEquals(0x64b3, ps7194.getChildPointers()[0].getOffset());
		assertEquals(0x64b3, ps7194.getPointedToStreams()[0].getPointer().getOffset());

		ChunkStream cs = (ChunkStream)ps7194.getPointedToStreams()[0];

		// Should be 26bc bytes un-compressed
		assertEquals(0x26bc, cs.getStore().getContents().length);
		// And should have lots of children
		assertEquals(131, cs.getChunks().length);

		// One of which is Text
		boolean hasText = false;
		for(int i=0; i<cs.getChunks().length; i++) {
			if(cs.getChunks()[i].getName().equals("Text")) {
				hasText = true;
			}
		}
		assertTrue(hasText);
		// Which is the 72nd command
		assertEquals("Text", cs.getChunks()[72].getName());

		Chunk text = cs.getChunks()[72];
		assertEquals("Text", text.getName());

		// Which contains our text
		assertEquals(1, text.getCommands().length);
		assertEquals("Test View\n", text.getCommands()[0].getValue());


		// Almost at the end is some more text
		assertEquals("Text", cs.getChunks()[128].getName());
		text = cs.getChunks()[128];
		assertEquals("Text", text.getName());

		assertEquals(1, text.getCommands().length);
		assertEquals("Some random text, on a page\n", text.getCommands()[0].getValue());
	}
}