/*
	FinalSun/FinalAlert 2 Mission Editor

	Copyright (C) 1999-2024 Electronic Arts, Inc.
	Authored by Matthias Wagner

	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 <https://www.gnu.org/licenses/>.
*/

/**************************************
	Global structs here
**************************************/

#ifndef GLOBALSTRUCTS_H_INCLUDED
#define GLOBALSTRUCTS_H_INCLUDED

#include "defines.h"
#include <vector>
#include <memory>
#include <cstdint>
#include "MissionEditorPackLib.h"
#include "Vec2.h"

class MapTool;

enum class MouseActionType : unsigned {
	AddInfantry = 1,
	AddStructure = 2,
	AddAircraft = 3,
	AddVehicle = 4,
	AddTerrain = 5,
	ManageOverlay = 6,
	ChangeOwner = 7,
	AddSmudge = 8,
};

enum class TheaterChar : char
{
	T = 'T',
	A = 'A',
	U = 'U',
	N = 'N',
	D = 'D',
	L = 'L',
	Generic = 'G',
	None = 0
};

inline TheaterChar toTheaterChar(char c)
{
	switch (c) {
	case 'T':
		return TheaterChar::T;
	case 'A':
		return TheaterChar::A;
	case 'U':
		return TheaterChar::U;
	case 'N':
		return TheaterChar::N;
	case 'D':
		return TheaterChar::D;
	case 'L':
		return TheaterChar::L;
	case 'G':
		return TheaterChar::Generic;
	default:
		return TheaterChar::None;
	}
}

struct CLIPBOARD_MAPCOPY_ENTRY
{
	BOOL bRedrawTerrain;
	BYTE overlay;
	BYTE overlaydata;
	WORD wGround;
	WORD bMapData;
	BYTE bSubTile;
	BYTE bHeight;
	BYTE bMapData2;

	// for RA2<->TS conversion:
	WORD wTileSet;
	BYTE bTile;
};

struct CLIPBOARD_DATA
{
	DWORD dwType;
	DWORD dwVersion;
	DWORD dwReserved;
	BYTE bGame; // 0 TS, 1 RA2
	UINT iWidth;
	UINT iHeight;
};

struct VBORDER
{
	short left;
	short right;
};

/*
picdata

Holds information for every picture:
a directdraw surface, and additional data
*/
struct PICDATA {
	PICDATA() = default;
	PICDATA(const PICDATA& c) = default;
	PICDATA& operator=(const PICDATA& c) = default;
	~PICDATA() = default;

#ifndef NOSURFACES_OBJECTS
	LPDIRECTDRAWSURFACE4 pic;
#else
	void* pic = nullptr; // BYTE* to image, exception: if bType==PICDATA_TYPE_BMP then this is a LPDIRECTDRAWSURFACE!
	VBORDER* vborder = nullptr;
	const int* pal = nullptr;
	std::shared_ptr<std::vector<BYTE>> lighting;
	std::shared_ptr<std::vector<BYTE>> rawPic;
	std::shared_ptr<std::vector<VBORDER>> _vBorder;
#endif

	FSunPackLib::VoxelNormalClass normalClass = FSunPackLib::VoxelNormalClass::Unknown;
	short x = 0; // for SHPs (starting point of main graphic inside surface)
	short y = 0; // for SHPs (starting point of main graphic inside surface)
	WORD wWidth = 0; // for non-shps: size of whole surface, else size of main graphic
	WORD wHeight = 0; // for non-shps: size of whole surface, else size of main graphic
	WORD wMaxWidth = 0; // for SHPs (size of whole surface)
	WORD wMaxHeight = 0; // for SHPs (size of whole surface)
	BYTE bType = 0; // is loaded from voxel, shp, bmp, etc... (for drawing logic)
	TheaterChar bTerrain = TheaterChar::None;
	bool bTried = false; // already tried to load this? - superseded by global array missingimages
	bool bHouseColor = false;

	inline ProjectedVec drawOffset() const
	{
		return ProjectedVec(x, y);
	}

#ifdef NOSURFACES_OBJECTS
	void createVBorder();
#endif

};

