/* 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_OPTIONS_MANAGER_PC_H_INCLUDED
#define ICB_OPTIONS_MANAGER_PC_H_INCLUDED

#include "engines/icb/p4.h"
#include "engines/icb/global_objects.h"
#include "engines/icb/global_switches.h"
#include "engines/icb/sound/fx_manager.h"
#include "engines/icb/sound/speech_manager.h"
#include "engines/icb/sound/music_manager.h"
#include "engines/icb/sound.h"
#include "engines/icb/direct_input.h"

namespace ICB {

class MovieManager;
extern MovieManager *g_personalSequenceManager;

#define MAX_BYTESIZE_OF_CREDITS_FILE (8 * 1024)

class Crediter {
private:
	uint8 m_theData[MAX_BYTESIZE_OF_CREDITS_FILE];
	char *m_creditsFile;
	int32 m_numberOfBytes;

	int32 m_endOfCredits;

	int32 m_currentHeight;
	uint32 m_cursor;
	int32 m_scrollOffset;

	uint32 m_logoSurfaceID;
	int32 m_logoDraw;
	bool8 m_logoAttached;

	uint32 m_movieSurfaceID;
	LRECT m_movieRect;
	bool8 m_movieBackdrop;

	bool8 m_loopingMovie;
	int32 m_frameStart;
	int32 m_totalMovieFrames;

public:
	Crediter();
	void Initialise(const char *textFileName, const char *movieFileName, bool8 loopingMovie, bool8 attachLogo, int32 frameStart);
	int32 DoScreen();
};

// Global options controller
class OptionsManager;
extern OptionsManager *g_theOptionsManager;

// Type to describe every menu in the entire game
enum _MENU_ {
	INGAME_TOP,
	INGAME_OPTIONS,
	INGAME_AUDIO,
	INGAME_VIDEO,
	INGAME_SAVE,
	INGAME_SAVECONFIRM,
	INGAME_LOAD,
	INGAME_CONTROLS,
	INGAME_QUIT,

	MAIN_TOP,
	MAIN_LOAD,
	MAIN_OPTIONS,
	MAIN_AUDIO,
	MAIN_VIDEO,
	MAIN_CONTROLS,
	MAIN_EXTRAS,
	MAIN_MOVIES,
	MAIN_PLAYSELECT,
	MAIN_PROFILES,
	MAIN_QUIT,

	MAIN_A_PROFILE,

	GAME_OVER,
	DEAD_LOAD,
	DEAD_QUIT
};

#define NUMBER_OF_IN_GAME_TOP_CHOICES 5

enum IN_GAME_TOP_CHOICES { CONTINUE = 0, SAVE_GAME = 1, LOAD_GAME = 2, OPTIONS = 3, QUIT = 4 };

#define NUMBER_OPTION_CHOICES 4

enum OPTION_CHOICES {
	VIDEO_SETTINGS = 0,
	AUDIO_SETTINGS = 1,
	CONTROLS = 2,
	DO_BACK = 3
};

#define NUMBER_OF_AUDIO_CHOICES 4

enum AUDIO_CHOICES {
	MUSIC_VOLUME = 0,
	SPEECH_VOLUME = 1,
	SFX_VOLUME = 2,
	DO_ONE = 3
};

#define NUMBER_OF_VIDEO_CHOICES 4

enum VIDEO_CHOICES {
	SUBTITLES = 0,
	SHADOWS = 1,
	FRAMELIMITER = 2,
	LEAVE = 3
};

#define NUMBER_OF_CONTROL_CHOICES 2

enum CONTROL_CHOICES {
	METHOD = 0,
	DONE = 1
};

#define TOTAL_NUMBER_OF_GAME_SLOTS 100
#define NUMBER_OF_VISIBLE_GAME_SLOTS 4
#define NUMBER_OF_GAMESLOT_CHOICES 5

enum GAMESLOT_CHOICES {
	SLOT1 = 0,
	SLOT2 = 1,
	SLOT3 = 2,
	SLOT4 = 3,
	RETURN = 4
};

#define NUMBER_OF_SAVECONFIRM_CHOICES 2

enum SAVECONFIRM_CHOICES { YEY = 0, NAY = 1 };

#define NUMBER_OF_QUIT_CHOICES 2

enum QUIT_CHOICES { YES = 0, NO = 1 };

#define NUMBER_OF_MAIN_TOP_CHOICES 5

enum MAIN_TOP_CHOICES {
	_NEWGAME = 0,
	_LOAD_GAME = 1,
	_OPTIONS = 2,
	_EXTRAS = 3,
	_EXIT_GAME = 4
};
#define NUMBER_OF_EXTRA_CHOICES 6

enum M_EXTRA_CHOICES {
	MOVIES = 0,
	SLIDESHOW = 1,
	PLAYSELECT = 2,
	PROFILES = 3,
	CREDITS = 4,
	ALLDONE = 5
};
//-----------------------------------------------------------------------
#define NUMBER_OF_PLAYSELECT_CHOICES 10

enum M_PLAYSELECT_CHOICES {
	M01 = 0,
	M02 = 1,
	M03 = 2,
	M04 = 3,
	M05 = 4,
	M07 = 5,
	M08 = 6,
	M09 = 7,
	M10 = 8,
	CANCEL = 9
};
//-----------------------------------------------------------------------
#define TOTAL_NUMBER_OF_MOVIES 47
#define M_NUMBER_OF_VISIBLE_MOVIE_SLOTS 12
#define M_NUMBER_OF_MOVIE_CHOICES 13

enum M_MOVIE_CHOICES {
	MOVIE01 = 0,
	MOVIE02 = 1,
	MOVIE03 = 2,
	MOVIE04 = 3,
	MOVIE05 = 4,
	MOVIE06 = 5,
	MOVIE07 = 6,
	MOVIE08 = 7,
	MOVIE09 = 8,
	MOVIE10 = 9,
	MOVIE11 = 10,
	MOVIE12 = 11,
	NOTHANKS = 12, // Excluded from name display if greater than this
	PAGELEFT = 13,
	PAGERIGHT = 14
};
#define M_NUMBER_OF_PROFILE_CHOICES 11

enum M_PROFILES_CHOICES {
	CORD = 0,
	CHI = 1,
	GREGOR = 2,
	NAGAROV = 3,
	LUKYAN = 4,
	KEIFFER = 5,
	TOLSTOV = 6,
	ALEXANDRA = 7,
	OLIAKOV = 8,
	SPECTRE = 9,
	RET = 10
};
#define NUMBER_OF_GAMEOVER_CHOICES 3

enum GAMEOVER_CHOICES { RESTORE = 0, RESTART = 1, GAMEOVER = 2 };

#define MAX_LABEL_LENGTH 24

typedef struct {
	char label[MAX_LABEL_LENGTH];
	uint32 secondsPlayed;

} _SLOT;

typedef struct {
	char filename[MAX_LABEL_LENGTH];
	bool8 visible;

} _MOVIESLOT;

// These initialised from a saved game and switched when movies are played
extern _MOVIESLOT g_movieLibrary[TOTAL_NUMBER_OF_MOVIES];

// Anti-aliased support provided for these coloured fonts (DisplayText)
#define NORMALFONT 0x0000
#define SELECTEDFONT 0x0001
#define PALEFONT 0x0002

class OptionsManager {
	friend class Crediter;

private:
	bool8 m_inGame;        // In-game or title screen flag
	bool8 m_useDirtyRects; // For increased speed over a static background
	bool8 m_gameover;      // Game Over flag
	bool8 m_haveControl;   // OptionsManager active flag
	bool8 m_thatsEnoughTa; // Quit flag

	int32 m_autoAnimating; // Animating flags
	int32 m_autoAnimating2;
	LRECT m_optionsBox;       // Top level screen bounding box
	int32 m_over_n_Frames;    // Animating variable
	int32 m_grower;           // Animating variable
	uint32 m_lipLength;       // Length of top-level box lips
	LRECT m_box;              // Animating variable
	LRECT m_targetBox;        // Child screen title box
	int32 m_interFrames;      // Animating variable
	int32 m_widthIncrements;  // Animating variable
	int32 m_bottomIncrements; // Animating variable
	int32 m_topIncrements;    // Animating variable
	bool8 m_warpDirection;    // Direction of animation

	char m_fontName[ENGINE_STRING_LEN]; // Bitmap font handling
	_pxBitmap *m_font_file;
	uint32 *m_fontPalette;
	uint32 m_fontHeight;
	_pxPCSprite *m_currentSprite;
	_rgb m_selectedShade;
	LinkedDataFile *m_global_text;

	_rgb m_drawColour; // Current primitive drawing colour

	_MENU_ m_activeMenu; // Active menu identifier

	_SLOT *m_slots[TOTAL_NUMBER_OF_GAME_SLOTS]; // Save slot pointers
	uint32 m_slotOffset;                        // Offset to current slot page
	uint32 m_movieOffset;                       // Offset to current movie page

	// Which option is selected for the main choices
	MAIN_TOP_CHOICES m_M_TOP_selected;
	M_EXTRA_CHOICES m_M_EXTRA_selected;
	M_MOVIE_CHOICES m_M_MOVIE_selected;
	M_PLAYSELECT_CHOICES m_M_PLAYSELECT_selected;
	M_PROFILES_CHOICES m_M_PROFILES_selected;

	// Which option is selected for the in-game choices
	IN_GAME_TOP_CHOICES m_IG_TOP_selected;

	// Generic chosers used in both option screens
	OPTION_CHOICES m_OPTION_selected;
	VIDEO_CHOICES m_VIDEO_selected;
	AUDIO_CHOICES m_AUDIO_selected;
	CONTROL_CHOICES m_CONTROL_selected;
	GAMESLOT_CHOICES m_GAMESLOT_selected;
	SAVECONFIRM_CHOICES m_SAVECONFIRM_selected;
	QUIT_CHOICES m_QUIT_selected;
	GAMEOVER_CHOICES m_GAMEOVER_selected;

	// Extra temporary direct draw surfaces to work with
	uint32 m_myScreenSurfaceID;
	uint32 m_mySlotSurface1ID;
	uint32 m_thumbSurfaceIDs[8];
	uint32 m_grayThumbSurfaceIDs[8];
	uint32 m_movieSurfaceIDs[24];
	uint32 m_grayMovieSurfaceIDs[24];
	uint32 m_profileSurface;

	LRECT m_fullscreen; // Useful rectangle
	LRECT m_movieRect;  // Paging rectangle
	uint32 m_colourKey; // Blitting colour key

	bool8 m_moveLimiter;        // Vertical input flag
	bool8 m_alterLimiter;       // Horizontal input flag
	bool8 m_choiceLimiter;      // Select input flag
	bool8 m_controlPage1;       // Control screen page indicator
	uint32 m_controlAnimCursor; // Animation sequence position

	int32 m_move_sfx_channel;   // Audio channel for move sfx
	int32 m_choose_sfx_channel; // Audio channel for select sfx

	bool8 m_canSave; // Is save disabled in game

	// Edit label buffer position
	uint32 m_cursorPos;
	char m_editBuffer[MAX_LABEL_LENGTH];
	char m_defaultSlotName[MAX_LABEL_LENGTH];
	bool8 m_editing;
	bool8 m_defaultWiper;
	int32 m_emptySlotFlag;

	uint32 m_timePlayed;

	// For animating and handling slot pages
	bool8 m_paging;              // Are we currently paging (animating)
	bool8 m_pageleft;            // Left or right paging
	LRECT m_slotBoundingRect;    // Box containing the 10 visible slots
	int32 m_slotsAnimOffBy;      // Animation step incrementer
	LRECT m_pageOn_from;         // Source blit rect for slots entering the screen
	LRECT m_pageOn_dest;         // Target blit rect for slots entering the screen
	LRECT m_pageOff_from;        // Source blit rect for slots leaving the screen
	LRECT m_pageOff_dest;        // Target blit rect for slots leaving the screen
	bool8 m_letJoystickQuitEdit; // Flag to restrain joystick presses

	bool8 m_awaitingKeyPress; // For control assignment
	bool8 m_configLimiter;
	int32 m_assignFlash;

	bool8 m_creditControl; // Credits displaying flag
	Crediter m_crediter;   // Crediter class instance

	bool8 m_slideshowActive; // Slideshow active flag
	bool8 m_slideLimiter;    // Slideshow variables
	int32 m_currentSlide;
	int32 m_slideWadger;
	uint32 m_slideFillColour;

	uint32 m_margin; // Profile screen variables
	LRECT m_profileRect;
	int32 m_profileScrollingOffset;
	int32 m_profileScrollingLine;
	bool8 m_lastLineDisplayed;
	int32 m_profileScrolling;

public:
	OptionsManager();  // Constructor
	~OptionsManager(); // Destructor

	// Initialise menu functions
	void StartInGameOptions();
	void StartMainOptions();
	void StartGameOverOptions();

	// Cycle
	void CycleLogic();

	// Force screen refresh
	void ForceInGameScreenRefresh();

	// Enquire as to present status
	bool8 HasControl() { return m_haveControl; }

	// Public access routines
	void DoCredits();
	void InitialiseScrollingText(const char *textFileName, const char *movieFileName, int32 frameStart);
	void DoScrollingText();
	void DisplayText(uint8 *ad, uint32 pitch, const char *str, int32 x, int32 y, uint32 col, bool8 centredHorizontally, bool8 boxed = FALSE8);
	const char *GetTextFromReference(uint32 hashRef);
	uint32 CalculateStringWidth(const char *str);
	void UnlockMovies();

private:
	// Logic
	void CycleInGameOptionsLogic();
	void CycleMainOptionsLogic();
	void CycleGameOverLogic();
	void InitialiseInGameOptions();
	void MoveSelected(bool8 _down_);
	void AlterSelected(bool8 _right_);
	void DoChoice();
	void OnEscapeKey();

	// Input
	void PollInput();

	// Graphics handling
	void MakeAllSurfii();
	void KillAllSurfii();

	void SetDrawColour(uint32 def);
	void DrawRectangle(bool8 selected, uint32 x, uint32 y, uint32 width, uint32 height, uint8 *surface_address, uint32 pitch);
	void DarkenScreen();
	void BloodScreen();
	void SetDesiredOptionsBoxParameters(uint32 width, uint32 height, uint32 nFrames);
	void SetTargetBox(uint32 x1, uint32 x2, uint32 y1, uint32 y2, uint32 nFrames);
	bool8 AnimateThoseBrackets(bool8 forwards);
	bool8 AnimateBracketsToBox(bool8 forwards, uint32 surface_id = working_buffer_id);
	void AnimateSlotsPaging();
	void GrabThumbnailImage();
	void LoadVisibleThumbnails();
	void LoadPagingThumbnails(uint32 slotOffset);
	void MakeGrayScaleThumbnail(uint32 src_surface_id, uint32 dst_surface_id, uint32 w = 64, uint32 h = 48);
	void LoadVisibleMovieShots();
	void LoadPagingMovieShots(uint32 slotOffset);
	void DrawWidescreenBorders();
	void DrawPageIndicator(uint32 x, uint32 y, bool8 up, bool8 selected, uint8 *ad, uint32 pitch);
	void FadeStrip(uint32 x, uint32 y, uint32 w, bool8 up, uint8 *ad, uint32 pitch);

	// Screen drawing functions
	void DrawMainOptionsScreen(uint32 surface_id);
	void DrawInGameOptionsScreen();
	void DrawGameOverScreen();
	void DrawGameSlots(uint32 slotOffset, uint32 surface_id = working_buffer_id);
	void DrawMovieSlots(uint32 offset, uint32 surface_id = working_buffer_id);
	void DrawGameOptions();
	void DrawAudioSettings();
	void DrawVideoSettings();
	void DrawControllerConfiguration();
	void DrawMainLoadScreen(uint32 surface_id = working_buffer_id);
	void DrawMovieScreen(uint32 surface_id = working_buffer_id);
	void DrawQuitGameConfirmScreen(uint32 surface_id = working_buffer_id);
	void DrawExtrasScreen(uint32 surface_id = working_buffer_id);
	void DrawPlaySelectScreen(uint32 surface_id = working_buffer_id);
	void DrawSlideShow();
	void DrawProfileSelectScreen(uint32 surface_id = working_buffer_id);
	void DrawProfileScreen(uint32 surface_id = working_buffer_id);
	void DrawOverwriteSaveConfirmScreen(uint32 surface_id = working_buffer_id);

	// Screen initialising functions
	void InitialiseControlsScreen();
	void InitialiseSlideShow();
	void InitialiseAProfile();

	// Slot management
	void InitialiseSlots();
	void DestroySlots();

	// Assign control functions
	void EditSlotLabel();
	bool8 VerifyLabel();
	void GetKeyAssignment();

	// Font handling
	void LoadBitmapFont();
	void LoadGlobalTextFile();
	bool8 SetCharacterSprite(char c);
	void RenderCharacter(uint8 *ad, uint32 pitch, int32 nX, int32 nY, uint32 col);
	void GetCentredRectFotText(const char *str, LRECT &r, int32 height);

	// Option screen sound functions
	void InitialiseSounds();
	void PlayMoveFX();
	void PlayChosenFX();

	// For the movie library
	void PlayMovie(uint32 id);

	// Title screen movie backdrop
	void LoadTitleScreenMovie();
	void UnloadTitleScreenMovie();
};

} // End of namespace ICB

#endif