/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * Additional copyright for this file:
 * Copyright (C) 1999-2000 Revolution Software Ltd.
 * This code is based on source code created by Revolution Software,
 * used with permission.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef ICB_LIBRARY_CMYACTARRAY
#define ICB_LIBRARY_CMYACTARRAY

#include "engines/icb/common/px_rcutypes.h"

namespace ICB {

#define MY_TEMPLATE template <class Type>
#define T_MYACTARRAY rcActArray<Type>
#define T_MYPTRARRAY rcAutoPtrArray<Type>

MY_TEMPLATE class rcActArray {
public:
	rcActArray() { // Construct an empty array
		m_userPosition = m_allocatedSize = 0;
	}

	rcActArray(rcActArray &a) {
		m_userPosition = m_allocatedSize = 0;
		(*this) = a;
	}

	~rcActArray(); // Destruct the array

	void operator=(const rcActArray &);

	// Member access functions
	uint32 GetNoItems() const { return (m_userPosition); }

	uint32 Add(const Type &f); // Add an item.

	Type &operator[](uint32); // Give access to an entry
	const Type &operator[](uint32 i) const;

	void SetSize(uint32 n) { ResizeArray(n); }
	void Reset();

private:
	uint32 m_userPosition;  // Next place to add an item to
	uint32 m_allocatedSize; // How many items have been allocated

	Type **m_contents; // A pointer to pointers to the objects

	void ResizeArray(uint32); // Change the size of the array
};

MY_TEMPLATE
void T_MYACTARRAY::operator=(const rcActArray &a) {
	if (m_allocatedSize)
		delete[] m_contents;
	m_userPosition = a.m_userPosition;
	m_allocatedSize = a.m_allocatedSize;

	if (m_allocatedSize)

	{
		m_contents = new Type *[m_allocatedSize];
		for (uint32 count = 0; count < m_allocatedSize; count++)
			m_contents[count] = new Type(*(a.m_contents[count]));
	}
}

MY_TEMPLATE
Type &T_MYACTARRAY::operator[](uint32 n) {
	if (n >= m_userPosition) {
		ResizeArray(n);
		m_userPosition = n + 1;
	}
	return (*(m_contents[n]));
}

MY_TEMPLATE
const Type &T_MYACTARRAY::operator[](uint32 n) const {
	// It is permissible to look at an element that has not been defined, as the constructor assures
	// that the contents are valid
	if (n >= m_userPosition) {
		// Remove any 'constness' for a resize
		(const_cast<rcActArray<Type> *>(this))->ResizeArray(n);
		(const_cast<rcActArray<Type> *>(this))->m_userPosition = n + 1;
	}

	return (*(m_contents[n]));
}

MY_TEMPLATE T_MYACTARRAY::~rcActArray() { Reset(); }

MY_TEMPLATE void T_MYACTARRAY::Reset() {
	for (uint32 count = 0; count < m_allocatedSize; count++)
		delete m_contents[count];

	if (m_allocatedSize)
		delete[] m_contents;
	m_allocatedSize = 0;
	m_userPosition = 0;
}

MY_TEMPLATE void T_MYACTARRAY::ResizeArray(uint32 n2) {
	// if n is still within the allocated area then just set the last position
	if (n2 >= m_allocatedSize) {
		// Make sure we are going to make the thing big enough
		uint32 nextSize = m_allocatedSize ? m_allocatedSize + m_allocatedSize : 1; // Double, or 1 if now 0
		while (nextSize <= n2)
			nextSize += nextSize;

		// Get a New pointer array of the correct size
		Type **newArray = new Type *[nextSize];
		if (m_allocatedSize > 0) {
			// Copy in the old stuff
			memcpy((unsigned char *)newArray, (unsigned char *)m_contents, m_allocatedSize * sizeof(Type *));
		}
		// Put empty objects in the newly allocated space
		for (uint32 newObjects = m_allocatedSize; newObjects < nextSize; newObjects++)
			newArray[newObjects] = new Type;
		// Remove any old stuff
		if (m_allocatedSize)
			delete[] m_contents;
		m_contents = newArray;
		m_allocatedSize = nextSize;
	}
}

MY_TEMPLATE uint32 T_MYACTARRAY::Add(const Type &f) {
	operator[](m_userPosition) = f;
	return (m_userPosition - 1);
}

MY_TEMPLATE class rcAutoPtrArray {
	uint32 m_noContents;   // How many entries have been allocated
	uint32 m_userPosition; // Next position for the Add command

	Type **m_contents; // A pointer to pointers to the objects

	void ResizeArray(uint32); // Change the size of the array
public:
	explicit rcAutoPtrArray() { // Construct an empty array
		m_noContents = m_userPosition = 0;
	}
	~rcAutoPtrArray(); // Destruct the array

	// Member access functions
	uint32 GetNoItems() const { return (m_userPosition); }

	uint32 Add(Type *f) {
		operator[](m_userPosition) = f;
		return (m_userPosition - 1);
	}

	Type *&operator[](uint32);             // Give access to an entry
	const Type *&operator[](uint32) const; // Give access to an entry

	void Reset();
	void RemoveAndShuffle(uint32); // Remove an object from the array
	void SetSize(uint32 n) { ResizeArray(n); }

	// Super dangerous, but faster, access to the array
	Type *GetRawArray() { return (*m_contents); }

private: // Prevent use of the PtrArray copy constructor
	// The default copy constructor should never be called
	rcAutoPtrArray(const rcAutoPtrArray &) {}
	void operator=(const rcAutoPtrArray &) {}
};

MY_TEMPLATE
Type *&T_MYPTRARRAY::operator[](uint32 n) {
	if (n >= m_userPosition) {
		ResizeArray(n);
		m_userPosition = n + 1;
	}
	return (m_contents[n]);
}

MY_TEMPLATE
const Type *&T_MYPTRARRAY::operator[](uint32 n) const {
	// It is permissible to look at an element that has not been defined, as it will be defined as NULL
	if (n >= m_userPosition) {
		(const_cast<rcAutoPtrArray<Type> *>(this))->ResizeArray(n);
		(const_cast<rcAutoPtrArray<Type> *>(this))->m_userPosition = n + 1;
	}

	return const_cast<const Type *&>(m_contents[n]);
}

MY_TEMPLATE T_MYPTRARRAY::~rcAutoPtrArray() { Reset(); }

MY_TEMPLATE void T_MYPTRARRAY::Reset() {
	// The pointer array maintains responsibility for deleting any contents
	for (uint32 count = 0; count < m_userPosition; count++)
		if (m_contents[count])
			delete m_contents[count];
	if (m_noContents)
		delete[] m_contents;
	m_noContents = m_userPosition = 0;
}

MY_TEMPLATE void T_MYPTRARRAY::ResizeArray(uint32 n2) {
	if (n2 >= m_noContents) {
		// Double the allocation value
		uint32 nextSize = m_noContents > 0 ? m_noContents + m_noContents : 1;
		while (n2 >= nextSize)
			nextSize = nextSize + nextSize;
		// Get a New pointer array of the correct size
		Type **newArray = new Type *[nextSize];
		// Copy in the old stuff, if there is any
		if (m_noContents > 0)
			memcpy((unsigned char *)newArray, (unsigned char *)m_contents, m_noContents * sizeof(Type *));
		// Reset the New entries
		memset((unsigned char *)(newArray + m_noContents), 0, (nextSize - m_noContents) * sizeof(Type *));
		// Remove any old stuff
		if (m_noContents)
			delete[] m_contents;
		m_contents = newArray;
		m_noContents = nextSize;
	}
}

MY_TEMPLATE void T_MYPTRARRAY::RemoveAndShuffle(uint32 n) {
	// Remove an object from the array

	// First delete it
	if (m_contents[n])
		delete m_contents[n];
	// and shuffle the array
	memcpy(m_contents + n, m_contents + n + 1, (m_noContents - n - 1) * sizeof(Type *));
}

template <class Type> class rcIntArray {
	uint32 m_noContents;   // How many entries there are
	uint32 m_userPosition; // Where the next add position goes
	Type *m_contents;

	void ResizeArray(uint32); // Change the size of the array

public:
	explicit rcIntArray() { // Construct an empty array
		m_noContents = m_userPosition = 0;
	}
	~rcIntArray() { // Destruct the array
		if (m_noContents)
			delete[] m_contents;
	}

	// Copy constructor
	rcIntArray(const rcIntArray &a) {
		m_noContents = m_userPosition = 0;
		(*this) = a;
	}

	// Constructor with an initial size
	rcIntArray(uint32 initialSize) { ResizeArray(initialSize); }

	const rcIntArray &operator=(const rcIntArray &);

	// Member access functions
	uint32 GetNoItems() const { return (m_userPosition); }

	uint32 Add(Type f); // Add an integer. Only makes sense if the resize step is one

	Type &operator[](uint32);            // Give access to an entry
	const Type operator[](uint32) const; // Give access to an entry

	void Reset();
	void SetSize(uint32 n) { ResizeArray(n); }

	Type *GetRawArray() { return (m_contents); }
};

template <class Type> Type &rcIntArray<Type>::operator[](uint32 index) {
	if (index >= m_userPosition) {
		ResizeArray(index);
		m_userPosition = index + 1;
	}
	return m_contents[index];
}

// This version of [] allows the array to be part of a const function
template <class Type> const Type rcIntArray<Type>::operator[](uint32 index) const {
	// It is permissible to look at an element that has not been defined, as it will have been set to 0
	if (index >= m_userPosition) {
		// Remove any 'constness' for a resize
		(const_cast<rcIntArray<Type> *>(this))->ResizeArray(index);
		(const_cast<rcIntArray<Type> *>(this))->m_userPosition = index + 1;
	}

	return m_contents[index];
}

template <class IntType> void rcIntArray<IntType>::ResizeArray(uint32 accessedSize) {
	// Check if we need to do any reallocating
	if (accessedSize >= m_noContents) {
		uint32 newSize = m_noContents > 0 ? m_noContents * 2 : 1;
		while (newSize <= accessedSize)
			newSize = newSize + newSize;

		IntType *newArray = new IntType[newSize];
		if (m_noContents)
			memcpy(newArray, m_contents, m_noContents * sizeof(IntType));
		// Call me a fool, but I like my integers initialised to 0
		memset(newArray + m_noContents, 0, (newSize - m_noContents) * sizeof(IntType));

		if (m_noContents)
			delete[] m_contents;
		m_contents = newArray;
		m_noContents = newSize;
	}
}

template <class IntType> const rcIntArray<IntType> &rcIntArray<IntType>::operator=(const rcIntArray<IntType> &obOpB) {
	uint32 nCount;

	if (m_noContents)
		delete[] m_contents;
	m_userPosition = obOpB.m_userPosition;
	m_noContents = obOpB.m_noContents;

	if (m_noContents) {
		m_contents = new IntType[m_noContents];
		for (nCount = 0; nCount < m_noContents; nCount++)
			m_contents[nCount] = obOpB.m_contents[nCount];
	}

	return *this;
}

template <class Type> void rcIntArray<Type>::Reset() {
	// CLear out the array
	if (m_noContents) {
		delete[] m_contents;
		m_noContents = m_userPosition = 0;
	}
}

template <class Type> uint32 rcIntArray<Type>::Add(Type f) {
	// Add an integer. Only makes sense if the resize step is one
	operator[](m_userPosition) = f;
	return (m_userPosition - 1);
}

} // End of namespace ICB

#endif // ndef _LIBRARY_CMYACTARRAY