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

#include "director/spriteinfo.h"

namespace Image {
class ImageDecoder;
}

namespace Graphics {
class ManagedSurface;
struct Surface;
}

namespace Common {
class ReadStreamEndian;
class MemoryReadStreamEndian;
class SeekableWriteStream;
}

namespace Director {

class Score;
class Sprite;
class TextCastMember;

enum {
	kMainChannelSizeD2 = 32,
	kSprChannelSizeD2 = 16,

	kMainChannelSizeD4 = 40,
	kSprChannelSizeD4 = 20,

	kMainChannelSizeD5 = 48,
	kSprChannelSizeD5 = 24,

	kMainChannelSizeD6 = 144,
	kSprChannelSizeD6 = 24,

	kMainChannelSizeD7 = 288,
	kSprChannelSizeD7 = 48,
};

struct PaletteInfo {
	CastMemberID paletteId;

	byte firstColor;
	byte lastColor;
	byte flags;
	bool colorCycling;
	bool normal;
	bool fadeToWhite;
	bool fadeToBlack;
	bool autoReverse;
	bool overTime;
	byte speed;
	uint16 frameCount;
	uint16 cycleCount;
	byte fade;
	byte delay;
	byte style;
	byte colorCode;

	uint32 spriteListIdx; // D6+
	SpriteInfo spriteInfo; // D6+

	PaletteInfo() {
		paletteId = CastMemberID(0, 0);
		firstColor = lastColor = 0;
		flags = 0; colorCycling = false;
		normal = false; fadeToWhite = false;
		fadeToBlack = false; autoReverse = false;
		overTime = false; speed = 0;
		frameCount = cycleCount = 0;
		fade = delay = style = colorCode = 0;
		spriteListIdx = 0;
	}
};

struct MainChannels {
	CastMemberID actionId;
	uint32 scriptSpriteListIdx; // D6+
	SpriteInfo scriptSpriteInfo; // D6+
	Common::Array<BehaviorElement> behaviors; // D6+

	uint16 transDuration;
	uint8 transArea; // 1 - Whole Window, 0 - Changing Area
	uint8 transChunkSize;
	TransitionType transType;
	CastMemberID trans;
	uint32 transSpriteListIdx; // D6+
	SpriteInfo transSpriteInfo; // D6+

	PaletteInfo palette;
	uint8 tempo;
	uint32 tempoSpriteListIdx; // D6+
	uint16 tempoCuePoint;
	SpriteInfo tempoSpriteInfo; // D6+

	uint8 scoreCachedTempo;
	CastMemberID scoreCachedPaletteId;

	CastMemberID sound1;
	uint8 soundType1;
	uint32 sound1SpriteListIdx; // D6+
	SpriteInfo sound1SpriteInfo; // D6+
	CastMemberID sound2;
	uint8 soundType2;
	uint32 sound2SpriteListIdx; // D6+
	SpriteInfo sound2SpriteInfo; // D6+

	byte colorTempo;
	byte colorSound1;
	byte colorSound2;
	byte colorScript;
	byte colorTrans;

	uint8 skipFrameFlag;
	uint8 blend;

	MainChannels() {
		scriptSpriteListIdx = 0;

		transDuration = 0;
		transArea = 0;
		transChunkSize = 0;
		transType = kTransNone;
		transSpriteListIdx = 0;

		tempo = 0;
		tempoSpriteListIdx = 0;
		tempoCuePoint = 0;

		scoreCachedTempo = 0;

		soundType1 = 0;
		sound1SpriteListIdx = 0;

		soundType2 = 0;
		sound2SpriteListIdx = 0;

		colorTempo = 0;
		colorSound1 = 0;
		colorSound2 = 0;
		colorScript = 0;
		colorTrans = 0;

		skipFrameFlag = 0;
		blend = 0;
	}
};

struct FrameEntity {
	uint16 spriteId;
	Common::Rect rect;
};


class Frame {
public:
	Frame(Score *score, int numChannels);
	Frame(const Frame &frame);
	~Frame();