/*
TILEPIC / TILEDATA

Holds information for every tile/subtile in TS.
*/
struct SUBTILE {
#ifndef NOSURFACES
	LPDIRECTDRAWSURFACE4 pic;
#else
#ifdef NOSURFACES_EXTRACT
	BOOL bNotExtracted; // pic is not extracted, even if NOSURFACES_EXTRACT is specifed. Probably there is inner transparency!
#endif
	BYTE* pic; // optionally use direct blitting? This is either a palette index array or non-palette data (if NOSURFACES_EXTRACT is specified)
	VBORDER* vborder;
#endif

	WORD wWidth; // width of tile
	WORD wHeight; // height "
	short sX; // x starting pos
	short sY; // y starting pos
	BYTE bZHeight; // z difference from tile ground surface (1unit == f_y/2pixel == 12pixel)
	BYTE bDirection; // for ramps for example
	BYTE bTerrainType; // water, etc...
	RGBTRIPLE rgbLeft;
	RGBTRIPLE rgbRight;
	BYTE bHackedTerrainType; // same like bTerrainType, except some shore pieces that were hacked in fsdata.ini

	std::shared_ptr<PICDATA> anim;

	inline ProjectedVec drawOffset() const
	{
		return ProjectedVec(sX, sY);
	}
};
struct TILEDATA {
	TILEDATA() = default;
	~TILEDATA();
	WORD wTileSet = 0;
	SUBTILE* tiles = nullptr; // the different tiles
	WORD wTileCount = 0; // number of tiles	
	WORD cx = 0;
	WORD cy = 0;
	BOOL bAllowTiberium = 0;
	BOOL bAllowToPlace = TRUE;
	BOOL bMorphable = FALSE; // morphable using lower/raise ground function?
	BOOL bHide = FALSE; // for user interface only
	BOOL bMarbleMadness = FALSE;
	WORD wMarbleGround = 0xFFFF;

public:
	RECT rect = { 0 };

	TILEDATA* lpReplacements = nullptr;
	BYTE bReplacementCount = 0;
};

/*
actiondata

CViewObjects sets this data struct,
and CIsoView uses it to interact with the user´s CViewObjects and terrain editing choice
*/
struct ACTIONDATA {
	DWORD mode;
	DWORD type;
	DWORD data;
	DWORD data2;
	DWORD data3;
	int z_data;
	CString data_s;
	std::unique_ptr<MapTool> tool;

	~ACTIONDATA();

	void reset();
};

struct SIDEINFO {
	CString name;
	int orig_n;
};

struct HOUSEINFO {
	CString name;
	SIDEINFO* side; // side is used for rules.ini owner= settings
	RGBTRIPLE color;
	BOOL bPlayable;
};

/**********************
  Unittype infos
**********************/

/*
building infos
*/
struct BUILDING_INFO
{
	PICDATA pic[8];
	int pic_count;
	BYTE w;
	BYTE h;
	BOOL bTemp;
	BOOL bSnow;
	BOOL bUrban;
};

struct TREE_INFO
{
	PICDATA pic;
	BYTE w;
	BYTE h;
};

#ifdef SMUDGE_SUPP
struct SMUDGE_INFO
{
	PICDATA pic;
	//BYTE w;
	//BYTE h;
};
#endif

/**
* Condtion Type enum
*/
enum ConditionType {
	COND_TYPE_NONE = 0,
	COND_TYPE_ENEMY_OWNS,
	COND_TYPE_SELF_OWNS,
	COND_TYPE_ENEMY_YELLOW_POWR,
	COND_TYPE_ENEMY_RED_POWR,
	COND_TYPE_ENEMY_OWNS_SOME_MONEY,
	COND_TYPE_IRON_CURTAIN_READY,
	COND_TYPE_CHRONO_SPHERE_READY,
	COND_TYPE_NEUTRAL_OWNS,
};

/**
* Condition Operator enumeration
*/
enum ConditionOpEnum {
	COND_OP_LT = 0,	// less than
	COND_OP_LE,			// less than or equal to
	COND_OP_EQ,			// equal to
	COND_OP_GE,			// greater than or equal to
	COND_OP_GT,			// greater than
	COND_OP_NE,			// not equal to
	COND_OP_COUNT
};

struct AITrigInfo
{
	union {
		struct {
			int Number;
			ConditionOpEnum Condition;
		};
		char Padding[32];
	};
};


