#pragma once
#include "MASTER.h"
#include "GLOBAL.h"
#include "SzlFileLoader.h"
#include "fileStuff.h"
#include "importSzPltFile.h"
#include "RawArray.h"
#include "readValueArray.h"
namespace tecplot
{
	namespace ___3933
	{
		class MinMaxTree
		{
			UNCOPYABLE_CLASS(MinMaxTree);

		public:
			typedef uint32_t EntryIndex_t;

		private:
			static EntryIndex_t const CHILDREN_BITS_PER_PARENT = 6;
			static EntryIndex_t const NUM_CHILDREN_PER_PARENT = (1 << CHILDREN_BITS_PER_PARENT);
			static EntryIndex_t const MAX_DEPTH = (24 + CHILDREN_BITS_PER_PARENT - 1) / CHILDREN_BITS_PER_PARENT;
			static size_t const MIN_ENTRIES_TO_ALLOCATE = 32;
			static size_t const ALLOCATION_EXPANSION_FACTOR = 2;
			___2240<___2481> m_minMaxArraysByDepth;
#ifndef NO_ASSERTS
			EntryIndex_t m_size;
#endif
		public:
			MinMaxTree()
			{
#ifndef NO_ASSERTS
				m_size = 0;
#endif
			}
			~MinMaxTree() {}
			inline void swap(MinMaxTree &___2888)
			{
				ASSERT_ONLY(___372 const thisWasEmpty = this->empty();)
				ASSERT_ONLY(___372 const thisWasValidlyPopulated = this->isValidlyPopulated(EntryIndex_t(this->size()));) ASSERT_ONLY(___372 const otherWasEmpty = ___2888.empty();) ASSERT_ONLY(___372 const otherWasValidlyPopulated = ___2888.isValidlyPopulated(EntryIndex_t(___2888.size()));) m_minMaxArraysByDepth.swap(___2888.m_minMaxArraysByDepth);
#ifndef NO_ASSERTS
				using std::swap;
				swap(m_size, ___2888.m_size);
#endif
				ENSURE(EQUIVALENCE(thisWasEmpty, ___2888.empty()));
				ENSURE(EQUIVALENCE(thisWasValidlyPopulated, ___2888.isValidlyPopulated(EntryIndex_t(___2888.size()))));
				ENSURE(EQUIVALENCE(otherWasEmpty, this->empty()));
				ENSURE(EQUIVALENCE(otherWasValidlyPopulated, this->isValidlyPopulated(EntryIndex_t(this->size()))));
			}
			static EntryIndex_t getNumEntriesAtDepth(EntryIndex_t ___2795, EntryIndex_t depth)
			{
				REQUIRE(___2795 > 0);
				REQUIRE(depth <= MAX_DEPTH);
				EntryIndex_t const shift = depth * CHILDREN_BITS_PER_PARENT;
				EntryIndex_t const ___3358 = ((___2795 - 1) >> shift) + 1;
				return ___3358;
			}
			___372 empty() const
			{
				___372 const isEmpty = m_minMaxArraysByDepth.empty();
				ENSURE(VALID_BOOLEAN(isEmpty));
				ENSURE(EQUIVALENCE(isEmpty, m_size == 0));
				return isEmpty;
			}
			___372 isPopulated() const { return !empty() && m_minMaxArraysByDepth[MAX_DEPTH - 1][0].___2067(); }
#ifndef NO_ASSERTS
			size_t size() const
			{
				REQUIRE(EQUIVALENCE(m_size == 0, m_minMaxArraysByDepth.empty()));
				REQUIRE(IMPLICATION(m_size > 0, m_size == m_minMaxArraysByDepth[0].size()));
				return m_size;
			}
			___372 isValidlyPopulated(EntryIndex_t ___2795) const
			{
				REQUIRE(___2795 == m_size);
				return m_minMaxArraysByDepth.size() == MAX_DEPTH && m_minMaxArraysByDepth[0].size() == ___2795 && m_minMaxArraysByDepth[0][0].___2067() && m_minMaxArraysByDepth[0][___2795 / 2].___2067() && m_minMaxArraysByDepth[0][___2795 - 1].___2067() && m_minMaxArraysByDepth[MAX_DEPTH / 2].size() == getNumEntriesAtDepth(___2795, MAX_DEPTH / 2) && m_minMaxArraysByDepth[MAX_DEPTH / 2][0].___2067() && m_minMaxArraysByDepth[MAX_DEPTH / 2][getNumEntriesAtDepth(___2795, MAX_DEPTH / 2) / 2].___2067() && m_minMaxArraysByDepth[MAX_DEPTH / 2][getNumEntriesAtDepth(___2795, MAX_DEPTH / 2) - 1].___2067() && m_minMaxArraysByDepth[MAX_DEPTH - 1].size() == getNumEntriesAtDepth(___2795, MAX_DEPTH - 1) && m_minMaxArraysByDepth[MAX_DEPTH - 1][0].___2067() && m_minMaxArraysByDepth[MAX_DEPTH - 1][getNumEntriesAtDepth(___2795, MAX_DEPTH - 1) / 2].___2067() && m_minMaxArraysByDepth[MAX_DEPTH - 1][getNumEntriesAtDepth(___2795, MAX_DEPTH - 1) - 1].___2067();
			}
#endif
		public:
			uint64_t numBytesAllocated(uint64_t ___2795) const
			{
				REQUIRE(___2795 == m_size);
				uint64_t ___2779 = m_minMaxArraysByDepth.numBytesAllocated(MAX_DEPTH);
				if (!m_minMaxArraysByDepth.empty())
				{
					for (EntryIndex_t depth = 0; depth < MAX_DEPTH; depth++)
					{
						EntryIndex_t const numEntriesAtDepth = getNumEntriesAtDepth(EntryIndex_t(___2795), depth);
						___2779 += m_minMaxArraysByDepth[depth].numBytesAllocated(numEntriesAtDepth);
					}
				}
				return ___2779;
			}
			___372 allocUninitialized(EntryIndex_t ___2795)
			{
				REQUIRE(___2795 > 0);
#ifndef NO_ASSERTS
				m_size = ___2795;
#endif
				___372 ___2039 = m_minMaxArraysByDepth.alloc(MAX_DEPTH);
				for (EntryIndex_t depth = 0; ___2039 && depth < MAX_DEPTH; ++depth)
				{
					EntryIndex_t const numEntiresAtDepth = getNumEntriesAtDepth(___2795, depth);
					___2039 = m_minMaxArraysByDepth[depth].alloc(numEntiresAtDepth);
				}
				if (!___2039)
					___937();
				ENSURE(VALID_BOOLEAN(___2039));
				ENSURE(EQUIVALENCE(___2039, !m_minMaxArraysByDepth.empty()));
				ENSURE(IMPLICATION(___2039, !m_minMaxArraysByDepth[0].empty()));
				return ___2039;
			}
			void initializeWithInvalidMinMaxes(EntryIndex_t ___2795)
			{
				REQUIRE(___2795 > 0 && ___2795 == m_size);
				REQUIRE(m_minMaxArraysByDepth.size() == MAX_DEPTH);
				___478(___2795 == getNumEntriesAtDepth(___2795, 0));
				for (EntryIndex_t depth = 0; depth < MAX_DEPTH; ++depth)
				{
					EntryIndex_t const numEntiresAtDepth = getNumEntriesAtDepth(___2795, depth);
					___2481 &___2480 = m_minMaxArraysByDepth[depth];
					for (EntryIndex_t entry = 0; entry < numEntiresAtDepth; entry++)
						___2480[entry].invalidate();
				}
				ENSURE(!m_minMaxArraysByDepth[0][0].___2067() && !m_minMaxArraysByDepth[0][___2795 / 2].___2067() && !m_minMaxArraysByDepth[0][___2795 - 1].___2067() && !m_minMaxArraysByDepth[MAX_DEPTH - 1][0].___2067());
				ENSURE(!isPopulated());
			}
			void ___937()
			{
				m_minMaxArraysByDepth.___937();
#ifndef NO_ASSERTS
				m_size = 0;
#endif
			}
			void getChildRangeUsingNumEntries(EntryIndex_t parentPos, EntryIndex_t numEntriesAtChildDepth, EntryIndex_t &childStart, EntryIndex_t &childEnd) const
			{
				REQUIRE(numEntriesAtChildDepth > 0);
				REQUIRE(parentPos < numEntriesAtChildDepth * NUM_CHILDREN_PER_PARENT);
				childStart = parentPos << CHILDREN_BITS_PER_PARENT;
				___478(childStart == parentPos * NUM_CHILDREN_PER_PARENT);
				childEnd = std::min(childStart + NUM_CHILDREN_PER_PARENT, numEntriesAtChildDepth);
				ENSURE(childStart < childEnd);
				ENSURE(childEnd <= numEntriesAtChildDepth);
			}
			void getChildRange(EntryIndex_t ___2795, EntryIndex_t parentDepth, EntryIndex_t parentPos, EntryIndex_t &childStart, EntryIndex_t &childEnd) const
			{
				REQUIRE(___2795 == m_size);
				REQUIRE(isValidlyPopulated(___2795));
				REQUIRE(parentDepth > 0);
				REQUIRE(parentDepth <= MAX_DEPTH);
				REQUIRE(parentPos < getNumEntriesAtDepth(___2795, parentDepth));
				EntryIndex_t const childDepth = parentDepth - 1;
				EntryIndex_t const numEntriesAtChildDepth = getNumEntriesAtDepth(___2795, childDepth);
				getChildRangeUsingNumEntries(parentPos, numEntriesAtChildDepth, childStart, childEnd);
				ENSURE(childStart < childEnd);
				ENSURE(childEnd <= getNumEntriesAtDepth(___2795, childDepth));
			}
			___2479 const &getMinMaxAtDepth(EntryIndex_t depth, EntryIndex_t pos) const
			{
				REQUIRE(depth < MAX_DEPTH);
				REQUIRE(pos < m_minMaxArraysByDepth[depth].size());
				REQUIRE(!m_minMaxArraysByDepth[depth].empty());
				___2479 const &minMax = m_minMaxArraysByDepth[depth][pos];
				ENSURE(minMax.___2067());
				return minMax;
			}
			bool minMaxIsValidForEntry(EntryIndex_t entry) const
			{
				REQUIRE(entry < size());
				bool const ___2067 = m_minMaxArraysByDepth[0][entry].___2067();
				return ___2067;
			}
			___2479 const &___1759(EntryIndex_t entry) const
			{
				REQUIRE(entry < size());
				___2479 const &minMax = m_minMaxArraysByDepth[0][entry];
				ENSURE(minMax.___2067());
				return minMax;
			}
			void ___3499(EntryIndex_t entry, double minVal, double maxVal)
			{
				REQUIRE(entry < size());
				REQUIRE(minVal <= maxVal);
				m_minMaxArraysByDepth[0][entry].___3499(minVal, maxVal);
				ENSURE(m_minMaxArraysByDepth[0][entry].___2067());
			}
			void ___3499(EntryIndex_t entry, ___2479 const &minMax)
			{
				REQUIRE(entry < size());
				REQUIRE(minMax.___2067());
				m_minMaxArraysByDepth[0][entry].___3499(minMax);
				ENSURE(m_minMaxArraysByDepth[0][entry].___2067());
			}
			void populateTree(EntryIndex_t ___2795);
			___372 populateTreeFromMinMax(___2479 const &minMax)
			{
				___372 ___2039 = allocUninitialized(1);
				if (___2039)
				{
					m_minMaxArraysByDepth[0][0] = minMax;
					populateTree(1);
				}
				else
					___937();
				ENSURE(IMPLICATION(___2039, isValidlyPopulated(1)));
				ENSURE(IMPLICATION(___2039, isPopulated()));
				ENSURE(IMPLICATION(!___2039, empty()));
				return ___2039;
			}
			___372 populateTreeFromFile(___1399 &file, FieldDataType_e ___1363, EntryIndex_t ___2795, IODescription const &___972)
			{
				REQUIRE(___2795 > 0);
				___372 ___2039 = allocUninitialized(___2795);
				switch (___1363)
				{
				case FieldDataType_Float:
					___2039 = ___2039 && readMinMaxArray<float>(file, 0, ___2795, m_minMaxArraysByDepth[0], ___972);
					break;
				case FieldDataType_Double:
					___2039 = ___2039 && readMinMaxArray<double>(file, 0, ___2795, m_minMaxArraysByDepth[0], ___972);
					break;
				case FieldDataType_Int32:
					___2039 = ___2039 && readMinMaxArray<int32_t>(file, 0, ___2795, m_minMaxArraysByDepth[0], ___972);
					break;
				case FieldDataType_Int16:
					___2039 = ___2039 && readMinMaxArray<int16_t>(file, 0, ___2795, m_minMaxArraysByDepth[0], ___972);
					break;
				case FieldDataType_Byte:
				case ___1365:
					___2039 = ___2039 && readMinMaxArray<uint8_t>(file, 0, ___2795, m_minMaxArraysByDepth[0], ___972);
					break;
				default:
					___478(___1305);
					___2039 = ___1305;
					break;
				}
				if (___2039)
					populateTree(___2795);
				else
					___937();
				ENSURE(IMPLICATION(___2039, isValidlyPopulated(___2795)));
				ENSURE(IMPLICATION(___2039, isPopulated()));
				ENSURE(IMPLICATION(!___2039, empty()));
				return ___2039;
			}
			static void findEntriesContainingNVarValues(___3269<MinMaxTree const *> const &minMaxTrees, ___3269<double> const &vals, EntryIndex_t ___2795, ___2090::___2980 ___2977, ___3269<___2090::SubzoneAddress> &entryAddresses)
			{
				size_t const numTrees = minMaxTrees.size();
				REQUIRE(!minMaxTrees.empty());
				REQUIRE(VALID_REF(minMaxTrees[0]) && minMaxTrees[0]->isValidlyPopulated(___2795));
				REQUIRE(VALID_REF(minMaxTrees[numTrees / 2]) && minMaxTrees[numTrees / 2]->isValidlyPopulated(___2795));
				REQUIRE(VALID_REF(minMaxTrees[numTrees - 1]) && minMaxTrees[numTrees - 1]->isValidlyPopulated(___2795));
				REQUIRE(minMaxTrees.size() == vals.size());
				REQUIRE(___2795 == minMaxTrees[0]->size() && ___2795 == minMaxTrees[numTrees / 2]->size() && ___2795 == minMaxTrees[numTrees - 1]->size());
				if (numTrees == 3)
				{
					MinMaxTree::findEntriesContaining3VarValues(*minMaxTrees[0], *minMaxTrees[1], *minMaxTrees[2], vals[0], vals[1], vals[2], ___2977, ___2795, entryAddresses);
				}
				else
				{
					EntryIndex_t startPos;
					EntryIndex_t endPos;
					minMaxTrees[0]->getChildRange(___2795, MinMaxTree::MAX_DEPTH, 0, startPos, endPos);
					MinMaxTree::recursivelyFindEntriesContainingNVarValues(minMaxTrees, vals, MinMaxTree::MAX_DEPTH - 1, startPos, endPos, ___2795, ___2977, entryAddresses);
				}
			}
			static void findEntriesContaining3VarValues(MinMaxTree const &xMinMaxTree, MinMaxTree const &yMinMaxTree, MinMaxTree const &zMinMaxTree, double xVal, double yVal, double zVal, ___2090::___2980 ___2977, EntryIndex_t ___2795, ___3269<___2090::SubzoneAddress> &entryAddresses)
			{
				REQUIRE(xMinMaxTree.isValidlyPopulated(___2795));
				REQUIRE(yMinMaxTree.isValidlyPopulated(___2795));
				REQUIRE(zMinMaxTree.isValidlyPopulated(___2795));
				REQUIRE(MAX_DEPTH == 4);
				EntryIndex_t const numEntriesAtDepth0 = ___2795;
				;
				___478(numEntriesAtDepth0 == getNumEntriesAtDepth(___2795, 0));
				EntryIndex_t const numEntriesAtDepth1 = getNumEntriesAtDepth(___2795, 1);
				EntryIndex_t const numEntriesAtDepth2 = getNumEntriesAtDepth(___2795, 2);
				EntryIndex_t const numEntriesAtDepth3 = getNumEntriesAtDepth(___2795, 3);
				EntryIndex_t depth3Start;
				EntryIndex_t depth3End;
				xMinMaxTree.getChildRangeUsingNumEntries(0, numEntriesAtDepth3, depth3Start, depth3End);
				for (EntryIndex_t depth3Pos = depth3Start; depth3Pos < depth3End; ++depth3Pos)
				{
					if (xMinMaxTree.getMinMaxAtDepth(3, depth3Pos).containsValue(xVal) && yMinMaxTree.getMinMaxAtDepth(3, depth3Pos).containsValue(yVal) && zMinMaxTree.getMinMaxAtDepth(3, depth3Pos).containsValue(zVal))
					{
						EntryIndex_t depth2Start;
						EntryIndex_t depth2End;
						xMinMaxTree.getChildRangeUsingNumEntries(depth3Pos, numEntriesAtDepth2, depth2Start, depth2End);
						for (EntryIndex_t depth2Pos = depth2Start; depth2Pos < depth2End; ++depth2Pos)
						{
							if (xMinMaxTree.getMinMaxAtDepth(2, depth2Pos).containsValue(xVal) && yMinMaxTree.getMinMaxAtDepth(2, depth2Pos).containsValue(yVal) && zMinMaxTree.getMinMaxAtDepth(2, depth2Pos).containsValue(zVal))
							{
								EntryIndex_t depth1Start;
								EntryIndex_t depth1End;
								xMinMaxTree.getChildRangeUsingNumEntries(depth2Pos, numEntriesAtDepth1, depth1Start, depth1End);
								for (EntryIndex_t depth1Pos = depth1Start; depth1Pos < depth1End; ++depth1Pos)
								{
									if (xMinMaxTree.getMinMaxAtDepth(1, depth1Pos).containsValue(xVal) && yMinMaxTree.getMinMaxAtDepth(1, depth1Pos).containsValue(yVal) && zMinMaxTree.getMinMaxAtDepth(1, depth1Pos).containsValue(zVal))
									{
										EntryIndex_t depth0Start;
										EntryIndex_t depth0End;
										xMinMaxTree.getChildRangeUsingNumEntries(depth1Pos, numEntriesAtDepth0, depth0Start, depth0End);
										for (EntryIndex_t depth0Pos = depth0Start; depth0Pos < depth0End; ++depth0Pos)
										{
											if (xMinMaxTree.getMinMaxAtDepth(0, depth0Pos).containsValue(xVal) && yMinMaxTree.getMinMaxAtDepth(0, depth0Pos).containsValue(yVal) && zMinMaxTree.getMinMaxAtDepth(0, depth0Pos).containsValue(zVal))
											{
												if (entryAddresses.empty())
													entryAddresses.reserve(MIN_ENTRIES_TO_ALLOCATE);
												else if (entryAddresses.size() >= entryAddresses.capacity())
													entryAddresses.reserve(entryAddresses.size() * ALLOCATION_EXPANSION_FACTOR);
												entryAddresses.append(___2090::SubzoneAddress(___2977, depth0Pos));
											}
										}
									}
								}
							}
						}
					}
				}
			}

		private:
			static void recursivelyFindEntriesContainingNVarValues(___3269<MinMaxTree const *> const &minMaxTrees, ___3269<double> const &vals, EntryIndex_t depth, EntryIndex_t startPos, EntryIndex_t endPos, EntryIndex_t ___2795, ___2090::___2980 ___2977, ___3269<___2090::SubzoneAddress> &entryAddresses);
		};
		typedef ___2240<MinMaxTree> MinMaxTreeArray;
		typedef ___2240<MinMaxTreeArray> MinMaxTree2DArray;
		typedef ___2240<MinMaxTree2DArray> MinMaxTree3DArray;
	}
}