#include <stdio.h>
#include <signal.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#define BUF 50

int fd[2];
FILE* config_file;
int father_pid;
int semaphor = 1;

int count_of_args(char* value);
int make_children(int num);
int check_files(int num, int children, char** files);
void SigWrite(int sig_num);
void SigRead(int sig_num);
void KillChild(int sig_num);

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

    if (argc < 2)
    {
        printf("Not enough arguments\n");
        return -1;
    }

    num_of_child = count_of_args(argv[1]);
    if (num_of_child < 2)
    {
	    printf("I need more children!!\n");
	    return -1;
    }

    make_children(num_of_child);

    return 0;
}

int make_children(int num)
{
    int i, j, child;
    pid_t pides[num - 1];
    pid_t pid;
    char conf_ch[10];

	printf("Starting make children\n");

    father_pid = getpid();

    pipe(fd);

    signal(SIGUSR1, SigWrite);
    signal(SIGUSR2, SigRead);
    signal(SIGTERM, KillChild);

    for (i = 1; i < num; i++)
    {
        switch (pid = (fork()))
        {
            case -1:
                printf("Killing all children\n");
                for (j = 0; j < (i-1); j++)
                    kill(pides[j], SIGTERM);
                printf("error fork\n");
                return -1;
                break;
            case 0:
		        printf("son num %d is born\n", i);
                sprintf(conf_ch, "config_%d", i);
                printf("%s\n", conf_ch);
              	config_file = fopen(conf_ch ,"r");
		        if (config_file == NULL);
		        {
			        semaphor = 0;
                    printf("The error is - %s\n", strerror(errno));
			        printf("No file %d found\n", i);
		        }
		        kill(father_pid, SIGUSR1);
		        printf("Signal %d  was sent!\n", i);
                while(1);
                break;
            default:
                pides[i-1] = pid;
                while(semaphor == 1);
                semaphor = 1;
                signal(SIGUSR1, SigWrite);
                break;
        }
    }


    for (i = 1; i < num; i++)
    {
        printf("send signal1\n");
        kill(pides[i-1], SIGUSR1);
	    while(semaphor == 1);
        read(fd[1], &child, sizeof(int));
        printf("Messag to son %d\n", child);
        if ((child > 0) && (child < num))
        {
            printf("send signal2\n");
            printf("son %d is reading\n", child);
            kill(pides[child-1], SIGUSR2);
	        while(semaphor == 0);
            signal(SIGUSR1, SigWrite);
            signal(SIGUSR2, SigRead);
        }
	    else if(child < (num - 1))
		    printf("No son %d\n",child);
	    printf("itteration %d done\n", i);
    }

    printf("KILL CHILDREN!!\n");
    for (i = 0; i < (num-1); i++)
        kill(pides[i], SIGTERM);

    close(fd[0]);
    close(fd[1]);

    return 0;
}

void SigWrite(int sig_num)
{
    int child, i = 0;
    char c;
    char byte[BUF];
    int no_message = -100;
    if(getpid() != father_pid)
    {
	    printf("Start WRITE!!!\n");
    if (semaphor == 1)
    {
        if(fscanf(config_file, "%d", &child) != 1)
        {
            printf("no message %d\n", no_message);
            write(fd[1], &no_message, sizeof(int));
        }
        else
        {
            c = fgetc(config_file);
            if (c == EOF)
                write(fd[1], &no_message, sizeof(int));
            else
            {
                write(fd[1], &child , sizeof(int));
                while (c != EOF)
                {
                    byte[i] = c;
                    if (i == BUF)
                    {
                        write(fd[1], byte, sizeof(char)*i);
                        i = 0;
                    }
                    else i++;
                    c = fgetc(config_file);
                }
                if (i != 0)
                    write(fd[1], byte, strlen(byte)*sizeof(char));
            }
        }
        fclose(config_file);
    }
    else
        write(fd[1], &no_message, sizeof(int));
	kill(father_pid, SIGUSR1);
    }
    else
        semaphor = 0;

}
void SigRead(int sig_num)
{
    char byte[1024];
    if(getpid() != father_pid)
    {
	    printf("START READ!!\n");
        read(fd[0], byte, 1024*sizeof(char));
        printf("%s\n", byte);
	kill(father_pid, SIGUSR2);
    }
    else
	    semaphor = 1;
}

void KillChild(int sig_num)
{
	close(fd[0]);
	close(fd[1]);
	exit(0);
}

int count_of_args(char* value)
{
    int num = 0;
    while (*value != '\0')
    {
        if ((*value < '0') || (*value > '9'))
            return -1;
        num = num * 10 + *value - '0';
        value++;
    }
    return num;
}

int check_files(int num, int children, char** files)
{
    FILE* file;
    int i;
    int value;
    char c;
    for (i = 0; i < num; i++)
    {
        file = fopen(files[i + 2], "r");
        if (file == NULL)
        {
            fclose(file);
            return -1;
        }
        if(fscanf(file, "%d", &value) == 1)
        {
            if ((value > children) || (value < 1))
            {
                fclose(file);
                return -1;
            }
        }
        else if ((c = fgetc(file)) != EOF)
        {
            fclose(file);
            return -1;
        }
        fclose(file);
    }
    return 0;
}