#ifdef _WIN32
  #define _CRT_SECURE_NO_DEPRECATE
  #include <windows.h>
  #include <direct.h>
  #include <GL/glew.h>
  #define _USE_MATH_DEFINES
#endif

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <iostream>
#include <fstream>
#include <vector>
#include <GL/gl.h>
#include <GL/glu.h>

#include <GL/glut.h>

#include "rwcore.h"
#include "rpworld.h"

#ifndef DFFVIEWER_H
#define DFFVIEWER_H

#define GAMEPC  0x1
#define GAMEPS2 0x2
#define GAMEIII	0x4
#define GAMEVICECITY 0x8
#define GAMESANANDREAS 0x10

#define GAME		0
#define CLUMPVIEWER	1

#define AMBIENT_ONLY	0
#define AMBIENT_AND_DIFFUSE	1

//#define VERBOSE cout
#define VERBOSE cerr

using namespace std;

typedef unsigned int uint;
typedef unsigned char byte;
typedef byte color[4];

typedef struct Instance Instance;
typedef struct DirEntry DirEntry;
typedef struct SWeather SWeather;
typedef struct SCloud SCloud;

enum BlockTypeAll {
	END = 0
};

enum BlockTypeIpl {
	INST = 1,
	CULL
};

enum BlockTypeIde {
	OBJS = 1,
	TOBJ,
	PATH,
	TWODFX,
	ANIM,
	TXDP
};

class CGLView {
private:
	int	nRadarFiles;
	bool	useFog;
	bool	useTextures;
	bool	useVertexColors;
	bool	useTint;
	bool	doStereo;
	bool	doRadar;
	bool	doCulling;
	bool	doWire;
public:
	void	Init(void);
	void	StartOgl(int, char**);
	void	UpdateScene(int ms);
	void	RenderScene(void);
	void	RenderClump(void);
	void	RenderMap(void);
	void	RenderMapViewport(void);
	void	DrawRadar(void);
	void	SwapBuffers(void);
	int	getWidth(void);
	int	getHeight(void);
	void	MakeScreenshot(void);

	void	SetnRadarFiles(int);

	void	SetFog(bool);
	void	ToggleFog();
	bool	UseFog();
	void	SetTextures(bool);
	void	ToggleTextures();
	bool	UseTextures();
	void	SetVertexColors(bool);
	void	ToggleVertexColors();
	bool	UseVertexColors();
	void	SetTint(bool);
	void	ToggleTint();
	bool	UseTint();
	void	SetStereo(bool);
	void	ToggleStereo();
	bool	DoStereo();
	void	SetRadar(bool);
	void	ToggleRadar();
	bool	DoRadar();
	void	SetCulling(bool);
	void	ToggleCulling();
	bool	DoCulling();
	void	ToggleWire();
};

class CCamera {
private:
	GLfloat	Position[3];
	GLfloat	LookVector[3];
	GLfloat Up[3];
	GLfloat	Yaw;
	GLfloat	Pitch;
	GLfloat	CamPositions[12][5];
	GLfloat	FOV;
	GLfloat	Frustum[6][4];
	GLfloat	EyeDist;
	GLfloat ArcLength;
	void	CalcLookVector(void);
	void	CalcCameraPosition(void);
	GLfloat	NormalizeVector(GLfloat *v);
public:
	void	Init(void);
	void	SetYaw(GLfloat);
	GLfloat	GetYaw(void);
	void	SetPitch(GLfloat);
	GLfloat	GetPitch(void);
	void	SetPosition(GLfloat, GLfloat, GLfloat);
	void	SetTarget(GLfloat, GLfloat, GLfloat);
	void	ArcLeftRight(GLfloat ang);
	void	ArcUpDown(GLfloat ang);
	void	Dolly(GLfloat dist);
	void	MoveTargetInOut(GLfloat dist);
	void	TurnLeftRight(GLfloat ang);
	void	TurnUpDown(GLfloat ang);
	void	MoveForwardBackward(GLfloat dist);
	void	MoveUpDown(GLfloat dist);
	void	PanLeftRight(GLfloat dist);
	void	PanUpDown(GLfloat dist);
	void	ChangeFOV(GLfloat);
	GLfloat	GetFOV(void);
	void	IncreaseEyeDist(GLfloat);
	void	DecreaseEyeDist(GLfloat);
	void	UpdateFrustum(void);
	bool	isPointInFrustum(const GLfloat *);
	bool	isSphereInFrustum(const GLfloat *, GLfloat r);
	bool	isTranslatedPointInFrustum(const GLfloat *);
	bool	isTranslatedSphereInFrustum(const GLfloat *, GLfloat r);
	void	Look(void);
	void	LookLeftEye(void);
	void	LookRightEye(void);
	float	DistanceTo(float *vector);
	void	ReadSavedPositions(void);
	void	SavePosition(int PosNumber);
	void	LoadPosition(int PosNumber);
	void	GetPosition(GLfloat *x, GLfloat *y, GLfloat *z);
	GLfloat	GetDistanceToTarget(void);
	void	SetDistanceToTarget(GLfloat);