/*
Struct for string items
*/
struct XCString
{
	XCString()
	{
		//wString=new(WCHAR[2]);
		//memset(wString, 0, 4);
		wString = NULL;
		bUsedDefault = FALSE;
		len = 0;
	}
	~XCString()
	{
		if (wString) delete[] wString;
		len = 0;
		wString = NULL;
	}
	void SetString(const CHAR* cString)
	{
		len = strlen(cString);

		this->cString = cString;

		if (wString) delete[] wString;

		bUsedDefault = FALSE;
		wString = new(WCHAR[len + 1]);
		memset(wString, 0, (len + 1) * sizeof(WCHAR));

		size_t convertedSize = 0;
		mbstowcs_s(&convertedSize, wString, len + 1, cString, len);

	}
	void SetString(const WCHAR* wString, int len)
	{
		this->len = len;

		if (this->wString) delete[] this->wString;

		bUsedDefault = FALSE;

		this->wString = new(WCHAR[len + 1]);
		memset(this->wString, 0, (len + 1) * 2);
		memcpy(this->wString, wString, len * 2);

		auto bufferSize = WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK, this->wString, len + 1, nullptr, 0, NULL, &bUsedDefault);
		if (bufferSize == 0) {
			cString = "";
			return; // failed
		}

		std::vector<BYTE> bByte(bufferSize + 4, 0);
		if (WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK, this->wString, len + 1, (LPSTR)bByte.data(), bufferSize, NULL, &bUsedDefault) == 0) {
			cString = "";
			return; // failed
		}
		cString = bByte.data();

	}
	CString cString;
	WCHAR* wString;
	BOOL bUsedDefault;
	size_t len;
};


/**********************
	Map stuff structs
***********************/

/*
AITRIGGERTYPE{};

Data for ai trigger types
*/
struct AITRIGGERTYPE {
	CString ID; // ai trigger id
	CString name; // param 1
	CString teamtype1; // param 2
	CString owner; // param 3
	CString techlevel; // flag 1/ param 4
	CString type; // param 5
	CString unittype; // param 6
	CString data; // param 7
	CString float1; // param 8 
	CString float2; // param 9
	CString float3; // param 10
	CString skirmish; // param 11
	CString flag4; // param 12 
	CString multihouse; // param 13
	CString basedefense; // param 14
	CString teamtype2; // param 15
	CString easy; // param 16
	CString medium; // param 17
	CString hard; // param 18
};

/*
STDOBJECTDATA

Data for Trees, Units, Infantry, Aircraft & Structures
This should be used for painting procedure...
except if you want to draw the upgrades on buildings
*/
struct STDOBJECTDATA
{
	CString house; // 1
	CString type; // 2
	CString strength; // 3
	CString y; // 4
	CString x; // 5
};

/*
STRUCTURE

Data for a structure
*/
struct STRUCTURE {
	CString house; // 1
	CString type; // 2
	CString strength; // 3
	CString y; // 4
	CString x; // 5
	CString direction; // 6
	CString tag; // 7
	CString flag1; // 8
	CString flag2; // 9
	CString energy; // 10
	CString upgradecount; // 11
	CString spotlight; // 12
	CString upgrade1; // 13
	CString upgrade2; // 14
	CString upgrade3; // 15
	CString flag3; // 16
	CString flag4; // 17
	unsigned deleted : 1;
};

// structure data especially for painting
struct STRUCTUREPAINT {
	COLORREF col;
	CString type;
	short x;
	short y;
	short direction;
	BYTE strength;
	BYTE upradecount;
	CString upgrade1;
	CString upgrade2;
	CString upgrade3;
};


/*
struct INFANTRY{};

Data for an infantry unit
*/
struct INFANTRY {
	CString house; // 1
	CString type; // 2
	CString strength; // 3
	CString y; // 4
	CString x; // 5
	CString pos; // 6
	CString action; // 7
	CString direction; // 8
	CString tag; // 9
	CString flag1; // 10
	CString group; // 11
	CString flag3; // 12
	CString flag4; // 13
	CString flag5; // 14
	unsigned deleted : 1;
};

