#include "ft_nm.h"

char *get_sym_char32(Elf32_Sym *sym, Elf32_Shdr *sec, int *tool) {
	*tool = 0;
	if (ELF32_ST_TYPE(sym->st_info) == STT_SECTION) {
		*tool = 1;
	}
	if (sym->st_shndx == SHN_ABS) {
		if (ELF32_ST_BIND(sym->st_info) == STB_LOCAL) {
			return ("a");
		}
		else if (ELF32_ST_BIND(sym->st_info) == STB_GLOBAL) {
			return ("A");
		}
	}
	if (ELF32_ST_BIND(sym->st_info) == STB_GNU_UNIQUE) {
		return ("u");
	}
	if (ELF32_ST_TYPE(sym->st_info) == STT_GNU_IFUNC) {
		return ("i");
	}
	if (sec->sh_flags & SHF_EXECINSTR) {
		if (ELF32_ST_BIND(sym->st_info) == STB_LOCAL) {
			return ("t");
		}
		else if (ELF32_ST_BIND(sym->st_info) == STB_GLOBAL) {
			return ("T");
		}
	}
	if (sec->sh_type == SHT_NOBITS) {
		if (ELF32_ST_BIND(sym->st_info) == STB_LOCAL) {
			return ("b");
		}
		else if (ELF32_ST_BIND(sym->st_info) == STB_GLOBAL) {
			return ("B");
		}
	}
	if (sec->sh_type == SHT_PROGBITS && (sec->sh_flags & (SHF_ALLOC | SHF_WRITE)) == (SHF_ALLOC | SHF_WRITE)) {
		if (ELF32_ST_BIND(sym->st_info) == STB_LOCAL) {
			return ("d");
		}
		else if (ELF32_ST_BIND(sym->st_info) == STB_GLOBAL) {
			return ("D");
		}
	}
	if (sec->sh_type == SHT_DYNAMIC && (sec->sh_flags & (SHF_ALLOC | SHF_WRITE)) == (SHF_ALLOC | SHF_WRITE)) {
		if (ELF32_ST_BIND(sym->st_info) == STB_LOCAL) {
			return ("d");
		}
		else if (ELF32_ST_BIND(sym->st_info) == STB_GLOBAL) {
			return ("D");
		}
	}
	if (sec->sh_type == SHT_INIT_ARRAY && (sec->sh_flags & (SHF_ALLOC | SHF_WRITE)) == (SHF_ALLOC | SHF_WRITE)) {
		if (ELF32_ST_BIND(sym->st_info) == STB_LOCAL) {
			return ("d");
		}
		else if (ELF32_ST_BIND(sym->st_info) == STB_GLOBAL) {
			return ("D");
		}
	}
	if (sec->sh_type == SHT_PREINIT_ARRAY && (sec->sh_flags & (SHF_ALLOC | SHF_WRITE)) == (SHF_ALLOC | SHF_WRITE)) {
		if (ELF32_ST_BIND(sym->st_info) == STB_LOCAL) {
			return ("d");
		}
		else if (ELF32_ST_BIND(sym->st_info) == STB_GLOBAL) {
			return ("D");
		}
	}
	if (sec->sh_type == SHT_FINI_ARRAY && (sec->sh_flags & (SHF_ALLOC | SHF_WRITE)) == (SHF_ALLOC | SHF_WRITE)) {
		if (ELF32_ST_BIND(sym->st_info) == STB_LOCAL) {
			return ("d");
		}
		else if (ELF32_ST_BIND(sym->st_info) == STB_GLOBAL) {
			return ("D");
		}
	}
	if (sec->sh_flags & SHF_ALLOC) {
		if (ELF32_ST_BIND(sym->st_info) == STB_LOCAL) {
			return ("r");
		}
		else if (ELF32_ST_BIND(sym->st_info) == STB_GLOBAL) {
			return ("R");
		}
	}
	if (sec->sh_type == SHT_NOTE && sec->sh_flags == SHF_ALLOC) {
		if (ELF32_ST_BIND(sym->st_info) == STB_LOCAL) {
			return ("r");
		}
		else if (ELF32_ST_BIND(sym->st_info) == STB_GLOBAL) {
			return ("R");
		}
	}
	if (sym->st_shndx == SHN_COMMON) {
		if (ELF32_ST_BIND(sym->st_info) == STB_LOCAL) {
			return ("c");
		}
		else if (ELF32_ST_BIND(sym->st_info) == STB_GLOBAL) {
			return ("C");
		}
	}
	if (sym->st_shndx == SHN_UNDEF) {
		if (ELF32_ST_BIND(sym->st_info) == STB_LOCAL) {
			return ("u");
		}
		else if (ELF32_ST_BIND(sym->st_info) == STB_GLOBAL) {
			return ("U");
		}
	}
	if (ELF32_ST_BIND(sym->st_info) == STB_WEAK) {
		if (ELF32_ST_TYPE(sym->st_info) == STT_OBJECT) {
			if (sec->sh_type == SHT_NULL) {
				return ("v");
			}
			else {
				return ("V");
			}
		} else {
			if (sec->sh_type == SHT_NULL) {
				return ("w");
			}
			else {
				return ("W");
			}
		}
	}
	if (ELF32_ST_BIND(sym->st_info) == STB_WEAK) {
		if (sec->sh_type == SHT_NULL) {
			return ("w");
		}
		else {
			return ("W");
		}
	}
	return ("n");
}