	void	DumpPos(void);
	CCamera();
	~CCamera();
};


struct DirEntry {
	char	FileName[48]; /* file name used by GTA */
	uint	Start;
	uint	Size;
	char	ContFile[48]; /* the actual file */
	bool	Unloadable;

	void	*Data;
	/* Only SA TXDs */
	DirEntry *Parent;

	int	RefCount;
};

class CDirectory {
private:
	vector<DirEntry> FileList;
public:
	void	AppendFromDir(FILE *Dir, const char *ContFile);
	void	Append(DirEntry&);
	void	Append(const char *FileName, uint Start, uint Size,
	            const char *ContFile, void * Data);
	DirEntry *GetEntry(const char *FileName);
	DirEntry *GetEntry(const char *Name, const char *Ext);
	void	Dump(void);
};

/* Only type 0 (light) at the moment */
class C2dfx {
public:
	int	ID;
	Vector3f PositionV;
	color	Color;
	int	Type;	/* Only 0 supported */

	/* Light */
	char	CoronaTexture[24];
	char	ShadowTexture[24];
	int	DrawDist;
	int	outer_range;
	int	lamp_size;
	int	inner_range;
	int	corona_size;
	int	control;
	int	reflection_on_wet_roads;
	int	lensflare;
	int	dust;
};

class CWorldObj {
private:
public:
	int	ID;
	char	ModelName[25];
	char	TextureName[25];
	char	AnimName[25];
	int	ObjCount;
	float	*DrawDist;
	float	*MinDrawDist;
	int	Flags;
	int	TimeOn;
	int	TimeOff;
	bool	isTimed;

	GLfloat	BSphere[4];

	RpClump	*Clump;
	RwTexDictionary *TexDict;

	DirEntry *DffEntry;
	DirEntry *TxdEntry;

	bool	isLOD;
	bool	isIslandLOD;

	CWorldObj *next;
	Instance *InstList;

//	void SetClump(RpClump *);
//	RpClump *GetClump(void);
	void	TransformFrame(RwFrame *, RwInt32);
	void	DrawGeometry(RpGeometry&, bool);
	void	Draw(bool DoTransformation, int atomic, bool DrawTransp);
};

struct Instance {
	int	ID;
	char	Name[64];
	int	Interior;
	Vector3f PositionV;
	Vector3f ScaleV;
	Vector4f Rotation;
	int	LOD;

	float	*MaxDrawDist;
	float	*MinDrawDist;

	CWorldObj *Obj;
	Instance *LODp;

	int	Index;

	bool	isLOD;
	bool	isIslandLOD;
	Instance *next;
};


class CFileLoader {
public:
	RpClump	*LoadClump(RwChar *Path);
	RpClump	*LoadClump(DirEntry *);
	RwTexDictionary *LoadTexDict(RwChar *Path);
	RwTexDictionary *LoadTexDict(DirEntry *);
	void	FreeRwTextures(RwTexDictionary *);
	void	LoadGLTextures(RwTexDictionary *);
	bool	LoadDff(CWorldObj *obj);
	bool	LoadTxd(CWorldObj *obj);
	void	UnloadWorldObj(CWorldObj *obj);
	FILE	*OpenFile(DirEntry *Entry);
};

class CWater {
private:
	byte	indiceshi[128*128];
	byte	indiceslo[64*64];
	float	palette[48]; /* not sure */
	void	DrawPatch(float x, float y, float patchsize, float height);
public:
	GLuint	TexID;
	void	Init(void);
	void	Draw(void);
	void	ReadWaterData(void);
};

struct SWeather {
	color	Amb;
	color	Amb_Obj;
	color	Amb_Bl;
	color	Amb_Obj_bl;
	color	Dir;
	color	Sky_top;
	color	Sky_bot;
	color	SunCore;
	color	SunCorona;
	float	SunSz;
	float	SprSz;
	float	SprBght;
	int	Shdw;
	int	LightShd;
	int	TreeShd;
	int	PoleShd;
	float	FarClp;
	float	FogSt;
	float	LightOnGround;
	color	LowCloudsRGB;
	color	TopCloudRGB;
	color	BottomCloudRGB;

	/* GTA 3 only, multiplied with 0.6 (AK-73) */
	color	Tint;

	color	BlurRGB;
	color	WaterRGBA;

	color	RGBA1;
	color	RGBA2;
	float	CloudAlpha;
};

struct SCloud {
	GLfloat	Position[3];
	char	TexName[12];
};

