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

#define HELP printf("Usage : %s [-l | --lines] [-w | --words]  [-c | --chars] [FILES]\n", argv[0]);
#define TRY_HELP fprintf(stderr, "Faites `%s -h' ou `%s --help' pour plus d'informations.\n", argv[0], argv[0]);

enum {
  COUNT_CHARS = 1 << 0,
  COUNT_WORDS = 1 << 1,
  COUNT_LINES = 1 << 2
};

struct counter {
  size_t chars,
         words,
         lines;
};

/* Teste l'égalité entre deux chaines */
char equals(char *s, char *t) {
  while (*s) {
    if (*s != *t) {
      return 0;
    }
    ++s;
    ++t;
  }
  return !*t;
}

/* Affiche le comptage de mot, en accord avec les flags */
void display(size_t chars, size_t words, size_t lines, char *filename, char flags) {
  if (flags & COUNT_LINES) {
    printf("%d ", lines);
  }
  if (flags & COUNT_WORDS) {
    printf("%d ", words);
  }
  if (flags & COUNT_CHARS) {
    printf("%d ", chars);
  }
  if (filename) {
    printf("%s ", filename);
  }
  putchar('\n');
}

/* Compte caractères, mots et lignes dans le fichier filename, et affiche le résultat */
void read_file(char *filename, struct counter *global, unsigned char flags) {
  FILE *file;
  char must_close = 0; /* stdin ne sera pas fermé, tout autre fichier le sera */
  size_t chars = 0,
         words = 0,
         lines = 0;
  char inWord = 0;
  char c;
  
  if (!filename || equals(filename, "-")) {
    file = stdin;
  } else {
    file = fopen(filename, "r");
    if (!file) {
      fprintf(stderr, "Erreur : fichier inexistant (%s)\n", filename);
      return;
    } else {
      must_close = 1;
    }
  }

  while ((c = getc(file)) != EOF) {
    ++chars;
    if (c == '\n') {
      ++lines;
    }
    if (c == '\n' || c == ' ' || c == '\t' || c == '\r') {
      if (inWord) {
        inWord = 0;
        ++words;
      }
    } else if (!inWord) {
      inWord = 1;
    }
  }

  /* Pourrait être fait plus tard, mais je préfère fermer le fichier dès que je n'en ai plus besoin */
  if (must_close) {
    fclose(file);
  }

  if (inWord) {
    ++words;
  }

  global->chars += chars;
  global->words += words;
  global->lines += lines;

  display(chars, words, lines, filename, flags);
}

