#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <string.h>
#include <pthread.h>

typedef struct {
    const char *file1;
    const char *file2;
} ThreadArgs;

pthread_mutex_t mutex;
int activeThreads = 0;

void *compareFiles(void *arg) {
    ThreadArgs *args = (ThreadArgs *)arg;
    const char *file1 = args->file1;
    const char *file2 = args->file2;

    FILE *f1 = fopen(file1, "r");
    FILE *f2 = fopen(file2, "r");

    if (f1 == NULL || f2 == NULL) {
        perror("Ошибка при открытии файла");
        exit(EXIT_FAILURE);
    }

    int byteCount = 0;
    int char1, char2;
    int difference = 0;

    while (((char1 = fgetc(f1)) != EOF) & ((char2 = fgetc(f2)) != EOF)) {
        byteCount++;

        if (char1 != char2) {
            difference = 1;
            break;
        }
    }

    pthread_mutex_lock(&mutex);
    printf("ID потока: %lu\n", pthread_self());

    if (difference == 0 && char1 == EOF && char2 == EOF) {
        printf("Файлы %s и %s идентичны\n", file1, file2);
    } else {
        printf("Файлы %s и %s различаются\n", file1, file2);
    }

    printf("Сравнено байт: %d\n", byteCount);
    pthread_mutex_unlock(&mutex);

    pthread_exit(NULL);
}

void searchIdenticalFiles(const char *dir1, const char *dir2, int maxThreads) {
    DIR *dp1, *dp2;
    struct dirent *entry1, *entry2;
    pthread_t threads[maxThreads];

    if ((dp1 = opendir(dir1)) == NULL || (dp2 = opendir(dir2)) == NULL) {
        perror("Ошибка при открытии каталога");
        exit(EXIT_FAILURE);
    }

    char file1Path[256];
    char file2Path[256];

    while ((entry1 = readdir(dp1)) != NULL) {
        if (entry1->d_type == DT_REG) {

            snprintf(file1Path, sizeof(file1Path), "%s/%s", dir1, entry1->d_name);

            rewinddir(dp2);

            while ((entry2 = readdir(dp2)) != NULL) {
                if (entry2->d_type == DT_REG) {

                    snprintf(file2Path, sizeof(file2Path), "%s/%s", dir2, entry2->d_name);

                    ThreadArgs *args = (ThreadArgs *)malloc(sizeof(ThreadArgs));
                    if (args == NULL) {
                        perror("Ошибка при выделении памяти для args");
                        exit(EXIT_FAILURE);
                    }
                    args->file1 = strdup(file1Path);
                    args->file2 = strdup(file2Path);

                    pthread_create(&threads[activeThreads], NULL, compareFiles, (void *)args);
                    activeThreads++;

                    if (activeThreads >= maxThreads) {
                        for (int i = 0; i < activeThreads; ++i) {
                            pthread_join(threads[i], NULL);
                        }
                        activeThreads = 0;
                    }
                }
            }
        }
    }

    for (int i = 0; i < activeThreads; ++i) {
        pthread_join(threads[i], NULL);
    }

    closedir(dp1);
    closedir(dp2);

}

int main(int argc, char *argv[]) {
    if (argc < 4) {
        printf("Использование: %s <DIR1_PATH> <DIR2_PATH> <MAX_THREADS>\n", argv[0]);
        return EXIT_FAILURE;
    }

    const char *dir1Path = argv[1];
    const char *dir2Path = argv[2];
    int maxThreads = atoi(argv[3]);

    searchIdenticalFiles(dir1Path, dir2Path, maxThreads);
    return EXIT_SUCCESS;
}