/* no idea whose this is.  if whoever made it wants to say something and claim credit, please let me know. */

#include <stdio.h>
#include <stdlib.h>
#include pidiv.h
#include gender.h

#define DEFAULT_MODE CLI
#define NUM_POKEMON 493
#define IV_MAX 31

#define TEST 29

#define PRNG(x) (0x41c64E6D*(x)+0x6073)
#define PRNG_REV(x) (0xEEB9EB65*(x)+0xA3561A1)
#define APRNG(x) (0x6C078965*(x)+0x1)
#define APRNG_REV(x) (0x9638806D*(x)+0x69c77F93)

// High and low functions for u32
#define HIGH(x) ((x)>>16&0xFFFF)
#define LOW(x) ((x)&0xFFFF)

#define RAND8 random(0x100)
#define RAND16 random(0x10000)

typedef unsigned char u8;			// 0 to 255
typedef unsigned short u16;			// 0 to 65535
typedef unsigned long u32;			// 0 to 4294967295
typedef unsigned long long u64;		// 0 to 1.8*10^19
typedef signed char s8;				// -127 to 127 (usually -128)
typedef signed short s16;			// -32767 to 32767 (usually -32768)
typedef signed long s32;			// +/- 2147483647
typedef signed long long s64;		// +/- 9.2*10^18

int mode;
s32 * pref_stats;
s32 * stats;
u8 * pref_ivs;
u8 * ivs;
u8 * algorithms;
u8 * ic_log;
u8 gender_threshold;
u64 num_results;
u64 found;
u8 log_length;
u8 tail;

enum {CLI, GUI, NUM_MODES};
enum {HP, ATK, DEF, SPD, SATK, SDEF, NUM_IVS};
enum {NORMAL, WILD, UNCOMMON, RARE, VERY_RARE, SUPER_RARE, NUM_ALGORITHMS};
enum {NATURE, CLASS, GENDER, SHINY, HP_TYPE, HP_POWER, TID, SID, NUM_STATS};

u8 get_gender_threshold(int pokemon)
{
	return (pokemon <= 0 || pokemon > NUM_POKEMON) ? gender[0] : gender[pokemon];
}

int cli_input()
{
	// temp code
	int i;
	for(i = 0; i < NUM_IVS; i++) {
		pref_ivs[i]=TEST;
	}
	for(i = 0; i< NUM_ALGORITHMS; i++) {
		algorithms[i] = 1;
	}
	pref_stats[NATURE] = -1;
	pref_stats[CLASS] = -1;
	pref_stats[GENDER] = -1;
	pref_stats[SHINY] = 0;
	pref_stats[HP_TYPE] = -1;
	pref_stats[HP_POWER] = 30;
	pref_stats[TID] = -1;
	pref_stats[SID] = -1;

	/* TODO: cli_input */
	return 0;
}

int gui_input()
{
	/* TODO: gui_input */
	return 0;
}

int get_input()
{
	if(mode == CLI) {
		return cli_input();
	} else if(mode == GUI) {
		return gui_input();
	}
	return 1;
}

void init_all()
{
	int i;
	pref_stats = (s32*) calloc(NUM_STATS, sizeof(s32));
	if(pref_stats==NULL) exit (1);
	stats = (s32*) calloc(NUM_STATS, sizeof(s32));
	if(stats==NULL) exit (1);
	pref_ivs = (u8*) calloc(NUM_IVS, sizeof(u8));
	if(pref_ivs==NULL) exit (1);
	ivs = (u8*) calloc(NUM_IVS, sizeof(u8));
	if(ivs==NULL) exit (1);
	algorithms = (u8*) calloc(NUM_ALGORITHMS, sizeof(u8));
	if(algorithms==NULL) exit (1);
	ic_log = NULL;
	mode = DEFAULT_MODE;
	gender_threshold = 255;
	num_results = 0;
	found = 0;
	log_lenghth = 0;
	tail = -1;
	return;
}

void init_ic()
{
	for(i = 0; i < NUM_IVS; i++) {
		log_length += IV_MAX-pref_ivs[i];
	}
	if(algorithms==NULL) exit (1);
	ic_log = (u8*) calloc(log_length, sizeof(u8));
}

void free_all()
{
	free(pref_stats);
	free(stats);
	free(pref_ivs);
	free(ivs);
	free(algorithms);
	if(ic_log) free(ic_log);
	return;
}

int cli_print_data(u32 pid, u8 algorithm) {
	// temp code
	printf("%010u %2d %2d %2d %2d %2d %2d %1d %2d %1d %1d %1d %2d %2d %05u %05u\n", pid, ivs[HP], ivs[ATK], ivs[DEF], ivs[SPD], ivs[SATK], ivs[SDEF], algorithm, stats[NATURE], stats[CLASS], stats[GENDER], stats[SHINY], stats[HP_TYPE], stats[HP_POWER], stats[TID], stats[SID]);
	
	/* TODO: real cli_print_data */
	return 0;
}

int gui_print_data(u32 pid, u8 algorithm)
{
	/* TODO: gui_print_data */
	return 0;
}

int print_data(u32 pid, u8 algorithm)
{
	if(mode == CLI) {
		return cli_print_data(pid, algorithm);
	} else if(mode == GUI) {
		return gui_print_data(pid, algorithm);
	}
	return 1;
}

