#ifndef INSTRUCTION_H_
#define INSTRUCTION_H_

#include <vector>

#include "evaluator.h"
#include "register_address.h"

class emulator;

class instruction {

public:
	instruction(
		const char * name,
		evaluator * evaluator,
		std::vector<register_address> dst,
		unsigned int src_reg_count);
	virtual void execute(emulator & emulator);
	virtual void add_src_reg(std::vector<register_address> src_reg);

protected:
	const char * m_name;
	evaluator * m_evaluator;
	std::vector<register_address> m_dst;
	std::vector<std::vector<register_address> > m_src_regs;
	unsigned int m_src_reg_count;
};

class add_instruction : public instruction {
public:
	add_instruction(
		std::vector<register_address> dst,
		std::vector<register_address> src0,
		std::vector<register_address> src1);

	add_instruction(std::vector<register_address> dst);
	void execute(emulator & emulator);
private:
	std::vector<register_address> m_src0;
	std::vector<register_address> m_src1;
};

class mov_instruction : public instruction {
public:
	mov_instruction(std::vector<register_address> dst);
	void execute(emulator & emulator);
};

class mul_instruction : public instruction {
public:
	mul_instruction(std::vector<register_address> dst);
	void execute(emulator & emulator);
};

/**
 * dst = src0 * src1 + src2
 */
class mad_instruction : public instruction {
public:
	mad_instruction(std::vector<register_address> dst);
	void execute(emulator & emulator);
};

class abs_instruction : public instruction {
public:
	abs_instruction(std::vector<register_address> dst);
};

class sub_instruction : public instruction {
public:
	sub_instruction(std::vector<register_address> dst);
};

class sat_instruction : public instruction {
public:
	sat_instruction(std::vector<register_address> dst);
};

class rcp_instruction : public instruction {
public:
	rcp_instruction(std::vector<register_address> dst);
};

class min_instruction : public instruction {
public:
	min_instruction(std::vector<register_address> dst);
};

class max_instruction : public instruction {
public:
	max_instruction(std::vector<register_address> dst);
};

class dp_instruction : public instruction {
public:
	dp_instruction(
		unsigned int components,
		std::vector<register_address> dst);
	void execute(emulator & emulator);
private:
	unsigned int m_components;
};

#endif //INSTRUCTION_H_