	void reset();

	Score *getScore() const { return _score; }

	void readChannel(Common::MemoryReadStreamEndian &stream, uint16 offset, uint16 size, uint16 version);
	void writeMainChannels(Common::SeekableWriteStream *writeStream, uint16 version);

	void executeImmediateScripts();

	Common::String formatChannelInfo();

private:

	void readChannelD2(Common::MemoryReadStreamEndian &stream, uint16 offset, uint16 size);
	void readSpriteD2(Common::MemoryReadStreamEndian &stream, uint16 offset, uint16 size);
	void readMainChannelsD2(Common::MemoryReadStreamEndian &stream, uint16 offset, uint16 size);

	void readChannelD4(Common::MemoryReadStreamEndian &stream, uint16 offset, uint16 size);
	void readSpriteD4(Common::MemoryReadStreamEndian &stream, uint16 offset, uint16 size);
	void readMainChannelsD4(Common::MemoryReadStreamEndian &stream, uint16 offset, uint16 size);

	void writeMainChannelsD4(Common::SeekableWriteStream *writeStream);

	void readChannelD5(Common::MemoryReadStreamEndian &stream, uint16 offset, uint16 size);
	void readSpriteD5(Common::MemoryReadStreamEndian &stream, uint16 offset, uint16 size);
	void readMainChannelsD5(Common::MemoryReadStreamEndian &stream, uint16 offset, uint16 size);

	void writeMainChannelsD5(Common::SeekableWriteStream *writeStream);

	void readChannelD6(Common::MemoryReadStreamEndian &stream, uint16 offset, uint16 size);
	void readSpriteD6(Common::MemoryReadStreamEndian &stream, uint16 offset, uint16 size);
	void readMainChannelsD6(Common::MemoryReadStreamEndian &stream, uint16 offset, uint16 size);

	void writeMainChannelsD6(Common::SeekableWriteStream *writeStream);

	void readChannelD7(Common::MemoryReadStreamEndian &stream, uint16 offset, uint16 size);
	void readSpriteD7(Common::MemoryReadStreamEndian &stream, uint16 offset, uint16 size);
	void readMainChannelsD7(Common::MemoryReadStreamEndian &stream, uint16 offset, uint16 size);

	void writeMainChannelsD7(Common::SeekableWriteStream *writeStream);

	Image::ImageDecoder *getImageFrom(uint16 spriteId);
	Common::String readTextStream(Common::SeekableReadStreamEndian *textStream, TextCastMember *textCast);


public:
	int _numChannels;
	MainChannels _mainChannels;
	Common::Array<Sprite *> _sprites;
	Score *_score;
	DirectorEngine *_vm;
};

void readSpriteDataD2(Common::SeekableReadStreamEndian &stream, Sprite &sprite, uint32 startPosition, uint32 finishPosition);
void readSpriteDataD4(Common::SeekableReadStreamEndian &stream, Sprite &sprite, uint32 startPosition, uint32 finishPosition);
void readSpriteDataD5(Common::SeekableReadStreamEndian &stream, Sprite &sprite, uint32 startPosition, uint32 finishPosition);
void readSpriteDataD6(Common::SeekableReadStreamEndian &stream, Sprite &sprite, uint32 startPosition, uint32 finishPosition);
void readSpriteDataD7(Common::SeekableReadStreamEndian &stream, Sprite &sprite, uint32 startPosition, uint32 finishPosition);

void writeSpriteDataD4(Common::SeekableWriteStream *writeStream, Sprite &sprite);
void writeSpriteDataD5(Common::SeekableWriteStream *writeStream, Sprite &sprite);
void writeSpriteDataD6(Common::SeekableWriteStream *writeStream, Sprite &sprite);
void writeSpriteDataD7(Common::SeekableWriteStream *writeStream, Sprite &sprite);

} // End of namespace Director

#endif