#include "pipex.h"

char	*read_file(int fd)
{
	char	*str;
	int		len;
	int		old_len;

	str = get_next_line(fd);
	len = ft_strlen(str);
	old_len = 0;
	while (len != old_len)
	{
		old_len = len;
		str = ft_strjoin_free(str, get_next_line(fd), 2);
		len = ft_strlen(str);
	}
	str[len] = '\0';
	return (str);
}

int	get_next(char *cmd, char c)
{
	int	i;

	i = 0;
	while (cmd[i] != c)
		i++;
	return (i);
}

char	**get_flags(char *cmd)
{
	size_t		i;
	int			y;
	char		*new_str;
	char		**flags;

	i = get_next(cmd, ' ') + 1;
	new_str = ft_calloc(ft_strlen(cmd) - i + 1, 1);
	y = 0;
	while (cmd[i])
		new_str[y++] = cmd[i++];
	new_str[y] = '\0';
	flags = ft_split(new_str, ' ');
	i = 0;
	free(new_str);
	return (flags);
}

char	*get_command(char *cmd)
{
	int		i;
	char	*new_str;

	new_str = ft_calloc(get_next(cmd, ' ') + 1, 1);
	i = -1;
	while (cmd[++i] != ' ')
		new_str[i] = cmd[i];
	new_str[i] = '\0';
	return (new_str);
}

char **add_cmd(char **flg, char *cmd)
{
	char	*tmp;
	int		i;
	int		check;

	tmp = NULL;
	i = 0;
	check = 0;
	while (check == 0)
	{
		if (flg[i] == NULL)
			check = 1;
		if (tmp != NULL)
			flg[i] = tmp;
		tmp = flg[i];
		i++;
	}
	flg[0] = cmd;
	return (flg);
}

int	parsing(char *argv[], t_data *data)
{
	int	fd1;
	int	fd2;

	fd2 = open(argv[4], O_WRONLY | O_TRUNC | O_CREAT);
	if (fd2 < 0)
		return (-1);
	fd1 = open(argv[1], O_RDONLY);
	if (fd1 < 0)
	{
		close(fd2);
		return (-1);
	}
	data->cmd1 = get_command(argv[2]);
	data->cmd2 = get_command(argv[3]);
	data->flg1 = get_flags(argv[2]);
	data->flg1 = add_cmd(data->flg1, data->cmd1);
	data->flg2 = get_flags(argv[3]);
	data->flg2 = add_cmd(data->flg2, data->cmd2);
	data->fl1 = argv[1];
	data->fl2 = argv[4];
	//data->ct_fl1 = read_file(fd1);
	data->fd1 = fd1;
	data->fd2 = fd2;
	return (0);
}

char	*find_command(char **env, char *cmd)
{
	char	*path;
	char	*s;
	int	i;
	int	y;

	while (*env != NULL)
	{
		if (ft_strnstr(*env, "PATH=/", ft_strlen(*env))
			&& ft_strchr(*env, ':') > 0)
			break;
		env++;
	}
	i = 5;
	y = 0;
	s = ft_calloc(ft_strlen(*env) + 1, 1);
	while ((*env)[i])
	{
		if ((*env)[i] != ':')
			s[y++] = (*env)[i];
		else
		{
			s = ft_strjoin(s, "/");
			path = ft_strjoin(s, cmd);
			if (access(path, X_OK) == 0)
			{
				free(s);
				return (path);
			}
			free(s);
			free(path);
			s = ft_calloc(ft_strlen(*env) + 1, 1);
			y = 0;
		}
		i++;		
	}
	return (NULL);
}

void	first_cmd(int fd[2], t_data data)
{
	dup2(data.fd1, 0);
	dup2(fd[1], 1);
	close(fd[0]);
	close(fd[1]);
	execve(data.cmd1, data.flg1, data.env);
}

void	second_cmd(int fd[2], t_data data)
{
	dup2(fd[0], 0);
	dup2(data.fd2, 1);
	close(fd[0]);
	close(fd[1]);
	execve(data.cmd2, data.flg2, data.env);
}

int	pipex(t_data data)
{
	int	fd[2];
	int	cmd1;
	int	cmd2;

	if (pipe(fd) < -1)
		return (1);
	cmd1 = fork();
	if (cmd1 == 0)
		first_cmd(fd, data);
	cmd2 = fork();
	if (cmd2 == 0)
		second_cmd(fd, data);
	close(fd[0]);
	close(fd[1]);
	waitpid(cmd1, NULL, 0);
	waitpid(cmd2, NULL, 0);
	return (0);
}

int	main(int argc, char *argv[], char **env)
{
	t_data	data;

	//(void)argc;
	//(void)argv;
	//char **test = ft_split(argv[2], ' ');
	//execve(find_command(env, argv[1]), test, env);
	if (argc < 5)
		return (1);
	if (parsing(argv, &data))
		return (2);
	data.cmd1 = find_command(env, data.cmd1);
	if (data.cmd1 == NULL)
		return (3);
	data.cmd2 = find_command(env, data.cmd2);
	if (data.cmd2 == NULL)
		return (4);
	data.env = env;
	if (pipex(data))
		return (5);
	close(data.fd1);
	close(data.fd2);
	return (0);
}