/* 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.
 *
 * 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/>.
 *
 *              Originally written by Syn9 in FreeBASIC with SDL
 *              http://syn9.thehideoutgames.com/index_backup.php
 *
 *            Ported to plain C for GCW-Zero handheld by Dmitry Smagin
 *                http://github.com/dmitrysmagin/griffon_legend
 *
 *
 *                 Programming/Graphics: Daniel "Syn9" Kennedy
 *                     Music/Sound effects: David Turner
 *
 *                   Beta testing and gameplay design help:
 *                    Deleter, Cha0s, Aether Fox, and Kiz
 *
 */

#ifndef GRIFFON_GRIFFON_H
#define GRIFFON_GRIFFON_H

#include "common/scummsys.h"
#include "common/error.h"
#include "common/events.h"
#include "common/random.h"
#include "engines/engine.h"

#include "audio/mixer.h"

#include "graphics/managed_surface.h"

namespace Griffon {

class Console;

#define kSoundHandles 16
#define kMaxNPC      32
#define kMaxFloat    32
#define kMaxSpell    32

// spells
enum {
	kSpellIce = 0,
	kSpellSteel,
	kSpellWood,
	kSpellRock,
	kSpellFire
};

// inventory items
enum {
	kInvFlask = 0,
	kInvDoubleFlask,
	kInvShock,
	kInvNormalKey,
	kInvMasterKey
};

enum {
	kSndBite = 0,
	kSndCrystal,
	kSndDoor,
	kSndEnemyHit,
	kSndIce,
	kSndLever,
	kSndLightning,
	kSndMetalHit,
	kSndPowerUp,
	kSndRocks,
	kSndSwordHit,
	kSndThrow,
	kSndChest,
	kSndFire,
	kSndBeep
};

//  in game scripts
enum {
	kScriptFlask = 0,			// get flask
	kScriptMasterKey = 2, 		// find master key
	kScriptFindCrystal = 3,		// find crystal
	kScriptFindShield = 4,		// find shield - obj 8
	kScriptFindSword = 5,		// find sword - obj 9
	kScriptKeyChest = 6,		// regular key chest
	kScriptBlueFlask = 7,		// blue flask
	kScriptGardenMasterKey = 8,	// garden's master key
	kScriptLightningBomb = 9,	// lightning bomb
	kScriptBlueFlaskChest = 10,	// blue flask chest
	kScriptLightningChest = 11,	// lightning chest
	kScriptArmourChest = 12,	// armour chest
	kScriptCitadelMasterKey = 13,	// citadel master key
	kScriptEndOfGame = 14,		// end of game
	kScriptGetSword3 = 15,		// get sword3
	kScriptShield3 = 16,		// shield3
	kScriptArmour3 = 17,		// armour3
	kScriptKeyChest1 = 20,		// key chest 1
	kScriptLever = 60			// lever
};

// monsters
enum {
	kMonsterBabyDragon = 1, 	// baby dragon
 	kMonsterOneWing = 2,		// one wing
 	kMonsterBoss1 = 3, 			// boss 1
 	kMonsterBlackKnight = 4,	// black knight
 	kMonsterFireHydra = 5,		// fire hydra
 	kMonsterRedDragon = 6,		// red dragon
 	kMonsterPriest = 7,			// priest
 	kMonsterYellowDragon = 8,	// yellow fire dragon
 	kMonsterTwoWing = 9,		// two wing
	kMonsterDragon2 = 10,		// dragon2
	kMonsterFinalBoss = 11,		// final boss
	kMonsterBatKitty = 12		// bat kitty
};

// engine actions
enum GriffonActions {
	kGriffonLeft,
	kGriffonRight,
	kGriffonUp,
	kGriffonDown,
	kGriffonAttack,
	kGriffonInventory,
	kGriffonMenu,
	kGriffonConfirm,
	kGriffonCutsceneSpeedUp
};

#define kEpsilon 0.001

struct Player {
	float   px;
	float   py;
	float   opx;
	float   opy;
	int     walkDir;
	float   walkFrame;
	float   walkSpeed;
	float   attackFrame;
	float   attackSpeed;

	int hp;
	int maxHp;
	float hpflash;
	int hpflashb;
	int level;
	int maxLevel;
	int sword;
	int shield;
	int armour;
	int foundSpell[5];
	float spellCharge[5];
	int inventory[5];
	float attackStrength;
	float spellStrength;
	int spellDamage;
	int swordDamage;

	int exp;
	int nextLevel;

	int pause;

	float itemselshade;
	int ysort;

	void reset();
};

struct BodySection {
	float   x;
	float   y;
	int parentID;
	int isbase;
	int sprite;
	int bonelength; // the 'bone' that connects the body sections
};

struct NPC {
	float x;
	float y;
	int spriteset;
	int x1;     // patrol area
	int y1;
	int x2;
	int y2;
	int attitude;
	int hp;

