#include "solver.hpp"

void Solver::generate_set(vector<int> carry) {
	if(carry.size() == N) {
		possible.insert(carry);
		return;
	}

	for(int col = 0; col < M; col++) {
		carry.push_back(col);
		generate_set(carry);
		carry.pop_back();
	}
}

Solver::Solver(int _N, int _M) : N(_N), M(_M) {
	generate_set({});
}

vector<int> Solver::guess() {
	return minimax({}).guess;
}
void Solver::learn(vector<int> guess, Response response) {
	set<vector<int>> next_possible;
	for(auto sequence : possible)
		if(validate(sequence, guess) == response)
			next_possible.insert(sequence);

	possible = next_possible;
}

// TODO
int Solver::get_weight(vector<int> guess) {
	// Indexing by N*somewhere + correct and holding how many sequences got that response
	vector<int> response_count(N*N+1, 0);
	for(auto sequence : possible) {
		Response response = validate(sequence, guess);
		response_count[N*response.somewhere + response.correct]++;
	}

	// Get highest possible number of sequences left
	int max = 0;
	for(int count : response_count)
		if(count > max)
			max = count;
	return max - possible.count(guess);
}
Weighed_guess Solver::minimax(vector<int> carry) {
	if(carry.size() == N)
		return {get_weight(carry), carry};

	Weighed_guess best = {-1, {}};
	for(int col = 0; col < M; col++) {
		carry.push_back(col);

		Weighed_guess next = minimax(carry);
		if(best.weight == -1 || next.weight < best.weight)
			best = next;

		carry.pop_back();
	}
	return best;
}