// printf("[%d]%c%s %ld %s %s %s \n", p - 1, files[p - 1].type, files[p - 1].mode, files[p - 1].hard_links, files[p - 1].group, files[p - 1].owner, files[p - 1].name);
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <ctype.h>
#include <pwd.h>
#include <grp.h>

#define REALLOC_SIZE 2
#define MODE_LEN 10


struct file_t {
	char * dir;
	char * name;
	char * mode;
	char * group;
	char * owner;
	char type;
	nlink_t hard_links;
};


int aflag = 0;
int lflag = 0;
int rflag = 0;

int p = 0;

char get_file_type(mode_t mode);
char * get_file_group(gid_t gid);
char * get_file_mode(mode_t mode);
char * get_file_owner(uid_t uid);
char * create_path(const char * dirname, const char * filename);

int * sort_by_name(struct file_t * files);

void add_file(struct file_t * files, char * filename, char* file_mode, char * file_group, char * file_owner, char file_type, nlink_t file_hard_links, const char * dirname);
void add_info_for_dir(int number_files, const char * dirname, struct file_t * files);

void print(struct file_t * files);

void process(int number_files, char * filenames[], struct file_t * files);


int main(int argc, char * const* argv) {
	int c, i;

	int element = 0;
	char ** dir = malloc(sizeof(char *));

	while ((c = getopt (argc, argv, "aAlR")) != -1) {
		switch (c) {
			case 'A':
				aflag = 1;
				break;
			case 'l':
				lflag = 1;
				break;
			case 'R':
				rflag = 1;
				break;
			default:
			break;
		}
	}

	for(i = 1; i < argc; i++) {
		if(argv[i][0] == '-') {
			continue;
		}
		dir = realloc(dir, (element + 1) * sizeof(char *));
		dir[element] = malloc(sizeof(char) * (strlen(argv[i]) + 1));
		strcpy(dir[element], argv[i]);
		element++;
	}

	if(element == 0) {
		dir[0] = malloc(sizeof(char) * 2);
		dir[0] = ".\0";
		element ++;
	}

	struct file_t files[255];
	process(element, dir, files);

	print(files);
	// free(files);
	return 0;
}


void process(int number_files, char * filenames[], struct file_t * files) {
	int i;
	char file_type;
	struct stat curr_file_stat;

	for (i = 0; i < number_files; ++i) {
		if(stat(filenames[i], &curr_file_stat)) {
			perror(filenames[i]);
		}

		file_type = get_file_type(curr_file_stat.st_mode);

		if(file_type == 'd') {
			add_info_for_dir(number_files, filenames[i], files);
			continue;
		}

		add_file(files, filenames[i], get_file_mode(curr_file_stat.st_mode), get_file_group(curr_file_stat.st_gid), get_file_owner(curr_file_stat.st_uid), file_type, curr_file_stat.st_nlink, "");

	}
}


void add_info_for_dir(int number_files, const char * dirname, struct file_t * files) {
	DIR *dir;
	struct dirent * ent;
	char * file_path;
	char file_type;

	struct stat curr_stat;

	dir = opendir(dirname);
	if(dir != NULL) {
		while((ent=readdir(dir)) != NULL) {
			file_path = create_path(dirname, ent->d_name);

			if(stat(file_path, &curr_stat)) {
				perror(file_path);
			}

			file_type = get_file_type(curr_stat.st_mode);

			if(file_type == 'd' && rflag && (strcmp(ent -> d_name, ".") && strcmp(ent -> d_name, ".."))) {
				add_info_for_dir(number_files, file_path, files);
			}

			add_file(files, ent->d_name, get_file_mode(curr_stat.st_mode), get_file_group(curr_stat.st_gid), get_file_owner(curr_stat.st_uid), file_type, curr_stat.st_nlink, dirname);
			free(file_path);
		}
		if(closedir(dir)) {
			perror("closedir");
		}

	} else {
		perror("opendir");
	}
}


