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

#include "ags/shared/ac/common.h"
#include "ags/shared/ac/game_version.h"
#include "ags/engine/ac/room_status.h"
#include "ags/shared/game/custom_properties.h"
#include "ags/engine/game/savegame_components.h"
#include "ags/shared/util/string_utils.h"
#include "ags/globals.h"

namespace AGS3 {

using namespace AGS::Shared;
using namespace AGS::Engine;

void HotspotState::ReadFromSavegame(Shared::Stream *in, int save_ver) {
	Enabled = in->ReadInt8() != 0;
	if (save_ver >= kRoomStatSvgVersion_36016) {
		Name = StrUtil::ReadString(in);
	}
}

void HotspotState::WriteToSavegame(Shared::Stream *out) const {
	out->WriteInt8(Enabled);
	StrUtil::WriteString(Name, out);
}

RoomStatus::RoomStatus() {
	contentFormat = kRoomStatSvgVersion_Current; // set current to avoid fixups
	beenhere = 0;
	numobj = 0;
	tsdatasize = 0;

	memset(&region_enabled, 0, sizeof(region_enabled));
	memset(&walkbehind_base, 0, sizeof(walkbehind_base));
	memset(&interactionVariableValues, 0, sizeof(interactionVariableValues));
}

RoomStatus::~RoomStatus() {}

void RoomStatus::FreeScriptData() {
	tsdata.clear();
	tsdatasize = 0;
}

void RoomStatus::FreeProperties() {
	roomProps.clear();
	for (int i = 0; i < MAX_ROOM_HOTSPOTS; ++i) {
		hsProps[i].clear();
	}
	objProps.clear();
}

void RoomStatus::ReadFromSavegame_v321(Stream *in, GameDataVersion data_ver) {
	FreeScriptData();
	FreeProperties();

	contentFormat = kRoomStatSvgVersion_Initial;
	obj.resize(MAX_ROOM_OBJECTS_v300);
	objProps.resize(MAX_ROOM_OBJECTS_v300);
	intrObject.resize(MAX_ROOM_OBJECTS_v300);

	beenhere = in->ReadInt32();
	numobj = in->ReadInt32();
	// NOTE: legacy format always contained max object slots
	for (auto &o : obj) {
		o.ReadFromSavegame(in, -1 /* legacy save with padding */);
	}

	in->Seek(MAX_LEGACY_ROOM_FLAGS * sizeof(int16_t)); // flagstates (OBSOLETE)
	in->ReadInt16(); // alignment padding to int32
	tsdatasize = static_cast<uint32_t>(in->ReadInt32());
	in->ReadInt32(); // tsdata
	for (int i = 0; i < MAX_ROOM_HOTSPOTS; ++i) {
		intrHotspot[i].ReadFromSavedgame_v321(in);
	}
	for (auto &intr : intrObject) {
		intr.ReadFromSavedgame_v321(in);
	}
	for (int i = 0; i < MAX_ROOM_REGIONS; ++i) {
		intrRegion[i].ReadFromSavedgame_v321(in);
	}
	intrRoom.ReadFromSavedgame_v321(in);
	for (size_t i = 0; i < MAX_ROOM_HOTSPOTS; ++i)
		hotspot[i].Enabled = in->ReadInt8() != 0;
	in->ReadArrayOfInt8((int8_t *)region_enabled, MAX_ROOM_REGIONS);
	in->ReadArrayOfInt16(walkbehind_base, MAX_WALK_BEHINDS);
	in->ReadInt16(); // alignment padding to int32 (66 int8 + 16 int16 = 49 int16 -> 50)
	in->ReadArrayOfInt32(interactionVariableValues, MAX_GLOBAL_VARIABLES);

	if (data_ver >= kGameVersion_340_4) {
		Properties::ReadValues(roomProps, in, true /* aligned */);
		for (int i = 0; i < MAX_ROOM_HOTSPOTS; ++i) {
			Properties::ReadValues(hsProps[i], in, true /* aligned */);
		}
		for (auto &props : objProps) {
			Properties::ReadValues(props, in, true /* aligned */);
		}
	}
}

void RoomStatus::ReadFromSavegame(Stream *in, GameDataVersion data_ver, RoomStatSvgVersion save_ver) {
	FreeScriptData();
	FreeProperties();

	beenhere = in->ReadInt8();
	numobj = static_cast<uint32_t>(in->ReadInt32());
	obj.resize(numobj);
	objProps.resize(numobj);
	intrObject.resize(numobj);
	for (uint32_t i = 0; i < numobj; ++i) {
		obj[i].ReadFromSavegame(in, save_ver);
		Properties::ReadValues(objProps[i], in);
		if (data_ver <= kGameVersion_272)
			SavegameComponents::ReadInteraction272(intrObject[i], in);
	}
	for (int i = 0; i < MAX_ROOM_HOTSPOTS; ++i) {
		hotspot[i].ReadFromSavegame(in, save_ver);
		Properties::ReadValues(hsProps[i], in);
		if (data_ver <= kGameVersion_272)
			SavegameComponents::ReadInteraction272(intrHotspot[i], in);
	}
	for (int i = 0; i < MAX_ROOM_REGIONS; ++i) {
		region_enabled[i] = in->ReadInt8();
		if (data_ver <= kGameVersion_272)
			SavegameComponents::ReadInteraction272(intrRegion[i], in);
	}
	for (int i = 0; i < MAX_WALK_BEHINDS; ++i) {
		walkbehind_base[i] = in->ReadInt32();
	}

	Properties::ReadValues(roomProps, in);
	if (data_ver <= kGameVersion_272) {
		SavegameComponents::ReadInteraction272(intrRoom, in);
		in->ReadArrayOfInt32(interactionVariableValues, MAX_GLOBAL_VARIABLES);
	}

	tsdatasize = static_cast<uint32_t>(in->ReadInt32());
	if (tsdatasize) {
		tsdata.resize(tsdatasize);
		in->Read(tsdata.data(), tsdatasize);
	}

	contentFormat = save_ver;
	if (save_ver >= kRoomStatSvgVersion_36041) {
		contentFormat = (RoomStatSvgVersion)in->ReadInt32();
		in->ReadInt32(); // reserved
		in->ReadInt32();
		in->ReadInt32();
	}
}

void RoomStatus::WriteToSavegame(Stream *out, GameDataVersion data_ver) const {
	out->WriteInt8(beenhere);
	out->WriteInt32(numobj);
	for (uint32_t i = 0; i < numobj; ++i) {
		obj[i].WriteToSavegame(out);
		Properties::WriteValues(objProps[i], out);
		if (data_ver <= kGameVersion_272)
			SavegameComponents::WriteInteraction272(intrObject[i], out);
	}
	for (int i = 0; i < MAX_ROOM_HOTSPOTS; ++i) {
		hotspot[i].WriteToSavegame(out);
		Properties::WriteValues(hsProps[i], out);
		if (data_ver <= kGameVersion_272)
			SavegameComponents::WriteInteraction272(intrHotspot[i], out);
	}
	for (int i = 0; i < MAX_ROOM_REGIONS; ++i) {
		out->WriteInt8(region_enabled[i]);
		if (data_ver <= kGameVersion_272)
			SavegameComponents::WriteInteraction272(intrRegion[i], out);
	}
	for (int i = 0; i < MAX_WALK_BEHINDS; ++i) {
		out->WriteInt32(walkbehind_base[i]);
	}

	Properties::WriteValues(roomProps, out);
	if (data_ver <= kGameVersion_272) {
		SavegameComponents::WriteInteraction272(intrRoom, out);
		out->WriteArrayOfInt32(interactionVariableValues, MAX_GLOBAL_VARIABLES);
	}

	out->WriteInt32(static_cast<int32_t>(tsdatasize));
	if (tsdatasize)
		out->Write(tsdata.data(), tsdatasize);

	// kRoomStatSvgVersion_36041
	out->WriteInt32(contentFormat);
	out->WriteInt32(0); // reserved
	out->WriteInt32(0);
	out->WriteInt32(0);
}

// Replaces all accesses to the roomstats array
RoomStatus *getRoomStatus(int room) {
	if (!_G(room_statuses)[room]) {
		// First access, allocate and initialise the status
		_G(room_statuses)[room].reset(new RoomStatus());
	}
	return _G(room_statuses)[room].get();
}

// Used in places where it is only important to know whether the player
// had previously entered the room. In this case it is not necessary
// to initialise the status because a player can only have been in
// a room if the status is already initialised.
bool isRoomStatusValid(int room) {
	return (_G(room_statuses)[room] != nullptr);
}

void resetRoomStatuses() {
	for (int i = 0; i < MAX_ROOMS; i++) {
		_G(room_statuses)[i].reset();
	}
}

} // namespace AGS3
