#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <sys/mman.h>
#include <errno.h>
#include <pthread.h>
#include <ctype.h>
#include <getopt.h>


struct args_struct{
    int tred;
    int iterations;
    int json;
    size_t words;
};
struct args_struct args;
#include "cJSON/cJSON.h"
#include "args_parser.h"


#define DEBUG 0
#define jemalloc 0

#if defined(DEBUG) && DEBUG > 1
 #define DEBUG_PRINT(fmt, args...) fprintf(stderr, "DEBUG: %s:%d:%s(): " fmt, \
    __FILE__, __LINE__, __func__, ##args)
#elif DEBUG == 1
 #define DEBUG_PRINT(fmt, args...) fprintf(stderr, "DEBUG: %d:%s(): " fmt, \
    __LINE__, __func__, ##args)
#else
 #define DEBUG_PRINT(fmt, args...) /* Don't do anything in release builds */
#endif
 
#define BLOCK_SIZE (1024ULL*1024ULL*1024ULL*8) 

uint32_t test_patterns[] = {0x00000000, 0xFFFFFFFF, 0xAAAAAAAA, 0x55555555};

char* test_name[] = {"increment", "ones test", "zeros test"};
int pretest_delay = 0;
int test_list[] = {2,3,4};
#define bool unsigned char



struct test_info{
    int error;
    int number_addresses;
};
struct error_info{
    uint32_t error_adres;
    uint32_t expected;
    uint32_t actual;
    struct error_info* error_info_next;
};
struct test_local_stats{
    int error_int;
    struct error_info* error_info;
    struct error_info* error_info_end;
};
struct test_stats{
    int len;
    struct test_local_stats* test_local_stats[];
};
struct struct_info{
    struct test_info* test_info;
    struct test_stats* test_stats;
};


struct struct_info info;

struct tred_pizdec{
    uint32_t* mem;
    size_t words_stop;
    int id;
    size_t words_start;
    int return_error;
    bool test_tip;
    struct test_stats* test_stats;
    
};

#include "multi_tred.h"

// Получить доступную память из /proc/meminfo
unsigned long int get_mem_available_mb() {
    FILE* f = fopen("/proc/meminfo", "r");
    if (!f) return 0;
    char line[256];
    unsigned long int available = 0;
    while (fgets(line, sizeof(line), f)) {
        if (sscanf(line, "MemAvailable: %lu kB", &available) == 1) break;
    }
    fclose(f);
    if (!args.json){
        printf("mem Gb: %lu\n",(available-available/100*10)/1024/1024);
        printf("mem MB: %lu\n",(available-available/100*10)/1024);
    }
    return (available - available/100*20)*1024;
}


void meseng_proses(int test_tipe, int p){
    if (args.json != 1){
        if (test_tipe == 1){
            printf("\rЗапушен патерн 0x%08X", test_patterns[p]);
            fflush(stdout);
        }
        else{
            printf("\rЗапушен патерн %s", test_name[test_tipe-2]);
            fflush(stdout);
        }
    }
}
void meseng_test_and_slip(){
    if (pretest_delay!= 0){
        printf("\rЖду            ");
        fflush(stdout);
        usleep(pretest_delay*1000000);
    }
    if (args.json != 1){
        printf("\r-- Проверяю   ");
        fflush(stdout);
    }
}

void test_patern(struct tred_pizdec** meta,unsigned long* thread, int tred, int* err, int p, int test_tipe){
    meseng_proses(test_tipe, p);
    for (bool i = 0;(i != tred); i++){// test
        meta[i]->id = p;
        meta[i]->test_tip = test_tipe;
        DEBUG_PRINT("words_stop: %zu\n",meta[i]->words_stop);
        DEBUG_PRINT("words_start:%zu\n",meta[i]->words_start);
        pthread_create(&thread[i], NULL, fill_pattern_multi_tred, (void*)meta[i]);
        //pthread_join(thread[i], NULL);
    }
    for (bool i = 0;(i != tred); i++) //sink tred
        pthread_join(thread[i], NULL);
    //fill_pattern(mem, words, test_patterns[p]);
    meseng_test_and_slip();
    //int err = check_pattern(mem, words, test_patterns[p]);
    for (bool i = 0;(i != tred); i++){// test
        pthread_create(&thread[i], NULL, check_pattern_multi_tred, (void*)meta[i]);
        //pthread_join(thread[i], NULL);
    }
    for (bool i = 0;(i != tred); i++){ //sink tred
        pthread_join(thread[i], NULL);
        *err += meta[i]->return_error;
    }
    if (!args.json){
        if (*err == 0){
            printf("\rOK\n");
            fflush(stdout);
        }
        else printf("Errors: %d\n", *err);
    }
}