void add_file(struct file_t * files, char * filename, char* file_mode, char * file_group, char * file_owner, char file_type, nlink_t file_hard_links, const char * dirname) {
	files[p].dir = malloc(sizeof(char) * strlen(dirname));
	strcpy(files[p].dir, dirname);

	files[p].name = malloc(sizeof(char) * (strlen(filename) + 1));
	strcpy(files[p].name, filename);

	files[p].mode = malloc(sizeof(char) * (strlen(file_mode) + 1));
	strcpy(files[p].mode, file_mode);

	files[p].owner = malloc(sizeof(char) * (strlen(file_owner) + 1));
	strcpy(files[p].owner, file_owner);

	files[p].group = malloc(sizeof(char) * (strlen(file_group) + 1));
	strcpy(files[p].group, file_group);

	files[p].hard_links = file_hard_links;
	files[p].type = file_type;
	p++;
}


char * create_path(const char * dirname, const char * filename) {
	char * file_path = malloc(sizeof(char) * (strlen(dirname) + strlen(filename) + 2));

	strcpy(file_path, dirname);

	if(dirname[strlen(dirname) - 1] != '/') {
		strcat(file_path, "/");
	}

	strcat(file_path, filename);

	return file_path;
}

char get_file_type(mode_t mode) {
	switch(mode & S_IFMT) {
		case S_IFSOCK: return 's';
		case S_IFLNK:  return 'l';
		case S_IFREG:  return '-';
		case S_IFBLK:  return 'b';
		case S_IFDIR:  return 'd';
		case S_IFCHR:  return 'c';
		case S_IFIFO:  return 'p';
		default:  	   return 'E';
	}
}


char * get_file_mode(mode_t mode) {
	char * file_mode = malloc(sizeof(char) * MODE_LEN);
	char curr_mode;
	int file_modes[9] = {S_IRUSR, S_IWUSR, S_IXUSR, S_IRGRP, S_IWGRP, S_IXGRP, S_IROTH, S_IWOTH, S_IXOTH};
	int i;
	for(i = 0; i < 9; i++) {
		if(mode & file_modes[i]) {
			switch(i % 3) {
				case 0: curr_mode = 'r'; break;
				case 1: curr_mode = 'w'; break;
				case 2: curr_mode = 'x'; break;
			}
		} else {
			curr_mode = '-';
		}
		file_mode[i] = curr_mode;
	}

	file_mode[9] = '\0';

	return file_mode;
}

char * get_file_group(gid_t gid) {
	struct group * gr = getgrgid(gid);
	return gr -> gr_name;
}


char * get_file_owner(uid_t uid) {
	struct passwd * passw = getpwuid(uid);
	return passw -> pw_name;
}


void print(struct file_t * files) {
	int i;
	int pos;
	int * ordered_list = sort_by_name(files);
	for(i = 0; i < p; i++) {
		pos = i;
		pos = ordered_list[i];
		printf("%c%s %ld %s %s %s %s\n", files[pos].type, files[pos].mode, files[pos].hard_links, files[pos].group, files[pos].owner, files[pos].name, files[pos].dir);

	}
}

int * sort_by_name(struct file_t * files) {
	int * result_order = malloc(sizeof(int) * (p + 1));
	int i, k, temp;
	for(i = 0; i < p; i++) {
		result_order[i] = i;
	}

	for(i = 0; i < p; i++) {
		printf("%d ",result_order[i]);
	}
	printf("\n");
	result_order[p] = '\0';
	for(i = 0; i < p; i ++) {
		for( k = i + 1; k < p; k++) {
			if(strcmp (files[i].name, files[k].name) > 0) {
				temp = result_order[i];
				result_order[i] = result_order[k];
				result_order[k] = temp;
			}
		}
	}

	for(i = 0; i < p; i++) {
		printf("%d ",result_order[i]);
	}
	printf("\n");
	return result_order;
}