struct UNIT {
	CString house; // 1
	CString type; // 2
	CString strength; // 3
	CString y; // 4
	CString x; // 5
	CString direction; // 6
	CString action; // 7
	CString tag; // 8
	CString flag1; // 9
	CString group; // 10
	CString flag3; // 11
	CString flag4; // 12
	CString flag5; // 13
	CString flag6; // 14
	unsigned deleted : 1;
};



struct AIRCRAFT {
	CString house; // 1
	CString type; // 2
	CString strength; // 3
	CString y; // 4
	CString x; // 5
	CString direction; // 6
	CString action; // 7
	CString tag; // 8
	CString flag1; // 9
	CString group; // 10
	CString flag3; // 11
	CString flag4; // 12
	unsigned deleted : 1;
};

struct TERRAIN {
	CString type;
	int x;
	int y;
	unsigned deleted : 1;
};

// MW 08/07/01: Smudge
#ifdef SMUDGE_SUPP
struct SMUDGE {
	CString type;
	int x;
	int y;
	unsigned deleted : 1;
};
#endif

/*
NODE

Data for a node
*/
struct NODE {
	CString house;
	CString type;
	CString x;
	CString y;
};


struct RA2STRFILEHEAD
{
	DWORD dwFlag1;
	DWORD dwCount1;
	DWORD dwCount2;
	DWORD dwUnused;
	DWORD dwFlag2;
};

#define RA2STRFILEHEADSIZE 20

struct RA2STRINGENTRY
{
	RA2STRINGENTRY() {
		//memset(this, 0, sizeof(RA2STRINGENTRY));
		id = NULL;
		value = NULL;
		value_asc = 0;
		value_asc_size = 0;
		dwFlag = 0;
		id_size = 0;
		value_size = 0;
	}
	~RA2STRINGENTRY() {
		if (value) delete[] value;
		if (id) delete[] id;
		if (value_asc) delete[] value_asc;
		value = NULL;
		value_size = 0;
		id = NULL;
		id_size = 0;
		value_asc = 0;
		value_asc_size = 0;
	}
	RA2STRINGENTRY(RA2STRINGENTRY& ref)
	{
		value = NULL;
		value_size = 0;
		id = NULL;
		id_size = 0;
		value_asc = 0;
		value_asc_size = 0;

		if (ref.value_size && ref.value) {
			value_size = ref.value_size;
			value = new(WCHAR[value_size + 1]);
			memcpy(value, ref.value, value_size * sizeof(WCHAR));
			value[value_size] = 0;
		}
		if (ref.id_size && ref.id) {
			id_size = ref.id_size;
			id = new(CHAR[id_size + 1]);
			memcpy(id, ref.id, id_size * sizeof(CHAR));
			id[id_size] = 0;
		}
		if (ref.value_asc_size && ref.value_asc) {
			value_asc_size = ref.value_asc_size;
			value_asc = new(CHAR[value_asc_size + 1]);
			memcpy(value_asc, ref.value_asc, value_asc_size * sizeof(CHAR));
			value_asc[value_asc_size] = 0;
		}
		dwFlag = ref.dwFlag;
	}
	RA2STRINGENTRY& operator=(RA2STRINGENTRY& ref)
	{
		if (value) delete[] value;
		if (id) delete[] id;
		value = NULL;
		value_size = 0;
		id = NULL;
		value_asc = 0;
		value_asc_size = 0;

		if (ref.value_size) {
			value_size = ref.value_size;
			value = new(WCHAR[value_size + 1]);
			memcpy(value, ref.value, value_size * sizeof(WCHAR));
			value[value_size] = 0;
		}
		if (ref.id_size) {
			id_size = ref.id_size;
			id = new(CHAR[id_size + 1]);
			memcpy(id, ref.id, id_size * sizeof(CHAR));
			id[id_size] = 0;
		}
		if (ref.value_asc_size) {
			value_asc_size = ref.value_asc_size;
			value_asc = new(CHAR[value_asc_size + 1]);
			memcpy(value_asc, ref.value_asc, value_asc_size * sizeof(CHAR));
			value_asc[value_asc_size] = 0;
		}
		dwFlag = ref.dwFlag;

		return *this;
	}

	DWORD dwFlag;
	CHAR* id;
	DWORD id_size;
	DWORD value_size;
	WCHAR* value;
	CHAR* value_asc;
	DWORD value_asc_size;
};



#endif