void json_create(struct tred_pizdec** meta){
    cJSON *main_ob = cJSON_CreateObject();
        //cJSON_AddItemToArray(main_Array, main_ob);
        cJSON *test_ob = cJSON_CreateObject();
        cJSON_AddItemToObject(main_ob, "test", test_ob);
            char* putaa = malloc(11);
            unsigned int error_int=0;
            for (int i = 0;i != sizeof(test_patterns)/sizeof(test_patterns[0]); ++i){
                sprintf(putaa, "0x%08X",test_patterns[i]);
                cJSON *error_ob = cJSON_CreateObject();
                cJSON *error_info_array = cJSON_CreateArray();
                unsigned int error_int_local=0;
                for (int t=0; t != args.tred; t++){
                    struct error_info* error_info_A = meta[t]->test_stats->test_local_stats[i]->error_info;
                    error_int_local += meta[t]->test_stats->test_local_stats[i]->error_int;
                    while(NULL != error_info_A){
                        //for(){};
                        //p += meta[t]->return_error;
                        cJSON *error_local_info_array = cJSON_CreateObject();
                        {
                            char* putaa = malloc(16);
                            sprintf(putaa, "%p",(void*)&error_info_A->error_adres);
                            cJSON *error_adres = cJSON_CreateString(putaa);
                            cJSON_AddItemToObject(error_local_info_array, "error_adres", error_adres);
                        }
                        {
                            char* putaa = malloc(11);
                            sprintf(putaa, "0x%08X",error_info_A->expected);
                            cJSON *expected = cJSON_CreateString(putaa);
                            cJSON_AddItemToObject(error_local_info_array, "expected", expected);
                        }
                        {
                            char* putaa = malloc(11);
                            sprintf(putaa, "0x%08X",error_info_A->actual);
                            cJSON *actual = cJSON_CreateString(putaa);
                            cJSON_AddItemToObject(error_local_info_array, "actual", actual);
                        }
                        cJSON_AddItemToArray(error_info_array, error_local_info_array);
                        error_info_A = error_info_A->error_info_next;
                    }
                }
                error_int += error_int_local;
                cJSON *error_int_j = cJSON_CreateNumber(error_int_local);
                    cJSON_AddItemToObject(error_ob, "error", error_int_j);
                    cJSON_AddItemToObject(error_ob, "error_info", error_info_array);
                cJSON_AddItemToObject(test_ob, putaa, error_ob);
                
            }
            for (int i = 0;i != sizeof(test_name)/sizeof(test_name[0]); ++i){
                int error_int_local=0;
                cJSON *error_int_j = cJSON_CreateNumber(error_int_local);
                cJSON *error_ob = cJSON_CreateObject();
                cJSON *error_info_array = cJSON_CreateArray();
                    cJSON_AddItemToObject(error_ob, "error", error_int_j);
                    cJSON_AddItemToObject(error_ob, "error_info", error_info_array);
                cJSON_AddItemToObject(test_ob, test_name[i], error_ob);
                
            }
            free(putaa);
        cJSON *test_info_ob = cJSON_CreateObject();
            cJSON_AddItemToObject(main_ob, "test_info", test_info_ob);
                cJSON *error_int_j = cJSON_CreateNumber(error_int);
                    cJSON_AddItemToObject(test_info_ob, "error", error_int_j);
                cJSON *message_str;
                    if (error_int)
                        message_str = cJSON_CreateString("Тест пройден неудачно!");
                    else
                        message_str = cJSON_CreateString("Тест пройден успешно!");
                    cJSON_AddItemToObject(test_info_ob, "message", message_str);
                cJSON *number_addresses_int = cJSON_CreateNumber(args.words);
                    cJSON_AddItemToObject(test_info_ob, "number_addresses", number_addresses_int);
                cJSON *mod_test_str = cJSON_CreateString("user_mod");
                    cJSON_AddItemToObject(test_info_ob, "mod_test", mod_test_str);
        char *string = cJSON_Print(main_ob);
        printf("%s", string);
        
        //cJSON *volume_js = cJSON_CreateNumber(volume);
        //cJSON_AddItemToObject(main_ob, "volume", volume_js);
        //cJSON_AddItemToObject(main_ob, "content", content_Array);

}




