#include <pwd.h>
#include <grp.h>
#include <time.h>
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <unistd.h>
#include <dirent.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include "make_path.h"
#include "get_stat.h"
#include "config.h"
#include "human.h"

unsigned int O_flag;
unsigned int a_flag;
unsigned int l_flag;
unsigned int F_flag;
unsigned int c_flag;
unsigned int R_flag;
unsigned int d_flag;
unsigned int L_flag;
unsigned int h_flag;
unsigned int i_flag;
unsigned int p_flag;

struct d_node {
	/* basename */
	char *name;

	/* For free */
	char *full_name;

	struct d_node *next;
	struct stat stats;
};

/* Work with dir */
struct d_node *stat_file(char *filename, int lfile) {
	/* lfile its flag. 1 if passed file from list_one() */
	struct d_node *file = malloc(sizeof(struct d_node));
	if (file == NULL)
		return NULL;

	if (mu_get_stats("ls", !L_flag, filename, &file->stats)) {
		free(file);
		return NULL;
	}

	file->full_name = filename;
	file->name = strrchr(filename, '/');
	if (file->name == NULL || lfile)
		file->name = filename;

	else
		file->name++;

	return file;
}

struct d_node **list(const char *path, size_t *nfiles) {
	DIR *dp = opendir(path);
	if (dp == NULL) {
		fprintf(stderr, "ls: %s: %s\n", path, strerror(errno));
		return NULL;
	}

	struct d_node **dir, *cur, *dr = NULL;
	size_t files = 0;

	struct dirent *ep;
	while ((ep = readdir(dp)) != NULL) {
		if (ep->d_name[0] == '.' && !a_flag)
			continue;

		char *full_path = mu_make_path("ls", path, ep->d_name);
		if (full_path == NULL)
			continue;

		cur = stat_file(full_path, 0);
		if (cur == NULL) {
			free(full_path);
			continue;
		}

		cur->next = dr;
		dr = cur;

		files++;
	}

	closedir(dp);

	if (dr == NULL)
		return NULL;

	*nfiles = files;
	dir = malloc((files + 1) * sizeof(struct d_node *));
	if (dir == NULL) {
		fprintf(stderr, "ls: malloc failed\n");
		exit(1);
	}

	for (size_t i = 0; ; i++) {
		dir[i] = dr;
		dr = dr->next;
		if (dr == NULL)
			break;
	}

	return dir;
}

struct d_node **list_one(const char *path) {
	struct d_node **dir = malloc(sizeof(struct d_node *));
	if (dir == NULL) {
		fprintf(stderr, "ls: malloc failed\n");
		exit(1);
	}

	char *new_path = strdup(path);
	if (new_path == NULL) {
		free(dir);
		return NULL;
	}

	dir[0] = stat_file(new_path, 1);
	if (dir[0] == NULL) {
		free(dir);
		return NULL;
	}

	return dir;

}

void dfree(struct d_node **dir) {
	struct d_node *cur = dir[0], *next;
	while (cur != NULL) {
		next = cur->next;
		free(cur->full_name);
		free(cur);
		cur = next;
	}

	free(dir);
}

/* Print */
int print(const struct d_node *node) {

	/* F_flag and c_flag Make output look pretty */
	char suf = ' ';
	char ind = '-';
	char *color = "";
	if (S_ISDIR(node->stats.st_mode)) {
		if (node->name[strlen(node->name) - 1] != '/')
			suf = '/';

		ind = 'd';
		color = LS_DIR_COLOR;
	}

	else if (S_ISLNK(node->stats.st_mode)) {
		suf = '@';
		ind = 'l';
		color = LS_LINK_COLOR;
	}

	else if (S_ISSOCK(node->stats.st_mode)) {
		suf = '=';
		ind = 's';
		color = LS_SOCK_COLOR;
	}

	else if (S_ISFIFO(node->stats.st_mode)) {
		suf = '|';
		ind = 'p';
		color = LS_FIFO_COLOR;
	}

	else if ((node->stats.st_mode & S_IXUSR) || (node->stats.st_mode & S_IXGRP) || (node->stats.st_mode & S_IXOTH)) {
		suf = '*';
		color = LS_EXE_COLOR;
	}

	int ret = 0;
	if (i_flag)
		ret += printf("%7ju ", (uintmax_t)node->stats.st_ino);

	/* Output */
	if (c_flag && p_flag)
		printf("%s", color);

	if (!l_flag)
		ret += printf("%s%c ", node->name, (F_flag) ? suf : 0);

	if (l_flag) {
		putchar(ind);
		printf("%c%c%c", (node->stats.st_mode & S_IRUSR) ? 'r' : '-', (node->stats.st_mode & S_IWUSR) ? 'w' : '-', (node->stats.st_mode & S_IXUSR) ? 'x' : '-');
		printf("%c%c%c", (node->stats.st_mode & S_IRGRP) ? 'r' : '-', (node->stats.st_mode & S_IWOTH) ? 'w' : '-', (node->stats.st_mode & S_IXGRP) ? 'x' : '-');
		printf("%c%c%c", (node->stats.st_mode & S_IROTH) ? 'r' : '-', (node->stats.st_mode & S_IWOTH) ? 'w' : '-', (node->stats.st_mode & S_IXOTH) ? 'x' : '-');

		struct tm *tm = localtime(&node->stats.st_mtime);

		char date[14];
		if (!strftime(date, sizeof(date), "%b %d %H:%M", tm))
			return 0;

		struct passwd *pw = getpwuid(node->stats.st_uid);
		struct group *gr = getgrgid(node->stats.st_gid);

		char *gr_name = (gr != 0) ? gr->gr_name : "nobody";
		char *pw_name = (pw != 0) ? pw->pw_name : "nobody";
		if (h_flag)
			ret += printf(" %s %s %6s %s %s%c", pw_name, gr_name, mu_humansize(node->stats.st_size), date, node->name, (F_flag) ? suf : 0);

		else
			ret += printf(" %s %s %10jd %s %s%c", pw_name, gr_name, (uintmax_t)node->stats.st_size, date, node->name, (F_flag) ? suf : 0);
	}

	if (c_flag && p_flag)
		printf("\033[0m");

	return ret;
}

