/* "Species" - a CoreWars evolver.  Copyright (C) 2003 'Varfar' 
 *
 * 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 1, 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, write to the Free Software Foundation, Inc.,
 * 675 Mass Ave, Cambridge, MA 02139, USA. 
 */

#include "inst_gen_markov.hpp"
#include "species.hpp"
#include "exhaust.hpp"

#include "opcode_branch_lookup.hpp"
#include "rand.hpp"

using namespace std;

/******* CInstGeneratorMarkov implementation *********************/

const float CInstGeneratorMarkov::DEFAULT_DAT = 0.1F; // 10%

CInstGeneratorMarkov::CInstGeneratorMarkov() {
	_type = MARKOV; // important line!
	CORESIZE = 0;
	opcodes = 0;
	opcode = 0;
	opcode_modifiers = 0;
	readonly = true;
	_filename = "<none>";
}

CInstGeneratorMarkov::~CInstGeneratorMarkov() {
	clear();
	readonly = true;
}

void CInstGeneratorMarkov::write_ini(ostream &os) {
	os << "inst_gen=" << impl_desc(type()) << endl;
	os << "markov_file=" << _filename << endl;
	if(DEFAULT_DAT != _dat)
		os << "markov_dats=" << _dat << endl;
}

void CInstGeneratorMarkov::write_override_ini(ostream &os,const CInstGenerator *parent) {
	if(parent == this) // nothing to do?
		return;
	os << "inst_gen=" << impl_desc(type()) << endl;
	if(same_type(this,parent)) {
		if(((CInstGeneratorMarkov*)parent)->_filename != _filename) { 
			os << "markov_file=" << _filename << endl;
			os << "markov_dats=" << _dat << endl;
		} else
			if(((CInstGeneratorMarkov*)parent)->_dat != _dat) // overriden?
				os << "markov_dats=" << _dat << endl;
	} else {
		if(DEFAULT_DAT != _dat)
			os << "markov_dats=" << _dat << endl;
	}
}

void CInstGeneratorMarkov::read_ini_impl(INIFile &ini) {
	KeyValuePair *kvp;
	kvp = ini.get("markov_file"); if(0 == kvp) PANIC(MISC,"markov_file key expected",NULL); // null?!
	kvp->getValueAsString(_filename);
	load(_filename.c_str());
	kvp = ini.get("markov_dats"); 
	if(0 != kvp) {
		_dat = kvp->getValueAsFloat(DEFAULT_DAT);
		if((0.0F > _dat) || (1.0F <= _dat)) PANIC(MISC,"markov_dat must be between 0.0 and 1.0",NULL);
	} else
		_dat = DEFAULT_DAT;
}

CInstGenerator *CInstGeneratorMarkov::read_override_ini_impl(INIFile &ini) {
	string filename;
	CInstGeneratorMarkov *ret = this;
	KeyValuePair *kvp;
	kvp = ini.get("markov_file");
	if(0 != kvp) { // specified?
		kvp->getValueAsString(filename);
		if(_filename != filename) {
			ret = new CInstGeneratorMarkov();
			ret->read_ini_impl(ini);
		}
	} 
	kvp = ini.get("markov_dats"); 
	if(0 != kvp) {
		float dat = kvp->getValueAsFloat(DEFAULT_DAT);
		if(dat != ret->_dat) {
			ret = new CInstGeneratorMarkov(*this);
			ret->_dat = dat;
			if((0.0F > ret->_dat) || (1.0F <= ret->_dat)) PANIC(MISC,"markov_dat must be between 0.0 and 1.0",NULL);
		}
	}
	return ret;
}

unsigned CInstGeneratorMarkov::opcode_modifier_2_index(const unsigned opcode_modifier) const {
	//TODO: binary search?  this is sorted btw..
	for(unsigned i=0; i<opcodes; i++) {
		if(opcode_modifier == opcode[i].key.get_opcode_modifier())
			return i;
	}
	return INVALID_INDEX;
}

unsigned CInstGeneratorMarkov::suggest_opcode_modifier() const { // returns an index
	const unsigned TARGET = CRand::irand(opcode_modifiers);
	unsigned y = 0;
	for(unsigned x = 0; x < opcodes; x++) {
		y += opcode[x].key.get_count();
		if(TARGET < y) {
			return x;
		}
	}
	PANIC(MISC,"roulette off end of markov opcodes",NULL);
}