	int maxhp;
	int item1;
	int item2;
	int item3;
	int script;
	float frame;
	float frame2;     // end boss specific
	int cframe;
	bool onMap;      // is this npc set to be genned in the mapfile

	int ticks;
	int pause;
	int shake;

	int movementmode;
	int walkdir;
	float walkspd;
	int movingdir;
	bool moving;

	bool attacking;
	float attackframe;
	int cattackframe;
	float attackspd;
	int attackdelay;
	int attacknext;
	int attackattempt;

	int spellDamage;
	int attackDamage;


	// one wing and firehydra specific
	BodySection bodysection[31];
	float swayAngle;
	float swaySpeed;
	float headTargetX[4];
	float headTargetY[4];
	int castPause;

	// firehydra specific
	int attacknext2[4];
	bool attacking2[4];
	int attackframe2[4];

	// dragon2 specific
	float   floating;
};

struct Spell {
	int spellnum;
	float   homex;
	float   homey;
	float   enemyx;
	float   enemyy;

	float   frame;

	int damagewho;  // 0 = npc, 1 = player

	// for earthslide
	float   rocky[9]; // CHECKME: Looks unused
	int rockimg[9];
	int rockdeflect[9];

	float   strength;

	// fire
	int legalive[5];

	// spell 6 specific
	float   fireballs[7][4];    // x,y,targetx, targety
	int nfballs;
	int ballon[7];

	int npc;
};

struct AnimSet {
	int x;  // xyloc on spriteimageset
	int y;
	int xofs;   // the actual place to paste the sprite in reference to the bodypart loc on screen
	int yofs;
	int w;  // w/h of the sprite in the imageset
	int h;
};

struct DataChunk {
	byte *data;
	int size;
};

struct FloatTextStruct {
	float framesLeft;
	float x;
	float y;
	int col;
	char *text;
};

struct FloatIconStruct {
	float framesLeft;
	float x;
	float y;
	int ico;
};

struct AttackOffsetStruct {
	float x;
	float y;
	bool completed;
};

struct Config {
	bool music;
	int musicVol;
	bool effects;
	int effectsVol;
};

struct ObjectInfoStruct {
	int nFrames;
	int xTiles;
	int yTiles;
	int speed;
	int type;
	int script;
};

enum {
	kGameModeIntro,
	kGameModePlay,
	kGameModeNewGame,
	kGameModeLoadGame
};

class GriffonEngine : public Engine {
public:
	GriffonEngine(OSystem *syst);
	~GriffonEngine() override;

	Common::Error run() override;
	void syncSoundSettings() override;

private:
	Common::RandomSource *_rnd;
	bool _shouldQuit;
	int _gameMode;

	Console *_console;

private:

	// combat.cpp
	void attack();
	void castSpell(int spellnum, float homex, float homey, float enemyx, float enemyy, int damagewho);
	void checkHit();
	void damageNPC(int npcnum, int damage, int spell);
	void damagePlayer(int damage);

	// cutscenes.cpp
	void showLogos();
	void intro();
	void endOfGame();
	void theEnd();

	// dialogs.cpp
	void title(int mode);
	void configMenu();
	void saveLoadNew();
	void renderSaveStates();

	// draw.cpp
	void drawAnims(int Layer);
	void drawHud();
	void drawNPCs(int mode);
	void drawOver(int modx, int mody);
	void drawPlayer();
	void drawView();
	void swash();

	// engine.cpp
	float RND();

	void mainLoop();
	void updateEngine();
	void newGame();

	// gfx.cpp
	void addFloatIcon(int ico, float xloc, float yloc);
	void addFloatText(const char *stri, float xloc, float yloc, int col);
	void eventText(const char *stri);
	void drawLine(Graphics::ManagedSurface *buffer, int x1, int y1, int x2, int y2, int col);
	void drawString(Graphics::ManagedSurface *buffer, const char *stri, int xloc, int yloc, int col);
	void drawProgress(int w, int wm);

	// input.cpp
	void checkInputs();
	void handleWalking();
	void checkTrigger();
	void processTrigger(int trignum);

	// logic.cpp
	void updateAnims();
	void updateY();
	void updateNPCs();
	void updateSpells();
	void updateSpellsUnder();

	// resources.cpp
	void initialize();
	Graphics::ManagedSurface *loadImage(const char *name, bool colorkey = false);
	void loadMap(int mapnum);
	void loadAnims();
	void loadFont();
	void loadItemImgs();
	void loadTiles();
	void loadTriggers();
	void loadObjectDB();

	// saveload.cpp
	Common::String getSaveStateName(int slot) const override;
	int loadPlayer(int slotnum);
	Common::Error loadGameState(int slot) override;
	Common::Error saveGameState(int slot, const Common::String &desc, bool isAutosave = false) override;
	Common::Error loadGameStream(Common::SeekableReadStream *file) override;
	Common::Error saveGameStream(Common::WriteStream *file, bool isAutosave) override;

