/// <summary>
		///     Serializes this instance.
		/// </summary>
		/// <returns>The serialized structure values.</returns>
		public StructureValueCollection Serialize()
		{
			var values = new StructureValueCollection();
			values.SetInteger("range start index", (uint) StartIndex);
			values.SetInteger("range size", (uint) Size);
			return values;
		}

        private long _offset; // The offset that the reader is currently at

        #endregion Fields

        #region Constructors

        /// <summary>
        ///     (private) Constructs a new StructureReader.
        /// </summary>
        /// <param name="reader">The IReader to read from.</param>
        private StructureReader(IReader reader)
        {
            _reader = reader;
            _baseOffset = reader.Position;
            _offset = _baseOffset;
            _collection = new StructureValueCollection();
        }

		private void Load(StructureValueCollection values)
		{
			Magic = (int) values.GetInteger("magic");
			ParentMagic = (int) values.GetInteger("parent magic");
			GrandparentMagic = (int) values.GetInteger("grandparent magic");
			Description = new StringID(values.GetIntegerOrDefault("stringid", 0));
		}

		private void Load(StructureValueCollection values, IReader reader, FileSegmentGroup metaArea,
			EngineDescription buildInfo)
		{
			Name = new StringID(values.GetInteger("name stringid"));

			LoadPermutations(values, reader, metaArea, buildInfo);
		}

		/// <summary>
		///     Serializes this instance.
		/// </summary>
		/// <returns>A collection of structure values.</returns>
		public StructureValueCollection Serialize()
		{
			var result = new StructureValueCollection();
			result.SetInteger("virtual address", VirtualAddress);
			result.SetInteger("size", Size);
			return result;
		}

		private void Load(StructureValueCollection values)
		{
			Magic = (int) values.GetInteger("magic");
			ParentMagic = (int) values.GetInteger("parent magic");
			GrandparentMagic = (int) values.GetInteger("grandparent magic");
			// No description stringid :(
		}

        private long _offset; // The offset that the writer is currently at

        #endregion Fields

        #region Constructors

        private StructureWriter(StructureValueCollection values, IWriter writer)
        {
            _writer = writer;
            _baseOffset = writer.Position;
            _offset = _baseOffset;
            _collection = values;
        }

		private void Load(StructureValueCollection values, FileSegmenter segmenter)
		{
			_eofSegment = segmenter.WrapEOF((int) values.GetInteger("file size"));

			var metaOffset = (int) values.GetInteger("meta offset");
			var metaSize = (int) values.GetInteger("meta size");
			uint metaOffsetMask = values.GetInteger("meta offset mask");

			var metaSegment = new FileSegment(
				segmenter.DefineSegment(metaOffset, metaSize, 0x200, SegmentResizeOrigin.Beginning), segmenter);
			MetaArea = new FileSegmentGroup(new MetaOffsetConverter(metaSegment, metaOffsetMask));
			IndexHeaderLocation = MetaArea.AddSegment(metaSegment);

			Type = (CacheFileType) values.GetInteger("type");

			var headerGroup = new FileSegmentGroup();
			headerGroup.AddSegment(segmenter.WrapSegment(0, HeaderSize, 1, SegmentResizeOrigin.None));

			StringIDCount = (int) values.GetInteger("string table count");
			var sidDataSize = (int) values.GetInteger("string table size");
			StringIDData = segmenter.WrapSegment((int) values.GetInteger("string table offset"), sidDataSize, 1,
				SegmentResizeOrigin.End);
			StringIDIndexTable = segmenter.WrapSegment((int) values.GetInteger("string index table offset"), StringIDCount*4, 4,
				SegmentResizeOrigin.End);

			FileNameCount = (int) values.GetInteger("file table count");
			var fileDataSize = (int) values.GetInteger("file table size");
			FileNameData = segmenter.WrapSegment((int) values.GetInteger("file table offset"), fileDataSize, 1,
				SegmentResizeOrigin.End);
			FileNameIndexTable = segmenter.WrapSegment((int) values.GetInteger("file index table offset"), FileNameCount*4, 4,
				SegmentResizeOrigin.End);

			InternalName = values.GetString("internal name");
			ScenarioName = values.GetString("scenario name");

			StringArea = new FileSegmentGroup();
			StringArea.AddSegment(segmenter.WrapSegment((int) values.GetInteger("string block offset"), StringIDCount*0x80, 0x80,
				SegmentResizeOrigin.End));
			StringArea.AddSegment(StringIDIndexTable);
			StringArea.AddSegment(StringIDData);
			StringArea.AddSegment(FileNameIndexTable);
			StringArea.AddSegment(FileNameData);

			StringIDIndexTableLocation = SegmentPointer.FromOffset(StringIDIndexTable.Offset, StringArea);
			StringIDDataLocation = SegmentPointer.FromOffset(StringIDData.Offset, StringArea);
			FileNameIndexTableLocation = SegmentPointer.FromOffset(FileNameIndexTable.Offset, StringArea);
			FileNameDataLocation = SegmentPointer.FromOffset(FileNameData.Offset, StringArea);

			LocaleArea = new FileSegmentGroup();

			var rawTableOffset = (int) values.GetInteger("raw table offset");
			var rawTableSize = (int) values.GetInteger("raw table size");
			RawTable = segmenter.WrapSegment(rawTableOffset, rawTableSize, 1, SegmentResizeOrigin.End);

			Checksum = values.GetInteger("checksum");

			// Set up a bogus partition table
			Partitions = new Partition[1];
			Partitions[0] = new Partition(SegmentPointer.FromOffset(MetaArea.Offset, MetaArea), (uint) MetaArea.Size);
		}

		public SecondGenHeader(StructureValueCollection values, EngineDescription info, string buildString,
			FileSegmenter segmenter)
		{
			BuildString = buildString;
			HeaderSize = info.HeaderSize;
			Load(values, segmenter);
		}

        public static void WriteStructure(StructureValueCollection values, StructureLayout layout, IWriter writer)
        {
            var structWriter = new StructureWriter(values, writer);
            layout.Accept(structWriter);

            if (layout.Size > 0)
                structWriter.SeekWriter(layout.Size);
        }

        public FourthGenHeader(StructureValueCollection map_values, StructureValueCollection tag_values, StructureValueCollection string_values, EngineDescription info, string buildString,
			FileSegmenter segmenter)
		{
            EngineInfo = info;
			BuildString = buildString;
			HeaderSize = info.HeaderSize;
            Load(map_values, tag_values, string_values, segmenter);
		}

		private void Load(StructureValueCollection values, StringID[] stringIds)
		{
			SoundName = stringIds[values.GetInteger("sound name index")];
			ParametersIndex = (int)values.GetInteger("parameters index");
			FirstRuntimePermutationFlagIndex = (int)values.GetInteger("first runtime permutation flag index");
			EncodedPermutationCount = ((int)values.GetInteger("encoded permutation count") >> 4) & 63;
			FirstPermutationIndex = (int)values.GetInteger("first permutation index");
		}

		private void Load(StructureValueCollection values, IReader reader, FileSegmentGroup metaArea,
			EngineDescription buildInfo)
		{
			ModelResourceIndex = new DatumIndex(values.GetInteger("model resource datum index"));

			LoadSections(values, reader, metaArea, buildInfo);
			LoadBoundingBoxes(values, reader, metaArea, buildInfo);
		}

		public StructureValueCollection Serialize(IList<ITagClass> classList)
		{
			var result = new StructureValueCollection();
			result.SetInteger("memory address", (MetaLocation != null) ? MetaLocation.AsPointer() : 0);
			result.SetInteger("class index", (Class != null) ? (uint) classList.IndexOf(Class) : 0xFFFFFFFF);
			result.SetInteger("datum index salt", Index.Salt);
			return result;
		}

		public FourthGenLanguage(GameLanguage language, StructureValueCollection values, FileSegmenter segmenter,
			FileSegmentGroup localeArea, EngineDescription buildInfo)
		{
			Language = language;
			_pointerLayout = buildInfo.Layouts.GetLayout("locale index table entry");
			_encryptionKey = buildInfo.LocaleKey;
			_sizeAlign = (_encryptionKey != null) ? AES.BlockSize : 1;
			Load(values, segmenter, localeArea);
		}

		/// <summary>
		///     Reads all child objects of this reflexive.
		/// </summary>
		/// <param name="values">The values read from the parent.</param>
		/// <param name="reader">The stream to read from.</param>
		/// <param name="metaArea">The meta area of the cache file.</param>
		/// <param name="stringIDs">The string ID source for the cache file.</param>
		/// <param name="buildInfo">The build info for the cache file.</param>
		/// <returns>The objects that were read.</returns>
		public ScriptObject[] ReadObjects(StructureValueCollection values, IReader reader, FileSegmentGroup metaArea,
			StringIDSource stringIDs, EngineDescription buildInfo)
		{
			var count = (int) values.GetInteger(_countEntryName);
			uint address = values.GetInteger(_addressEntryName);
			StructureLayout layout = buildInfo.Layouts.GetLayout(_layoutName);
			StructureValueCollection[] entries = ReflexiveReader.ReadReflexive(reader, count, address, layout, metaArea);
			return entries.Select(e => ReadScriptObject(e, reader, metaArea, stringIDs, buildInfo)).ToArray();
		}

		private List<ThirdGenLanguage> LoadLanguages(StructureValueCollection values, FileSegmenter segmenter,
			EngineDescription buildInfo)
		{
			StructureValueCollection[] languageSet = values.GetArray("languages");

			IEnumerable<ThirdGenLanguage> result =
				languageSet.Select((l, i) => new ThirdGenLanguage((GameLanguage) i, l, segmenter, LocaleArea, buildInfo));
			return result.ToList();
		}

		private void LoadSoundNames(StructureValueCollection values, IReader reader, FileSegmentGroup metaArea, EngineDescription buildInfo)
		{
			var count = (int)values.GetInteger("number of sound names");
			var address = values.GetInteger("sound name table address");
			var layout = buildInfo.Layouts.GetLayout("sound names");
			var entries = ReflexiveReader.ReadReflexive(reader, count, address, layout, metaArea);

			SoundNames = entries.Select(e => new StringID(e.GetInteger("name index"))).ToArray();
		}

		private void Load(StructureValueCollection values)
		{
			ShaderIndex = (int) values.GetInteger("shader index");
			IndexBufferStart = (int) values.GetInteger("index buffer start");
			IndexBufferCount = (int) values.GetInteger("index buffer count");
			VertexGroupStart = (int) values.GetInteger("vertex group start");
			VertexGroupCount = (int) values.GetInteger("vertex group count");
			VertexBufferCount = (int) values.GetInteger("vertex buffer count");
		}

		private void Load(StructureValueCollection values, IModelSubmesh[] submeshes)
		{
			IndexBufferStart = (int) values.GetInteger("index buffer start");
			IndexBufferCount = (int) values.GetInteger("index buffer count");
			VertexBufferCount = (int) values.GetInteger("vertex buffer count");

			var submeshIndex = (int) values.GetInteger("parent submesh index");
			Submesh = submeshes[submeshIndex];
		}