unsigned CInstGeneratorMarkov::CFreq::suggest_opcode_modifier() const {
	if(0 == opcode_modifiers) return INVALID_INDEX;
	const unsigned TARGET = CRand::irand(opcode_modifiers);
	unsigned y = 0;
	for(unsigned x = 0; x < markovs; x++) {
		y += markov[x].get_count();
		if(TARGET < y) {
			return x;
		}
	}
	cout << MNEMONIC_OPCODE(key.get_opcode()) << '.' << MNEMONIC_MODIFIER(key.get_modifier()) << ": target = " << TARGET << ", opcode_modififers = " << opcode_modifiers << ", y = " << y << ", markovs = " << markovs << endl;
	PANIC(MISC,"roulette off end of markovs",NULL);
}

bool CInstGeneratorMarkov::dat() const { // test that this can be a dat
	return (index() > 0) && (_dat >= CRand::frand(1.0F));
}

void CInstGeneratorMarkov::suggest_instruction(insn_t &instruction,const MODE /*mode*/) {
	instruction.in = 0;
	unsigned prev = INVALID_INDEX, curr = INVALID_INDEX, opmod = INVALID_INDEX;
	if((index() > 0) && (index() < chromosome()->len()))
		prev = opcode_modifier_2_index(chromosome()->code(index()-1).opcode_modifier());
	if(INVALID_INDEX != prev) {
		opmod = opcode[prev].suggest_opcode_modifier(); // is index
		if(INVALID_INDEX != opmod)
			opmod = opcode[prev].markov[opmod].get_opcode_modifier(); // to actual opcode/modifier
	}
	if(INVALID_INDEX == opmod) {
		opmod = opcode[suggest_opcode_modifier()].key.get_opcode_modifier();
	}
	instruction.set_opcode_modifier(opmod);
	curr = opcode_modifier_2_index(opmod);
	if(INVALID_INDEX != curr) {
		//cout << MNEMONIC_OPCODE(instruction.opcode()] << '.' << MNEMONIC_MODIFIER[instruction.modifier()] << " is known" << endl;
		// set appropriate values
		instruction.set_addrmode_a((ADDRMODE)opcode[curr].addrmode_a.suggest());
		instruction.set_addrmode_b((ADDRMODE)opcode[curr].addrmode_b.suggest());
		chromosome()->type()->operands()->rnd(instruction,COperand::A);
		chromosome()->type()->operands()->rnd(instruction,COperand::B);
	} else {
		//cout << MNEMONIC_OPCODE(instruction.opcode()] << '.' << MNEMONIC_MODIFIER[instruction.modifier()] << " is unknown" << endl;
		// make stuff up
		instruction.set_addrmode_a((ADDRMODE)CRand::irand(ADDRMODE_LAST));
		instruction.set_addrmode_b((ADDRMODE)CRand::irand(ADDRMODE_LAST));
		chromosome()->type()->operands()->rnd(instruction,COperand::A);
		chromosome()->type()->operands()->rnd(instruction,COperand::B);
	}
	if(safety_checks) {
		if(!instruction.valid(chromosome()->warrior()->species()->kingdom()->coresize())) {
			cerr << "bad instruction in chromosome()[" << index() << ']' << endl;
			PANIC(MISC,"corrupt warrior from markov",NULL);
		}
	}
}

void CInstGeneratorMarkov::clear() {
	for(int i=0; i<opcodes; i++) {
		delete [] opcode[i].markov;
		//TODO: check that CHighLowArrays autodestruct
	}
	delete [] opcode;
	opcodes = 0;
	opcode = 0;
	readonly = true;
}

void CInstGeneratorMarkov::init(const unsigned coresize) {
	clear();
	CORESIZE = coresize;
	if(CORESIZE <= 0 || CORESIZE >= 0xFFFF)
		PANIC(MISC,"coresize isn\'t valid",NULL);
	opcodes = OPCODE_MODIFIER_LAST;
	opcode = new CFreq[opcodes];
	for(unsigned i=0; i<OPCODE_MODIFIER_LAST; i++) {
		opcode[i].key.set(i);
		opcode[i].markovs = OPCODE_MODIFIER_LAST;
		opcode[i].markov = new COpcodeModifier[opcode[i].markovs];
		for(unsigned j=0; j<opcode[i].markovs; j++)
			opcode[i].markov[j].set(j);
		opcode[i].addrmode_a.init(ADDRMODE_LAST);
		opcode[i].addrmode_b.init(ADDRMODE_LAST);
		for(unsigned j=0; j<ADDRMODE_LAST; j++) {
			opcode[i].addrmode_a[j].set(j);
			opcode[i].addrmode_b[j].set(j);
		}
		opcode[i].a.init(CORESIZE);
		opcode[i].b.init(CORESIZE);
		for(unsigned j=0; j<CORESIZE; j++) {
			opcode[i].a[j].set(j);
			opcode[i].a[j].set(j);
		}
	}
	readonly = false;
}

