#include <pthread.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
       
unsigned int licznik = 0;
unsigned int linia = 1;
unsigned int liczba_watkow;
pthread_rwlock_t licznik_lock = PTHREAD_RWLOCK_INITIALIZER;
pthread_mutex_t cond_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

pthread_mutex_t cond2_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond2 = PTHREAD_COND_INITIALIZER;

typedef struct {
     int fd;
     unsigned int linia;
} worker_arg; 

void *worker_t(void *arg){
    worker_arg *wa = (worker_arg *)arg;
    char buf[128];
#ifdef DEBUG    
    printf("worker %d %d\n",wa->fd,wa->linia);
    fflush(stdout);
#endif        
    while (1) {
        pthread_testcancel();
#ifdef DEBUG    
        printf("worker %d lockwait\n",wa->linia);
	fflush(stdout);
#endif        
	pthread_mutex_lock(&cond_mutex);

#ifdef DEBUG    
        printf("worker %d lock\n",wa->linia);
	fflush(stdout);
#endif        	
	while (wa->linia!=linia) { 
	    if (pthread_cond_wait(&cond,&cond_mutex)!=0) {
		perror("pthread_cond_wait");
		exit(-1);
	    }
#ifdef DEBUG    
	    printf("worker %d cond\n",wa->linia);
	    fflush(stdout);
#endif        	
	};
#ifdef DEBUG    	
	printf("in worker %d\n",wa->linia);
	fflush(stdout);
#endif        	
	
	if (fgets(buf,128,stdin) != 0) {
	    write(wa->fd,buf,strlen(buf));
	    pthread_rwlock_wrlock(&licznik_lock);
	    licznik++;
	    pthread_rwlock_unlock(&licznik_lock);
	} else {
		pthread_mutex_unlock(&cond_mutex);
		pthread_cond_signal(&cond2);
		return 0;
	}
	
        if (linia == liczba_watkow)
	    linia = 1;
        else 
	    linia++;
	
	sleep(1);
#ifdef DEBUG    
	printf("worker %d switch\n",wa->linia);
	fflush(stdout);
#endif        	
	
	pthread_mutex_unlock(&cond_mutex);
	pthread_cond_broadcast(&cond);
    }
};

int main (int argc, char **argv) {
    pthread_t *tidy;
    int *fds;
    int n;
    
    if (argc<2) {
	fprintf(stderr,"%s: plik1 (..) plikn\n",argv[0]);
	return -1;
    };
    
    liczba_watkow = argc-1;
    
    tidy = (pthread_t *)malloc(sizeof(pthread_t)*(liczba_watkow));
    if (tidy==0) {
	perror("malloc");
	return -1;
    };
    
    fds = (int *)malloc(sizeof(int)*(liczba_watkow));
    if (fds==0) {
	perror("malloc");
	return -1;
    };
    
    pthread_mutex_lock(&cond_mutex);
    pthread_mutex_lock(&cond2_mutex);

    for (n=0;n<liczba_watkow;n++) {
	worker_arg *wa = (worker_arg *)malloc (sizeof (worker_arg));
	if (wa==0){
	    perror("malloc");
	    return -1;
	}
	wa->linia=n+1;
	wa->fd=open(argv[n+1],O_WRONLY|O_CREAT|O_TRUNC,S_IWUSR|S_IRUSR);
	if (wa->fd==-1) {
	    perror("open");
	    return -1;
	}
	if (pthread_create(&(tidy[n]),0,worker_t,wa)!=0) {
	    perror("pthread_create");
	    return -1;
	}
    };

    pthread_mutex_unlock(&cond_mutex);
    
    pthread_cond_broadcast(&cond);

    struct timespec tm;
    tm.tv_sec = 10;
    tm.tv_nsec = 0;
    
    pthread_cond_reltimedwait_np(&cond2,&cond2_mutex,&tm);
#ifdef DEBUG    
    printf("Timeout!\n");
    fflush(stdout);
#endif
    
    pthread_mutex_unlock(&cond2_mutex);
    
    for (n=0;n<liczba_watkow;n++) 
	pthread_cancel(tidy[n]);

#ifdef DEBUG    
    printf("Cancel!\n");
    fflush(stdout);
#endif
        
    for (n=0;n<liczba_watkow;n++) 
	close(fds[n]);
    
    pthread_rwlock_rdlock(&licznik_lock);
    printf("Liczba linii: %d\n",licznik);
    pthread_rwlock_unlock(&licznik_lock);

    return 0;
}