int check_pid(u32 pid, u8 algorithm)
{
	int ret;
	stats[NATURE] = (s32) pid%25;
	stats[CLASS] = (s32) pid&0x1;
	stats[HP_TYPE] = (s32) ((ivs[5]&0x1)<<5|(ivs[4]&0x1)<<4|(ivs[3]&0x1)<<3|(ivs[2]&0x1)<<2|(ivs[1]&0x1)<<1|ivs[0]&0x1)*15/63;
	stats[HP_POWER] = (s32) ((ivs[5]&0x2)<<4|(ivs[4]&0x2)<<3|(ivs[3]&0x2)<<2|(ivs[2]&0x2)<<1|(ivs[2]&0x2)|(ivs[2]&0x2)>>1)*40/63+30;
	stats[TID] = (s32) (prefs[TID]>=0 ? prefs[TID] : (prefs[SID]<0 ? RAND16 : (prefs[SHINY] ? HIGH(pid)^LOW(pid)^prefs[SID] : RAND16)));
	stats[SID] = (s32) (prefs[SID]>=0 ? prefs[SID] : (prefs[SHINY] ? HIGH(pid)^LOW(pid)^stats[TID] : RAND16));
	stats[SHINY] = (HIGH(pid)^LOW(pid)^stats[TID]^stats[SID]) < 8 ? 1 : 0;
	stats[GENDER] = gender_threshold==0 ? 0 : (gender_threshold==254 ? 1 : (gender_threshold==255 ? 2 : ((pid&0xFF) > gender_threshold ? 0 : 1)));
	if(!(1<<stats[NATURE]&prefs[NATURE]))
		return 0;
	if(stats[CLASS] != prefs[CLASS] && prefs[CLASS] >= 0)
		return 0;
	if(stats[GENDER] != prefs[GENDER] && prefs[GENDER] >= 0)
		return 0;
	if(!stats[SHINY] && prefs[SHINY])
		return 0;
	if(!(1<<stats[HP_TYPE]&prefs[HP_TYPE]))
		return 0;
	if(stats[HP_POWER] < prefs[HP_POWER])
		return 0;
	ret = print_data(pid, algorithm);
	return ret;
}

int ivs_to_pid(u32 root, int iv1)
{
	int ret;
	u32 x[5];
	u8 found[] = {0, 0, 0};
	x[0] = PRNG_REV(root);
	if(algorithms[NORMAL] || algorithms[WILD] || algorithms[SUPER_RARE]) {
		if ((HIGH(x[0])&0x7FFF) == iv1)
			found[0] = 1;
	}
	x[1] = PRNG_REV(x[0]);
	if(algorithms[UNCOMMON] || algorithms[RARE]) {
		if ((HIGH(x[1])&0x7FFF) == iv1)
			found[1] = 1;
	}
	x[2] = rev(x[1]);
	if(algorithms[VERY_RARE]) {
		if ((HIGH(x[2])&0x7FFF) == iv1)
			found[2] = 1;
	}
	if(found[0]) {
		ret = check_pid(((x[1]&0xFFFF0000)|HIGH(x[2]), NORMAL);
		if(ret) return ret;
	}
	if(!algorithms[WILD] && !algorithms[UNCOMMON] && !algorithms[RARE] && !algorithms[VERY_RARE] && !algorithms[SUPER_RARE])
		return 0;
	x[3] = rev(x[2]);
	if(found[0] || found[1]) {
		ret = check_pid(((x[2]&0xFFFF0000)|HIGH(x[3]), found[0] ? WILD : UNCOMMON);
		if(ret) return ret;
	}
	if(!algorithms[RARE] && !algorithms[VERY_RARE] && !algorithms[SUPER_RARE])
		return 0;
	x[4] = rev(x[3]);
	if(found[0] || found[1] || found[2]) {
		ret = check_pid(((x[3]&0xFFFF0000)|HIGH(x[4])), found[1] ? RARE : (found[2] ? VERY_RARE : SUPER_RARE));
		if(ret) return ret;
	}
	return 0;
}

int root_loop()
{
	int ret;
	u32 i;
	u32 j;
	u32 iv1 = ivs[HP]|ivs[ATK]<<5|ivs[DEF]<<10;
	u32 iv2 = ivs[SPD]|ivs[SATK]<<5|ivs[SDEF]<<10;
	for(i = 0; i < 2; i++) {
		for(j = 0; j < 0x10000; j++) {
			ret = ivs_to_pid(i<<31|iv2<<16|j, iv1);
			if(ret) return ret;
		}
	}
	return 0;
}

int flip(int i)
{
	int ret;
	ivs[ic_log[i]]++;
	ic_log[i]++;
	if((i != 0 && ic_log[i] > ic_log[i-1]) || ic_log[i] >= NUM_IVS) {
		ic_log[i] = 0;
		ivs[0]--;
		if(i>0) {
			ret = flip(i-1);
			if(ret) return ret;
		} else {
			ret = exp_log();
			if(ret) return ret;
		}
	} else {
		ivs[ic_log[i]]--;
	}
	if(ivs[ic_log[i]] < pref_ivs[ic_log[i]] || ivs[ic_log[i]] > IV_MAX) return flip(i);
	return 0;
}

int exp_log()
{
	tail++;
	if(tail > log_length) return 1;
	ic_log[tail]=0;
	ivs[0]--;
	if(ivs[0]<pref_ivs[0]) return flip(tail);
	return 0;
}

int iv_loop()
{
	int i;
	int ret;
	int stop = 0;
	for(i = 0; i < NUM_IVS; i++) {
		ivs[i] = IV_MAX;
	}
	ret = root_loop();
	if(ret) return ret;
	stop = exp_log();
	while(!stop) {
		ret = root_loop();
		if(ret) return ret;
		stop = flip(tail);
	}
}

int main()
{
	int ret;
	mode = CLI;
	init_all();
	ret = get_input();
	if(ret) {
		free_all();
		return ret;
	}
	init_ic();
	ret = iv_loop();
	free_all();
	return ret;
}