void col_print(struct d_node **node, size_t files, struct winsize w) {
	/* Get max len */
	size_t maxlen = 0;
	for (size_t i = 0; i < files; i++)
		if (strlen(node[i]->name) > maxlen)
			maxlen = strlen(node[i]->name);

	/* Calc */
	maxlen += 3;
	if (i_flag)
		maxlen += 10;

	size_t ncols = w.ws_col / maxlen;
	size_t nrows = files;
	if (ncols > 1) {
		nrows = files / ncols;
		if (nrows * ncols < files)
			nrows++;
	}

	else
		ncols = 1;

	int col = 0;
	int nexttab = 0;

	/* Mc print */
	for (size_t i = 0; i < nrows; i++) {
		for (size_t j = 0; j < ncols; j++) {
			size_t index = j * nrows + i;
			if (index < files) {
				if (col > 0) {
					nexttab -= col;
					col += nexttab;
					for (int k = 0; k < nexttab; k++)
						putchar(' ');
				}

				nexttab = col + (int)maxlen;
				col += print(node[index]);
			}
		}

		putchar('\n');
		col = 0;
	}
}

int ls(const char *dir_name, int label, struct winsize w) {
	size_t files = 0;
	struct stat sb;
	if (mu_get_stat("ls", dir_name, &sb))
		return 1;

	struct d_node **dir = NULL;
	if (S_ISDIR(sb.st_mode) && !d_flag)
		dir = list(dir_name, &files);

	else {
		dir = list_one(dir_name);
		files++;
	}

	if (dir == NULL)
		return 1;

	if ((label || R_flag) && !d_flag)
		printf("\n%s:\n", dir_name);

	/* pipe print */
	if (!p_flag || l_flag || O_flag) {
		for (size_t i = 0; i < files; i++) {
			print(dir[i]);
			putchar('\n');
		}
	}

	/* mc print */
	else
		col_print(dir, files, w);

	if (R_flag)
		for (size_t i = 0; i < files; i++)
			if (S_ISDIR(dir[i]->stats.st_mode) && strcmp(dir[i]->name, "..") && strcmp(dir[i]->name, "."))
				ls(dir[i]->full_name, 1, w);

	dfree(dir);
	return 0;
}

int main(int argc, char **argv) {
	int opt;
	while ((opt = getopt(argc, argv, "1alFcRdLhi")) != -1) {
		switch (opt) {
			case '1':
				O_flag = 1;
				break;

			case 'a':
				a_flag = 1;
				break;

			case 'l':
				l_flag = 1;
				break;

			case 'F':
				F_flag = 1;
				break;

			case 'c':
				c_flag = 1;
				break;

			case 'R':
				d_flag = 0;
				R_flag = 1;
				break;

			case 'd':
				R_flag = 0;
				d_flag = 1;
				break;

			case 'L':
				L_flag = 1;
				break;

			case 'h':
				h_flag = 1;
				break;

			case 'i':
				i_flag = 1;
				break;

			default:
				printf("ls [dir1 dir2...]\n\t[-a Show hidden files]\n\t[-l Use a long listing format]\n\t[-F Append indicator to names]\n\t[-c Color mode] [-R Recursive]\n\t[-1 One column] [-d Print only dir names]\n\t[-L Follow symlinks]\n\t[-h Sizes in human readable format]\n\t[-i Listen inodes]\n");
				return 0;
		}
	}

	argv += optind;
	argc -= optind;

	struct winsize w;
	ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);

	/* Check if programm piped, 1 - false, 0 - true */
	p_flag = isatty(STDOUT_FILENO);

	if (argc < 1)
		ls(".", 0, w);

	if (argc == 1)
		ls(argv[0], 0, w);

	else
		for (int i = 0; i < argc; i++)
			ls(argv[i], 1, w);

	return 0;
}