#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>

/* Fonction : Is In Set
	Retour : un int valant 1 ou 0.
	Parametre : Un caractere et la chaine Charset contenant les separateurs.
	Description : Detecte si le caractere "char c" sur lequel on se trouve est un separateur ou non (donc fait parti de la chaine charset ou non). On renvoi 1 si il en fait
	parti , sinon 0 .
 */
int		is_in_set(char c, char *charset)
{
	while (*charset)
	{
		if (*charset == c)
			return (1);
		++charset;
	}
	return (0);
}

/* Fonction : Leng
	Retour : Un int >= 1.
	Parametre : Notre chaine a decouper "str" et notre chaine de separateurs "charset".
	Description : La fonction Leng compte la taille d'un mot. On avance sur la chaine str tant que l'on rencontre pas de separateur , et on renvoi la taille de cette nouvelle portion. (qui nous sert pour le malloc)
 */

int		leng(char *str, char *charset)
{
	int count;
	count = 1;
	while(*str && is_in_set(*str, charset) == 0)
	{
		++str;
		count++;
	}
	return (count);
}

/* Fonction : Count Space
	Retour : Un int >= 1
	Parametre : Notre chaine a decouper "str" et notre chaine de separateurs "charset".
	Description : La fonction count space , compte notre nombre de mots au total pour qu'on puisse malloc toutes nos dimensions . Il avance dans la chaine str, si il rencontre un separateur , il compte donc un mot (une dimension), puis il skip tout les autres separateurs si il y en a plusieurs a la suite . Et il continue ainsi ...
 */

int		count_space(char *str, char *charset)
{
	int count;

	count = 0;
	while (*str)
	{
		if (is_in_set(*str, charset))
		{
			while (*str && is_in_set(*str, charset))
				++str;
			++count;
		}
		else
			++str;
	}
	return (++count);
}

char	**ft_split(char *str, char *charset)
{
	char	**tab;
	char	*temp_str; // chaine tampon
	int		i; // compteur de lettres
	int		y; // compteurs de mots

	// on malloc notre nombre de mots (donc dimension) en comptant nos mots avec count_space , on rajoute 1 pour la dimension vide a la fin.
	tab = (char**)malloc(sizeof(char*) * count_space(str, charset) + 1);
	y = 0;
	while (*str) // tant qu'on a pas traite toute la chaine.
	{
		if (is_in_set(*str, charset)) // si on est sur un separateur  on les skip tous. Ca signifie egalement qu'on arrive sur un nouveau mot !
			++str;
		else // Ici du coup si on est pas sur un separateur on effectue la copie !
		{
			i = 0; // on reset notre compteur de lettre
			temp_str = (char*)malloc(sizeof(char) * leng(str, charset)); // on malloc les lettres de notre mot  avec Leng , qui compte notre nombre de lettre jusqu'au prochain separateur
			while (*str && is_in_set(*str, charset) == 0) // tant qu'on est pas sur un separateur on copie a fond
				temp_str[i++] = *(str++);
			temp_str[i] = 0; // on met le \0 des que on a vu un separateur
			tab[y] = temp_str; // on le copie dans notre tableau
			++y; // on passe au mot suivant
		}
	}
	tab[y] = 0; // quand notre chaine est fini on oublie pas de mettre notre \0 dans notre derniere dimension vide .
	return (tab);
}



/* MAIN DE TEST : ON S'EN FOU*/
int main(int argc, char **argv)
{
	char **tab;
	int j;

	j = 0;

	if(argc != 3)
		return(0);
	tab = ft_split(argv[1],argv[2]);
	while(tab[j] != 0)
	{
		printf("%s\n", tab[j]);
		j++;
	}
	return(0);
}