	// sound.cpp
	void setChannelVolume(int channel, int volume);
	int getSoundHandle();
	int playSound(DataChunk *chunk, bool looped = false);
	void pauseSoundChannel(int channel);
	void haltSoundChannel(int channel);
	void resumeSoundChannel(int channel);
	bool isSoundChannelPlaying(int channel);
	void setupAudio();
	void updateMusic();

	// Common engine overrides
	void pauseEngineIntern(bool pause) override;
	bool canLoadGameStateCurrently(Common::U32String *msg = nullptr) override { return true; }
	bool canSaveGameStateCurrently(Common::U32String *msg = nullptr) override { return _gameMode == kGameModePlay; }
	int getAutosaveSlot() const override { return 4; }
	bool hasFeature(EngineFeature f) const override;

private:
	Graphics::ManagedSurface *_video, *_videoBuffer, *_videoBuffer2, *_videoBuffer3;

	// system
	Graphics::ManagedSurface *_titleImg, *_titleImg2, *_inventoryImg;
	Graphics::ManagedSurface *_logosImg, *_theEndImg;
	Common::Event _event;

	Graphics::ManagedSurface *_mapBg, *_clipBg, *_clipBg2;
	unsigned int _clipSurround[4][4];

	float _animSpeed; // CHECKME: it seems to always be 0.5
	int _rampData[40][24];

	int _curMap;
	Graphics::ManagedSurface *_fontChr[224][5]; // 256 - 32
	Graphics::ManagedSurface *_itemImg[21], *_windowImg;
	Graphics::ManagedSurface *_spellImg;

	bool _itemSelOn;
	int _curItem, _itemTicks;
	float _itemyloc;
	bool _selEnemyOn;
	int _curEnemy;
	bool _forcePause;
	bool _roomLock; // set to disable any room jumps while in the room
	int _scriptFlag[100][10], _saveSlot;  // script, flag

	// timer related - move to local later
	int _ticks, _ticksPassed, _nextTicks, _ticksAtPauseStart;
	float _fp, _fps, _fpsr; // CHECKME: _fp and _fps seems to be integers
	int _secsInGame, _secStart;

	Graphics::ManagedSurface *mapImg[4];

	Common::Rect rcSrc, rcDest;

	// -----------special case
	bool _dontDrawOver;   // used in map24 so that the candles don't draw over the boss, default set to 0

	// saveload info
	Graphics::ManagedSurface *_saveLoadImg;

	// post info
	float _postInfo[21][3];
	int _postInfoNbr;

	// cloud info
	Graphics::ManagedSurface *_cloudImg;
	float _cloudAngle;
	int _cloudsOn;

	// spell info
	Spell _spellInfo[kMaxSpell];

	// player info
	Player _player;
	Player _playera;
	bool _movingUp, _movingDown, _movingLeft, _movingRight;
	bool _attacking;
	int _asecstart;

	// tile info
	Graphics::ManagedSurface *_tiles[4];
	int _tileinfo[3][40][24][3]; // maplayer, x, y, tiledata (tile, tilelayer)

	// animation info
	Graphics::ManagedSurface *_anims[100];
	// id number 0&1 = players
	Graphics::ManagedSurface *_animsAttack[100];
	// attack anims
	AttackOffsetStruct _playerAttackOfs[4][16];

	FloatTextStruct _floatText[kMaxFloat];
	FloatIconStruct _floatIcon[kMaxFloat];

	// special for animset2
	AnimSet _animSet2[7], _animSet9[7];

	// object info
	float _objectFrame[256][2];
	int _lastObj;
	// frame!, curframe
	ObjectInfoStruct _objectInfo[33];

	int _objectTile[33][9][3][3][2];
	// [objnum] [frame] [x] [y] [tile/layer]
	int _objectMap[21][15];

	int _objectMapFull[1000][21][15];
	// [mapnum] x, y  set to 1 to make this objmap spot stay at -1

	// trigger info
	int _triggers[10000][9];
	// [map#][index], [var]
	// map#,x,y
	int _triggerLoc[320][240], _triggerNbr;

	// npc info
	NPC _npcInfo[kMaxNPC];
	int _lastNpc;

	// music info
	DataChunk *_musicGardens1, *_musicGardens2, *_musicGardens3, *_musicGardens4, *_musicBoss, *_musicMenu, *_musicEndOfGame;
	int _musicChannel, _menuChannel;
	bool _playingBoss, _playingGardens;

	DataChunk *_sfx[15];
	Audio::SoundHandle _handles[kSoundHandles];
	Audio::Mixer *_mixer;

	// set to 1 for normal key, set to 2 for master, set to 0 if unlocked
	int _roomLocks[201], _lockType;
	int _roomToUnlock;

	bool _canUseKey;
	bool _saidLocked;
	bool _saidJammed;

	// ysort
	int _ysort[2401], _lasty, _firsty;

	bool _pmenu;

	Config config;
	void saveConfig();
};

}

#endif // GRIFFON_GRIFFON_H