// ICS 53 - Lab 8 - Search
// grep -nFHr
// n = print line number
// F = fixed string (search for specific string)
// H = print file name for each match
// r = read files under each directory recursively

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

#define _FILE 100
#define _DIR 200
#define NUM_THREADS 200

struct stat sb;


/* Functions that will read in files / patterns when user runs the program */
int num_files = 0;
char *pattern;
struct Files
{
    char *f_name;
    int status; // can = either FILE or DIR
};
struct Files arg_files[200];

struct thread_struct
{
    char file_name[256];
    int thread_id;
};
struct thread_struct thread_array[200];

void strip_newline(char *input)
{
    int len = strlen(input) - 1;
    if(input[len] == '\n')
       input[len] = '\0';
}

int get_num_files(int *file_num)
{
    if(*file_num > 2)
        num_files = *file_num - 2;
    return num_files;
}

void check_args()
{
    if(num_files == 0)
    {
        arg_files[0].f_name = "/home";
        return;
    }
}

void get_pattern(char *argv[])
{
    if(argv[1] != NULL)
        pattern = argv[1];
    else {
        printf("No pattern given\n");
        exit(1);
    }
}

void load_names(char *argv[])
{
    check_args();
    int i;
    for(i = 0; i < num_files; ++i)
    {
        arg_files[i].f_name = argv[i+2];
    }
}

// determines if the file name passed in is a directory
// returns DIRECTORY if it is, otherwise returns 0
int is_dir(char *file_name)
{
    stat(file_name, &sb);
    if(S_ISDIR(sb.st_mode))
        return _DIR;
    return 0;
}

// determines if the file name passed in is a regular file
// returns FILE if it is, otherwise returns 0
int is_file(char *file_name)
{
    stat(file_name, &sb);
    if(S_ISREG(sb.st_mode))
        return _FILE;
    return 0;
}

void load_and_get_pattern(char *argv[])
{
    get_pattern(argv);
    load_names(argv);
}

void get_status()
{
    int i;
    for(i = 0; i < num_files; ++i) {
        if(is_file(arg_files[i].f_name) == _FILE)
            arg_files[i].status = _FILE;
        else
            arg_files[i].status = _DIR;
    }
}

void load_everything(char *argv[])
{
    load_and_get_pattern(argv);
    get_status();
}

/* Functions that will call system commands */

void check_file_for_pattern(char *temp, char *file_name,int ln, int id)
{
    char *found = strstr(temp, pattern);
    if(found) {
        strip_newline(temp);
        printf("%d %s %s %d\n",id, file_name, temp, ln);
    }
}


void parse_file(FILE* fp, char *file_name, int id)
{
    char temp[1024];
    int line_num = 1;
    while(fgets(temp, 1024, fp) != NULL) {
        check_file_for_pattern(temp, file_name, line_num, id);
        ++line_num;
    }
}

void * grep_file(void * arg)
{
    //printf("Thread created\n");
    struct thread_struct *thread = arg;
    char file_name[256];
    strcpy(file_name,thread->file_name);
    int id = thread->thread_id;
    printf("File name: %s\n", file_name);
    /*
    FILE* fp = fopen(file_name, "r");
    if(!fp) {
        printf("Couldn't open file\n");
        return NULL; }
    parse_file(fp, file_name, id);
    fclose(fp);
    return NULL;
    */
    return NULL;
}

void create_file_thread(char * file_name, int i)
{
    pthread_t threads[NUM_THREADS];
    strcpy(thread_array[i].file_name, file_name);
    thread_array[i].thread_id = i + 1;
    int rc;
    printf("thread file: %s\n", thread_array[i].file_name);
    if((rc = pthread_create(&threads[i], NULL,
                grep_file, &thread_array[i]))) {
        fprintf(stderr, "ERROR: Return code from pthread_create() is %d\n", rc);
        exit(-1);
    }
}

void grep_directory(char *dir_name, int id)
{
    DIR *p_dir = NULL; // pointer to a directory
    struct dirent *p_entry; // pointer to a directory entry
    if(!(p_dir = opendir(dir_name)))
    {
        fprintf(stderr, "Error while opening directory %s: %s\n", dir_name, strerror(errno));
        return;
    }
    while((p_entry = readdir(p_dir)))
    {
        char entry_path[250];
        snprintf(entry_path, 249, "%s/%s", dir_name, p_entry->d_name);
        if(is_dir(entry_path) == _DIR) {
            if(strcmp(p_entry->d_name, ".") != 0 && strcmp(p_entry->d_name, "..") != 0)
                grep_directory(entry_path, id);
        } else {
            create_file_thread(entry_path, id);
        }
    }
    closedir(p_dir);
}


void print_results(char *file_name, int i)
{
   if(is_dir(file_name) == _DIR)
        grep_directory(file_name,i);
    else if(is_file(file_name) == _FILE) {
        create_file_thread(file_name, i);
    }
}

void grep_and_print_directories()
{
    for(long i = 0; i < num_files; ++i) {
        print_results(arg_files[i].f_name, i);
    }
}


int main(int argc, char *argv[])
{
    get_num_files(&argc);
    load_everything(argv);
    grep_and_print_directories();
    pthread_exit(NULL);
    return 0;
}