class CSky {
private:
	vector<SWeather> WeatherList;
	int	numWeather;
	int	WeatherSelector;
	GLfloat SunPos[3];
	SCloud	BottomClouds[10];
	SCloud	TopClouds[10];
	int	LightModel;
public:
	void	Clear(void);
	void	Draw(void);
	void	DrawSunCorona(void);
	void	DrawCloud(const char *TexName, GLfloat *Pos);
	void	DrawTint(void);
	void	NextWeather(void);
	void	PreviousWeather(void);
	void	GetSky_top(byte *color);
	void	GetSky_bot(byte *color);
	void	GetDir(byte *color);
	void	GetAmb(byte *color);
	void	GetAmb_Obj(byte *color);
	void	GetSunCore(byte *color);
	void	GetSunCorona(byte *color);
	void	GetWaterColor(byte *color);
	void	GetTintColor(byte *color);
	void	GetLowCloudsRGB(byte *color);
	void	GetTopCloudRGB(byte *color);
	void	GetBottomCloudRGB(byte *color);
	void	SetLightModel(int);

	/* Not quite correct */
	GLfloat	GetFarClp(void);
	GLfloat	GetFogSt(void);
	GLfloat	GetSunSz(void);
	GLfloat GetSprSz(void);

	void	ReadWeatherData(void);
	int	GetWeatherSelector(void);
	void	SetSunPos(GLfloat x, GLfloat y, GLfloat z);
	void	UpdateSun(void);
	void	UpdateLight(void);
	void	Init(void);
	void	Dump(void);
	CSky(void);
	~CSky(void);
};

class CClock {
private:
	int	Hour;
	int	Minute;
public:
	void	Init(void);
	int	GetHour(void);
	int	GetMinute(void);
	void	SetHour(int h);
	void	SetMinute(int m);
	void	AdvanceOneMinute(void);
	void	AdvanceOneHour(void);
	void	TurnBackOneMinute(void);
	void	TurnBackOneHour(void);
};

class CWorld {
private:
	int	Interior;
	float	LODmultiplier;
	CWorldObj *ObjList;

	int	Index;

	Instance *GetLOD(Instance *Inst, vector<Instance *> &Iv);
	int	isCorrectLOD(Instance *Inst, float d);
public:
	void	Init(void);
	void	Draw(int DrawTransp);
//	void	BuildTree(void);
	void	SetInterior(int);
	int	GetInterior(void);
	void	SetLODmultiplier(float);
	float	GetLODmultiplier(void);

	CWorldObj *GetObjByID(int ID);
//	CWorldObj *GetLOD(CWorldObj *Obj);
	void	AddObj(CWorldObj *Obj);
	void	AddObjsFromFile(FILE *f);

	void	AddInstancesFromFile(FILE *file, char *Name);
	void	AddInstancesFromBinFile(FILE *file, vector<Instance *> &Iv);
	void	AddInstancesFromPlainFile(FILE *file, vector<Instance *> &Iv);
	void	AddInstance(Instance *);

	void	DumpObjs(void);
};

class CGame {
private:
	uint	Version;
	GLfloat WorldLimits[4];
	int	MinuteLength;
	bool	useTime;

public:
	void	Init(void);
	int	Load(int argc, char *argv[]);
	void	ParseDat(FILE *conf);
	uint	GetVersion(void);
	void	SetVersion(uint);
	void	SetWorldLimits(GLfloat, GLfloat, GLfloat, GLfloat);
	void	GetWorldLimits(GLfloat *v);
	void	SetMinuteLength(int);
	int	GetMinuteLength(void);
	void	SetTime(bool);
	void	ToggleTime();
	bool	UseTime();
	CGame();
	~CGame();
};

class CViewer {
private:
	CWorldObj *Obj;
	char	*txdpath;
	char	*dffpath;
public:
	int	Load(int argc, char *argv[]);
	void	Init(void);
	void	Draw(void);
};

extern CGame	Game;
extern CViewer	Viewer;
extern CGLView	GLView;
extern CWorld	World;
extern CCamera	Camera;
extern CDirectory Directory;
extern CFileLoader FileLoader;
extern CWater	Water;
extern CSky	Sky;
extern CClock	Clock;

extern int	ViewMode;

extern char	*progname;
extern char	*progdir;
extern bool	useGLEW;


extern GLfloat	planex;
extern GLfloat	planey;
extern GLfloat	planescale;

extern int carcol1ind, carcol2ind;

char *GetFileName(char *Path);
void CorrectPath(char *Path);
bool BindTexture(const char *texname);
bool BindTextureFromTxd(const char *TexName, const char *DictName);

void exiterror(const char *s, const char *t);
FILE *efopen(const char *FileName, const char *mode);
char *GetWordUp(char *line, char *word);
char *GetQuotedWordUp(char *line, char *word);
char *GetFloat(char *line, float *number);
char *GetInt(char *line, void *number);
char *GetRGB(char *line, byte *color);
char *GetRGBA(char *line, byte *color);
char *ReadConfigLine(FILE *file, char *buffer);
void MixColors(RwUInt8 *result, RwUInt8 *col1,
               RwUInt8 *col2, int ratio, int all);

bool isCulled(Instance *Inst);
bool isVisible(CWorldObj *Obj);
void TransformItem(Instance *Inst);
void DrawSprite(const char *DictName, const char *TexName, bool hasAlpha);

#endif