int nm32(t_mapped_file mapped_file, char *path, t_verbosity verbosity, t_ordering ordering) {
	Elf32_Ehdr header;
	if (get_header32(mapped_file, &header) == FT_NM_FAILURE) {
		return FT_NM_FAILURE;
	}
	uint32_t addr = header.e_shoff + header.e_shentsize * header.e_shstrndx;
	Elf32_Shdr *shstrtb;
	if (!(shstrtb = (Elf32_Shdr *)fetch(mapped_file, addr, header.e_shentsize))) {
		return FT_NM_FAILURE;
	}
	t_root *tree = NULL;
	t_entry *entry = (t_entry *)malloc(sizeof(t_entry)); 
	if (!entry)
		return FT_NM_FAILURE;
	int tool;
	for (int i = 0; i < header.e_shnum; i++) {
		uint32_t addr = header.e_shoff + header.e_shentsize * i;
		Elf32_Shdr *sh;
		if (!(sh = (Elf32_Shdr *)fetch(mapped_file, addr, header.e_shentsize))) {
			free(entry);
			return FT_NM_FAILURE;
		}
		if (sh->sh_type == SHT_SYMTAB) {
			uint32_t addr2 = header.e_shoff + header.e_shentsize * sh->sh_link;
			Elf32_Shdr *strtab;
			if (!(strtab = (Elf32_Shdr *)fetch(mapped_file, addr2, header.e_shentsize))) {
				free(entry);
				return FT_NM_FAILURE;
			}
			char *first = (char *)fetch(mapped_file, strtab->sh_offset, 1);
			char *last = (char *)fetch(mapped_file, strtab->sh_offset + strtab->sh_size - 1, 1);
			if (!first || !last || *first != '\0' || *last != '\0') {
				free(entry);
				return FT_NM_FAILURE;
			}
			for (uint32_t j = sh->sh_entsize; j < sh->sh_size; j += sh->sh_entsize) {
				Elf32_Sym *sym;
				Elf32_Shdr *sec;
				if (!(sym = (Elf32_Sym *)fetch(mapped_file, sh->sh_offset + j, sh->sh_entsize))) {
					free(entry);
					return FT_NM_FAILURE;
				}
				if (sym->st_shndx < header.e_shnum) {
					if (!(sec = (Elf32_Shdr *)fetch(mapped_file, header.e_shoff + header.e_shentsize * sym->st_shndx, header.e_shentsize))) {
						free(entry);
						return FT_NM_FAILURE;
					}
				}
				char *str;
				char *sec_str;
				Elf32_Shdr *shdr;
				if (sym->st_shndx != SHN_ABS) {
					if (!(shdr = (Elf32_Shdr *)fetch(mapped_file, header.e_shoff + header.e_shentsize * sym->st_shndx, header.e_shentsize))) {
						free(entry);
						return FT_NM_FAILURE;
					}
					sec_str = ft_strdup(mapped_file.ptr + shstrtb->sh_offset + shdr->sh_name);
				} else {
					sec_str = ft_strdup("");
				}
				if (sym->st_name) {
					str = ft_strdup(mapped_file.ptr + strtab->sh_offset + sym->st_name);
				}
				else {
					str = sec_str;
				}
				if (str != sec_str)
					free(sec_str);
				// ici la str (le symbole) est bon, on la charge dans le truc, ensuite on genere la vrai string a afficher, avant de sort
				entry->symbol = ft_strdup(str);
				free(str);
				char *sym_char = ft_strdup(get_sym_char32(sym, sec, &tool));
				if (ft_strnstr(entry->symbol, ".debug", 6) && ft_strequ(sym_char, "n")) {
					free(sym_char);
					sym_char = ft_strdup("N");
				}

				// ici le sym char a ete calculer, a partir de la on determine la verbosity 
				// ici on fait if entry->verbosity >= verbosity, si c'est pas bon on skip toute la suite
				entry->verbosity = DEFAULT_VERBOSITY;
				if ((sym_char[0] == 'a' && sym->st_info == 4) || sym_char[0] == 'N' || tool == 1)
					entry->verbosity = ALL;
				if (sym_char[0] == 'u' || sym_char[0] == 'v' || sym_char[0] == 'w' || (sym_char[0] >= 'A' && sym_char[0] <= 'Z' && sym_char[0] != 'N'))
					entry->verbosity = GLOBAL;
				if (sym_char[0] == 'w' || sym_char[0] == 'U')
					entry->verbosity = UNDEFINED;
				if (entry->verbosity >= verbosity) {
					// ici on genere la string a afficher
					//					      pad ' ' symchar ' '       symbol name          \n  \0
					size_t entry_string_len = 8 + 1 +   1   + 1 + ft_strlen(entry->symbol) + 1 + 1;
					entry->string = (char *)malloc(sizeof(char) * entry_string_len);
					if (!entry->string)
						return FT_NM_FAILURE;
					entry->string[entry_string_len - 1] = '\0';
					entry->string[entry_string_len - 2] = '\n';
					entry->string[8] = ' ';
					entry->string[9] = sym_char[0];
					entry->string[10] = ' ';
					ft_memcpy(entry->string + 11, entry->symbol, ft_strlen(entry->symbol));
					if (sym->st_value && !ft_strstr(entry->symbol, "@@")) {
						for (char i = 7; i >= 0; i--) {
							entry->string[7 - i] = ft_get_hex_digit((sym->st_value >> i * 4) & 0xF);
						}
					} else {
						if (ft_strcmp(sym_char, "U") && ft_strcmp(sym_char, "w") && ft_strcmp(sym_char, "v")) {

							for (char i = 7; i >= 0; i--) {
								entry->string[7 - i] = ft_get_hex_digit((sym->st_value >> i * 4) & 0xF);
							}
						} else {
							for (int i = 0; i < 8; i++)
								entry->string[i] = ' ';
						}
					}
					free(sym_char);
					// ensuite un switch ordering avec un ft_lstinsert (pointeur sur fonction serait plus opti mais osef)
					switch (ordering) {
						case NOSORT:
							ft_rbt_insert(&tree, ft_rbt_new((void *)entry, sizeof(t_entry)), &nosort);
							break;
						case REVERSE:
							ft_rbt_insert(&tree, ft_rbt_new((void *)entry, sizeof(t_entry)), &reverse);
							break;
						case DEFAULT_ORDERING:
							ft_rbt_insert(&tree, ft_rbt_new((void *)entry, sizeof(t_entry)), &strcmp_nm);
							break;
					}
				} else {
					free(entry->symbol);
					free(sym_char);
				}
			}
		}
	}
	free(entry);
	// ici on affiche tout ou no symbols en cas de list vide
	if (tree) {
		ft_putrbt(tree, &put_entry);
		ft_delrbt(tree, &free_entry);
	} else {
		ft_printf("sss", "nm: ", path, ": no symbols\n");
	}
	return FT_NM_SUCCESS;
}