/* 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/>.
 *
 */

#ifndef AGS_ENGINE_GAME_SAVEGAME_INTERNAL_H
#define AGS_ENGINE_GAME_SAVEGAME_INTERNAL_H

#include "common/std/memory.h"
#include "common/std/vector.h"
#include "common/std/map.h"
#include "ags/shared/ac/common_defines.h"
#include "ags/shared/game/room_struct.h"
#include "ags/shared/gfx/bitmap.h"
#include "ags/engine/media/audio/audio_defines.h"

namespace AGS3 {
namespace AGS {
namespace Engine {

using AGS::Shared::Bitmap;
using AGS::Shared::Stream;

typedef std::shared_ptr<Bitmap> PBitmap;

// PreservedParams keeps old values of particular gameplay
// parameters that are saved before the save restoration
// and either applied or compared to new values after
// loading save data
struct PreservedParams {
	// Whether speech and audio packages available
	bool SpeechVOX = false;
	bool MusicVOX = false;
	// Game options, to preserve ones that must not change at runtime
	int GameOptions[GameSetupStructBase::MAX_OPTIONS]{};
	// Script global data sizes
	size_t GlScDataSize = 0u;
	std::vector<size_t> ScMdDataSize;

	PreservedParams();
};

// Audio playback state flags, used only in serialization
enum AudioSvgPlaybackFlags {
	kSvgAudioPaused = 0x01
};

enum GameViewCamFlags {
	kSvgGameAutoRoomView = 0x01
};

enum CameraSaveFlags {
	kSvgCamPosLocked = 0x01
};

enum ViewportSaveFlags {
	kSvgViewportVisible = 0x01
};

// RestoredData keeps certain temporary data to help with
// the restoration process
struct RestoredData {
	int                     FPS;
	// Unserialized bitmaps for dynamic surfaces
	std::vector<std::unique_ptr<Bitmap>> DynamicSurfaces;
	// Unserialized bitmaps for overlays (old-style saves)
	std::unordered_map<int, std::unique_ptr<Bitmap> > OverlayImages;
	// Scripts global data
	struct ScriptData {
		std::vector<char>	Data;
		size_t              Len;

		ScriptData();
	};
	ScriptData              GlobalScript;
	std::vector<ScriptData> ScriptModules;
	// Game state data (loaded ahead)
	uint32_t				DoOnceCount;
	// Room data (has to be be preserved until room is loaded)
	PBitmap                 RoomBkgScene[MAX_ROOM_BGFRAMES];
	int16_t                 RoomLightLevels[MAX_ROOM_REGIONS];
	int32_t                 RoomTintLevels[MAX_ROOM_REGIONS];
	int16_t                 RoomZoomLevels1[MAX_WALK_AREAS];
	int16_t                 RoomZoomLevels2[MAX_WALK_AREAS];
	RoomVolumeMod           RoomVolume;
	// Mouse cursor parameters
	int                     CursorID;
	int                     CursorMode;
	// General audio
	struct ChannelInfo {
		int ClipID = -1;
		int Flags = 0;
		int Pos = 0;
		int Priority = 0;
		int Repeat = 0;
		int Vol = 0;
		int VolAsPercent = 0;
		int Pan = 0;
		int Speed = 0;
		// since version 1
		int XSource = -1;
		int YSource = -1;
		int MaxDist = 0;
	};
	ChannelInfo             AudioChans[TOTAL_AUDIO_CHANNELS];
	// Ambient sounds
	int                     DoAmbient[MAX_GAME_CHANNELS];
	// Viewport and camera data, has to be preserved and applied only after
	// room gets loaded, because we must clamp these to room parameters.
	struct ViewportData {
		int ID = -1;
		int Flags = 0;
		int Left = 0;
		int Top = 0;
		int Width = 0;
		int Height = 0;
		int ZOrder = 0;
		int CamID = -1;
	};
	struct CameraData {
		int ID = -1;
		int Flags = 0;
		int Left = 0;
		int Top = 0;
		int Width = 0;
		int Height = 0;
	};
	std::vector<ViewportData> Viewports;
	std::vector<CameraData> Cameras;
	bool LegacyViewCamera = false;
	int32_t Camera0_Flags = 0; // flags for primary camera, when data is read in legacy order

	RestoredData();
};

enum PluginSvgVersion {
	kPluginSvgVersion_Initial = 0,
	kPluginSvgVersion_36115   = 1,
};

// Runs plugin events, requesting to read save data from the given stream.
// NOTE: there's no error check in this function, because plugin API currently
// does not let plugins report any errors when restoring their saved data.
void ReadPluginSaveData(Stream *in, PluginSvgVersion svg_ver, soff_t max_size);
// Runs plugin events, requesting to write save data into the given stream.
void WritePluginSaveData(Stream *out);

} // namespace Engine
} // namespace AGS
} // namespace AGS3

#endif