void CInstGeneratorMarkov::record(const OPCODE opcode_prev,const MODIFIER mod_prev,const insn_st &code) {
	const unsigned
		curr = _OP(code.opcode(),code.modifier()),
		prev = _OP(opcode_prev,mod_prev);
	opcode[curr].key.inc_count();
	if(opcode_prev < OPCODE_LAST)
		opcode[prev].markov[curr].inc_count();
	opcode[curr].addrmode_a[code.addrmode_a()].inc_low();
	opcode[curr].addrmode_b[code.addrmode_b()].inc_low();
	opcode[curr].a[code.a].inc_low();
	opcode[curr].b[code.b].inc_low();
}

void CInstGeneratorMarkov::dump(std::ostream &out) const {
	using namespace std;
	out << used_opcodes() << " used opcode/modifier combos" << endl;
	for(unsigned i=0; i<opcodes; i++) {
		if(opcode[i].key.used()) {
			out << MNEMONIC_OPCODE(opcode[i].key.get_opcode()) << '.' << MNEMONIC_MODIFIER(opcode[i].key.get_modifier()) << " = " << opcode[i].key.get_count() << endl;
			for(unsigned j=0; j<opcode[i].markovs; j++) {
				if(opcode[i].markov[j].used())
					out << '\t' << MNEMONIC_OPCODE(opcode[i].markov[j].get_opcode()) << '.' << MNEMONIC_MODIFIER(opcode[i].markov[j].get_modifier()) << " = " << opcode[i].markov[j].get_count() << endl; 
			}
			for(unsigned j=0; j<opcode[i].addrmode_a.count(); j++) {
				if(opcode[i].addrmode_a[j].used())
					out << "\ta." << MNEMONIC_ADDRMODE((ADDRMODE)opcode[i].addrmode_a[j].get_high()) << " = " << opcode[i].addrmode_a[j].get_low() << endl;
			}
			for(unsigned j=0; j<opcode[i].addrmode_b.count(); j++) {
				if(opcode[i].addrmode_b[j].used())
					out << "\tb." << MNEMONIC_ADDRMODE((ADDRMODE)opcode[i].addrmode_b[j].get_high()) << " = " << opcode[i].addrmode_b[j].get_low() << endl;
			}
			for(unsigned j=0; j<opcode[i].a.count(); j++) {
				if(opcode[i].a[j].used())
					out << "\ta[" << opcode[i].a[j].get_high() << "] = " << opcode[i].a[j].get_low() << endl;
			}
			for(unsigned j=0; j<opcode[i].b.count(); j++) {
				if(opcode[i].b[j].used())
					out << "\tb[" << opcode[i].b[j].get_high() << "] = " << opcode[i].b[j].get_low() << endl;
			}
		}
	}
}

void CInstGeneratorMarkov::save(const char *binfilename) const {
	// open file
	FILE *f = fopen(binfilename,"wb");
	if(!f)
		PANIC(MISC,"couldn\'t create lookup file ",binfilename);
	write(CORESIZE,f);
	write(used_opcodes(),f);
	for(unsigned i=0; i<opcodes; i++) {
		if(opcode[i].key.used()) {
			write(opcode[i].key.get_literal(),f);
			write(opcode[i].used_markovs(),f);
			for(unsigned j=0; j<opcode[i].markovs; j++) {
				if(opcode[i].markov[j].used())
					write(opcode[i].markov[j].get_literal(),f);
			}
			write(opcode[i].addrmode_a.used(),f);
			for(unsigned j=0; j<opcode[i].addrmode_a.count(); j++) {
				if(opcode[i].addrmode_a[j].used())
					write(opcode[i].addrmode_a[j].get_data(),f);
			}
			if(opcode[i].addrmode_a.calc_sum() != opcode[i].key.get_count()) PANIC(MISC,"bad number of addrmode_a entries in ",binfilename); 
			write(opcode[i].addrmode_b.used(),f);
			for(unsigned j=0; j<opcode[i].addrmode_b.count(); j++) {
				if(opcode[i].addrmode_b[j].used())
					write(opcode[i].addrmode_b[j].get_data(),f);
			}
			if(opcode[i].addrmode_b.calc_sum() != opcode[i].key.get_count()) PANIC(MISC,"bad number of addrmode_b entries in ",binfilename); 
			write(opcode[i].a.used(),f);
			for(unsigned j=0; j<opcode[i].a.count(); j++) {
				if(opcode[i].a[j].used())
					write(opcode[i].a[j].get_data(),f);
			}
			if(opcode[i].a.calc_sum() != opcode[i].key.get_count()) PANIC(MISC,"bad number of a entries in ",binfilename);
			write(opcode[i].b.used(),f);
			for(unsigned j=0; j<opcode[i].b.count(); j++) {
				if(opcode[i].b[j].used())
					write(opcode[i].b[j].get_data(),f);
			}
			if(opcode[i].b.calc_sum() != opcode[i].key.get_count()) PANIC(MISC,"bad number of b entries in ",binfilename); 
		}
	}
	// done
	fclose(f);
}