int main(int argc, char *argv[]) {
  int i;
  unsigned char flags = 0;
  char *opt;
  char take_all = 0; /* Après un --, on considère tout comme un fichier */
  unsigned char files = 0; /* Compteur de fichiers */
  struct counter count = {0, 0, 0};

  for (i = 1; i < argc; ++i) {
    opt = argv[i];
    if (*opt == '-' && *(opt + 1)) { /* Il s'agit d'une option (- = stdin) */
      ++opt;
      if (*opt == '-') { /* Option longue */
        ++opt;
        if (!*opt) { /* -- = fin des options */
          break;
        } else if (equals(opt, "chars")) {
          flags |= COUNT_CHARS;
        } else if (equals(opt, "words")) {
          flags |= COUNT_WORDS;
        } else if (equals(opt, "lines")) {
          flags |= COUNT_LINES;
        } else if (equals(opt, "help")) {
          HELP;
          return EXIT_SUCCESS;
        } else {
          fprintf(stderr, "Option non reconnue : '--%s'\n", opt);
          TRY_HELP;
          return EXIT_FAILURE;
        }
      } else { /* Option courte */
        while (*opt) {
          switch (*opt) {
            case 'c': flags |= COUNT_CHARS; break;
            case 'w': flags |= COUNT_WORDS; break;
            case 'l': flags |= COUNT_LINES; break;
            case 'h':
              HELP;
              return EXIT_SUCCESS;
            default:
              fprintf(stderr, "Option invalide -- '%c'\n", *opt);
              TRY_HELP;
              return EXIT_FAILURE;
            break;
          } /* end switch */
          ++opt;
        } /* end while */
      } /* end if */
    } /* end if */
  } /* end for */

  if (!flags) {
    flags = COUNT_CHARS | COUNT_WORDS | COUNT_LINES;
  }

  for (i = 1; i < argc; ++i) {
    if (take_all || *argv[i] != '-') { /* C'est un fichier */
      read_file(argv[i], &count, flags);
      ++files;
    } else { /* Ce n'est pas un fichier */
      if (equals(argv[i], "--")) { /* -- : mode take_all */
        take_all = 1;
      }
    }
  }

  if (!files) {
    read_file(NULL, &count, flags);
  } else if (files > 1) { /* Si plus d'un fichier, on affiche le total */
    display(count.chars, count.words, count.lines, "total", flags);
  }

  return EXIT_SUCCESS;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

#ifndef isascii
# define isascii(c)    1
#endif

#define ISBLANK(c) (isascii(c) && isblank(c))
#define ISALNUM(c) (isascii(c) && isalnum(c))

#define SHORT_OPT   0
#define LONG_OPT    1

typedef char bool;

typedef struct opt_ss {
	bool car;
	bool line;
	bool word;
	bool help;
	bool errno;
} opt_s;

typedef struct res_count_ss {
	unsigned line;
	unsigned car;
	unsigned word;
} res_count_s;

void get_opt(char * arg, opt_s * opt, bool stat) {
	while (*arg) {
		switch (*arg) {
			case 'c':
				if ((stat == LONG_OPT && strcmp("char", arg) == 0) ||
					stat == SHORT_OPT)
					opt->car = 1;
				break;
			case 'l':
				if ((stat == LONG_OPT && strcmp("line", arg) == 0) ||
					stat == SHORT_OPT)
					opt->line = 1;
				break;
			case 'w':
				if ((stat == LONG_OPT && strcmp("word", arg) == 0) ||
					stat == SHORT_OPT)
					opt->word = 1;
				break;
			case 'h':
				if ((stat == LONG_OPT && strcmp("help", arg) == 0) ||
					stat == SHORT_OPT)
					opt->help = 1;
				break;
			default:
				opt->errno = 1;
				break;
		}
		if (stat == LONG_OPT)
			return;
		arg++;
	}
}

void get_args(int ac, char *av[], opt_s * opt, char const * (*name_f)) {
	int i;
	
	for (i = 1; i < ac; i++) {
		if (av[i][0] == '-') {
			if (av[i][1] == '-')
				get_opt(av[i]+2, opt, LONG_OPT);
			else
				get_opt(av[i]+1, opt, SHORT_OPT);
		}
		else if (*name_f == NULL)
			*name_f = av[i];
		else {
			fputs("Erreur: Plusieurs fichiers passes en argument.\n", stderr);
			opt->errno = 1;
			return;
		}
	}
	
	if (ac <= 1 || (ac == 2 && name_f != NULL)) {
		opt->car = 1;
		opt->line = 1;
		opt->word = 1;
		return;
	}
}


void usage(FILE * f) {
	fputs("usage: zwc [-w | -l | -c | -h] [fichier]\n", f);
}

res_count_s count(FILE * f) {
	res_count_s res = { 1, 0, 0 };
	int c;
	bool isword = 0;
	
	while ((c = fgetc(f)) != EOF) {
		if ((ISBLANK(c) || c == '\n') && isword) {
			isword = 0;
			res.word++;
		}	
		else if (ISALNUM(c))
			isword = 1;
		
		if (c == '\n') {
			res.line++;
			continue;
		}
		res.car++;
	}
	
	if (isword)
		res.word++;
	
	return res;
}

#define ESSE(s)  (&"s"[(s) <= 1])

void print_opt(opt_s opt, res_count_s res) {
	if (opt.help)
		usage(stdout);
	if (opt.line)
		printf("%u ligne%s\n", res.line, ESSE(res.line));
	if (opt.word)
		printf("%u mot%s\n", res.word, ESSE(res.word));
	if (opt.car)
		printf("%u caractere%s\n", res.car, ESSE(res.car));
}

FILE * check_file(char const * name) {
	FILE * f;
	if (name == NULL)
		f = stdin;
	else {
		f = fopen(name, "r");
		if (f == NULL)
			perror(name);
	}
	return f;
}

void zwc(int ac, char *av[]) {
	FILE * f = NULL;
	char const * name_f = NULL;
	opt_s opt = { 0, 0, 0, 0, 0 };
	res_count_s res;
	
	get_args(ac, av, &opt, &name_f);
	
	if (opt.errno) {
		usage(stderr);
		return;
	}
	
	f = check_file(name_f);
	if (f == NULL)
		return;
	
	res = count(f);
	print_opt(opt, res);
}

int	main(int ac, char *av[]) {
	zwc(ac, av);
	return EXIT_SUCCESS;
}