int main(int argc, char *argv[]){
    if (mlockall(MCL_CURRENT | MCL_FUTURE) != 0) {
        perror("mlockall ошибка!\nВозможно недостаточно прав!\n");
        return 1;
    }
    
    args.tred = -1;
    args.iterations = 1;
    args.json = 0;

    aaa(&argc, argv, &pretest_delay);

    if (!args.json)
        printf("threads: %d\n", args.tred);
    
    unsigned long int mem_size = get_mem_available_mb();
    size_t words = mem_size / sizeof(uint32_t);
    args.words = words;
    uint32_t *mem = malloc(mem_size);
    if (!mem) {
        printf("Память не выделена!");
        return 1;
    }
    //struct tred_pizdec* meta[];
    //pthread_t thread[];
    int err = 0, iterations = args.iterations;
    struct tred_pizdec** meta = malloc(sizeof(struct tred_pizdec) * args.tred);
    pthread_t *thread = malloc(sizeof(pthread_t) * args.tred);
    if (!args.json)
        printf("iterations: %i\n", iterations);
    for (;iterations != 0; iterations--){
        if (args.tred != -1){
            for (bool i = 0;(i != args.tred); i++){// test
                meta[i] = malloc(sizeof(struct tred_pizdec));
                meta[i]->test_stats = malloc(sizeof(struct test_stats) + 
                (sizeof(test_list)/sizeof(test_list[0]) + sizeof(test_patterns)/sizeof(test_patterns[0])) * sizeof(struct test_local_stats*)
                );
                meta[i]->test_stats->len = (sizeof(test_list)/sizeof(test_list[0]) + sizeof(test_patterns)/sizeof(test_patterns[0]));
                //meta[i]->test_stats = malloc(meta[i]->test_stats->len);
                for (int m=0;m != meta[i]->test_stats->len;m++){
                    meta[i]->test_stats->test_local_stats[m] = malloc(sizeof(struct test_local_stats));
                    meta[i]->test_stats->test_local_stats[m]->error_int = 0;
                    meta[i]->test_stats->test_local_stats[m]->error_info = NULL;
                    //meta[i]->test_stats->test_local_stats[m]->
                }
                meta[i]->mem = mem;
                meta[i]->words_stop = words/args.tred*(i+1);
                meta[i]->words_start = i * words/args.tred;
                meta[i]->return_error = 0;
                DEBUG_PRINT("words_stop: %zu\n",meta[i]->words_stop);
                DEBUG_PRINT("words_start:%zu\n",meta[i]->words_start);
            }
            for (size_t p = 0; p < sizeof(test_patterns)/sizeof(test_patterns[0]); ++p){
                test_patern(meta, thread, args.tred, &err, p, 1);// Основные паттерны 0x00000000, 0xFFFFFFFF, 0xAAAAAAAA, 0x55555555
            }
            for (int test_list_id = 0; test_list_id < sizeof(test_list)/sizeof(test_list[0]); ++test_list_id){
                test_patern(meta, thread, args.tred, &err, 0, test_list[test_list_id]);
            }
            free(mem);
            if (args.json)
                json_create(meta);
            for (bool i = 0;(i != args.tred); i++)
                free(meta[i]);
        }
        else{
            struct tred_pizdec meta;
            meta.mem = mem;
            meta.words_stop = words;
            meta.words_start = 0;
            meta.test_tip = 1;
            // Основные паттерны 0x00000000, 0xFFFFFFFF, 0xAAAAAAAA, 0x55555555
            for (size_t p = 0; p < sizeof(test_patterns)/sizeof(test_patterns[0]); ++p){
                //struct tred_pizdec meta = malloc(sizeof(struct tred_pizdec));
                meta.id = p;
                meseng_proses(meta.test_tip, meta.id);
                fill_pattern_multi_tred((void*)&meta);
                //fill_pattern(mem, words, test_patterns[p]);
                meseng_test_and_slip();
                check_pattern_multi_tred((void*)&meta);
                err = meta.return_error;
                //err += check_pattern(mem, words, test_patterns[p]);
                free(mem);
                if (!args.json){
                    if (err == 0){ 
                        printf("\rOK\n");
                        fflush(stdout);
                    }
                    else printf("\nErrors: %d\n", err);
                }
            }
            for (int test_list_id = 0; test_list_id < sizeof(test_list)/sizeof(test_list[0]); ++test_list_id){
                meta.test_tip = test_list[test_list_id];
                meseng_proses(meta.test_tip, meta.id);
                fill_pattern_multi_tred((void*)&meta);
                meseng_test_and_slip();
                check_pattern_multi_tred((void*)&meta);
                if (!args.json){
                    if(meta.return_error == 0){
                        printf("\rOK\n");
                        fflush(stdout);
                    }
                    else printf("Errors: %d\n", meta.return_error);
                }
                if (!args.json){
                    if (err == 0){
                        printf("\rOK");
                        fflush(stdout);
                    }
                    else printf("\nErrors: %d\n", err);
                }
            }
        }
    }
    //if(args.json)
    //for (bool i = 0;(args.tred != -1 || i != args.tred); i++)
    //    free(meta[i]);
    return 0;
}