void CInstGeneratorMarkov::load(const char *binfilename) {
	unsigned x;
	FILE *f = fopen(binfilename,"rb");
	if(!f)
		PANIC(MISC,"couldn\'t open lookup file ",binfilename);
	clear();
	read(x,f); CORESIZE = x;
	read(x,f); opcodes = x;
	opcode_modifiers = 0;
	opcode = new CFreq[opcodes];
	for(unsigned i=0; i<opcodes; i++) {
		read(x,f); opcode[i].key.set_literal(x); opcode_modifiers += opcode[i].key.get_count();
		read(x,f); opcode[i].markovs = x;
		opcode[i].markov = new COpcodeModifier[opcode[i].markovs];
		opcode[i].opcode_modifiers = 0;
		for(unsigned j=0; j<opcode[i].markovs; j++) {
			read(x,f); opcode[i].markov[j].set_literal(x);
			opcode[i].opcode_modifiers += opcode[i].markov[j].get_count();
		}
		read(x,f); opcode[i].addrmode_a.init(x);
		for(unsigned j=0; j<opcode[i].addrmode_a.count(); j++) {
			read(x,f); opcode[i].addrmode_a[j].set_data(x);
		}
		if(opcode[i].addrmode_a.calc_sum() != opcode[i].key.get_count()) PANIC(MISC,"bad number of addrmode_a entries in ",binfilename); 
		read(x,f); opcode[i].addrmode_b.init(x);
		for(unsigned j=0; j<opcode[i].addrmode_b.count(); j++) {
			read(x,f); opcode[i].addrmode_b[j].set_data(x);
		}
		if(opcode[i].addrmode_b.calc_sum() != opcode[i].key.get_count()) PANIC(MISC,"bad number of addrmode_b entries in ",binfilename); 
		read(x,f); opcode[i].a.init(x);
		for(unsigned j=0; j<opcode[i].a.count(); j++) {
			read(x,f); opcode[i].a[j].set_data(x);
		}
		if(opcode[i].a.calc_sum() != opcode[i].key.get_count()) PANIC(MISC,"bad number of a entries in ",binfilename);
		read(x,f); opcode[i].b.init(x);
		for(unsigned j=0; j<opcode[i].b.count(); j++) {
			read(x,f); opcode[i].b[j].set_data(x);
		}
		if(opcode[i].b.calc_sum() != opcode[i].key.get_count()) PANIC(MISC,"bad number of b entries in ",binfilename); 
	}
	if(0 != fread(&x,1,1,f)) PANIC(MISC,"unexpected data after file",binfilename);
	fclose(f);
	readonly = true;
}

void CInstGeneratorMarkov::append(const char *rcfilename) {
	if(readonly)
		PANIC(MISC,"OpcodeFreqLookup is readonly",NULL);
	warrior_t warrior;
	// load it
	printf("loading %s\n",rcfilename);
	asm_fname(rcfilename,&warrior,CORESIZE); // will panic fatally if can't
	// and add to markov chaining
	OPCODE opcode_prev = OPCODE_LAST;
	MODIFIER mod_prev = MODIFIER_LAST;
	for(int i=0; i<warrior.len; i++) {
		if(warrior.code[i].opcode() == DAT) {
			opcode_prev = OPCODE_LAST;
			mod_prev = MODIFIER_LAST;
			continue; // skip it
		}
		record(opcode_prev,mod_prev,warrior.code[i]);
		opcode_prev = warrior.code[i].opcode();
		mod_prev = warrior.code[i].modifier();
	}
}