/*
 *  Copyright (C) 2017 - This file is part of libecc project
 *
 *  Authors:
 *      Ryad BENADJILA <ryadbenadjila@gmail.com>
 *      Arnaud EBALARD <arnaud.ebalard@ssi.gouv.fr>
 *      Jean-Pierre FLORI <jean-pierre.flori@ssi.gouv.fr>
 *
 *  Contributors:
 *      Nicolas VIVET <nicolas.vivet@ssi.gouv.fr>
 *      Karim KHALFALLAH <karim.khalfallah@ssi.gouv.fr>
 *
 *  This software is licensed under a dual BSD and GPL v2 license.
 *  See LICENSE file at the root folder of the project.
 */
#include <libecc/external_deps/print.h>
#include <libecc/utils/utils.h>
#include <libecc/libsig.h>

/*
 * Use extern declarations to avoid including
 * ec_self_tests_core.h, which has all fixed
 * test vectors definitions. We only need the
 * three functions below.
 */
extern ATTRIBUTE_WARN_UNUSED_RET int perform_known_test_vectors_test(const char *sig, const char *hash, const char *curve);
extern ATTRIBUTE_WARN_UNUSED_RET int perform_random_sig_verif_test(const char *sig, const char *hash, const char *curve);
extern ATTRIBUTE_WARN_UNUSED_RET int perform_performance_test(const char *sig, const char *hash, const char *curve);

/* Tests kinds */
#define KNOWN_TEST_VECTORS      (1)
#define RANDOM_SIG_VERIF        (1 << 2)
#define PERFORMANCE             (1 << 3)

typedef struct {
        const char *type_name;
        const char *type_help;
        unsigned int type_mask;
} test_type;

static const test_type test_types[] = {
        {
         .type_name = "vectors",
         .type_help = "Perform known test vectors",
         .type_mask = KNOWN_TEST_VECTORS,
         },
        {
         .type_name = "rand",
         .type_help = "Perform random sign/verify tests",
         .type_mask = RANDOM_SIG_VERIF,
         },
        {
         .type_name = "perf",
         .type_help = "Performance tests",
         .type_mask = PERFORMANCE,
         },
};

ATTRIBUTE_WARN_UNUSED_RET static int perform_tests(unsigned int tests, const char *sig, const char *hash, const char *curve)
{
        /* KNOWN_TEST_VECTORS tests */
        if (tests & KNOWN_TEST_VECTORS) {
                if (perform_known_test_vectors_test(sig, hash, curve)) {
                        goto err;
                }
        }
        /* RANDOM_SIG_VERIF tests */
        if (tests & RANDOM_SIG_VERIF) {
                if (perform_random_sig_verif_test(sig, hash, curve)) {
                        goto err;
                }
        }
        /* PERFORMANCE tests */
        if (tests & PERFORMANCE) {
                if (perform_performance_test(sig, hash, curve)) {
                        goto err;
                }
        }

        return 0;

 err:
        return -1;
}

static void print_curves(void)
{
       u8 i;

       /* Print all the available curves */
       for (i = 0; i < EC_CURVES_NUM; i++) {
               ext_printf("%s ", (const char *)(ec_maps[i].params->name->buf));
       }

       return;
}

static void print_hash_algs(void)
{
       int i;

       /* Print all the available hash functions */
       for (i = 0; hash_maps[i].type != UNKNOWN_HASH_ALG; i++) {
               ext_printf("%s ", hash_maps[i].name);
       }

       return;
}

static void print_sig_algs(void)
{
        int i;

        /* Print all the available signature schemes */
        for (i = 0; ec_sig_maps[i].type != UNKNOWN_ALG; i++) {
                ext_printf("%s ", ec_sig_maps[i].name);
        }

        return;
}

static void print_help(const char *bad_arg)
{
        int j;
        if(bad_arg != NULL){
                ext_printf("Argument %s is unknown. Possible args are:\n", bad_arg);
        }
        for (j = 0; j < (int)(sizeof(test_types) / sizeof(test_type)); j++) {
                ext_printf("\t%20s:\t%s\n", test_types[j].type_name,
                           test_types[j].type_help);
        }
        ext_printf("-------------------\n");
        ext_printf("NOTE: you can filter signatures with 'sign=', hash algorithms with 'hash=', curves with 'curve='\n");
        ext_printf("\tExample: sign=ECDSA hash=SHA256 hash=SHA512 curve=FRP256V1\n");
        ext_printf("\tPossible signatures: ");
        print_sig_algs();
        ext_printf("\n\tPossible hash algorithms: ");
        print_hash_algs();
        ext_printf("\n\tPossible curves: ");
        print_curves();
        ext_printf("\n");
}

#if defined(USE_SMALL_STACK)
#define MAX_FILTERS 1
#else
#define MAX_FILTERS 100
#endif

#ifdef __cplusplus
/* In case of a C++ compiler, preserve our "main"
 * linkage.
 */
extern "C" {
int main(int argc, char *argv[]);
}
#endif

int main(int argc, char *argv[])
{
        int ret;
        unsigned int tests_to_do;
        const char *sign_filters[MAX_FILTERS]  = { NULL };
        const char *hash_filters[MAX_FILTERS]  = { NULL };
        const char *curve_filters[MAX_FILTERS] = { NULL };
        int sign_filters_num = 0, hash_filters_num = 0, curve_filters_num = 0;
        int i, j, k;

        /* By default, perform all tests */
        tests_to_do = KNOWN_TEST_VECTORS | RANDOM_SIG_VERIF | PERFORMANCE;

        /* Sanity check */
        if(MAX_FILTERS < 1){
                ext_printf("Error: MAX_FILTERS too small\n");
                ret = -1;
                goto err;
        }

        /* If we have one or more arguments, only perform specific test */
        if (argc > 1) {
                unsigned char found = 0, found_filter = 0;
                unsigned int found_ops = 0;
                int check;
                u32 len;
                /* Check of the args */
                for (i = 1; i < argc; i++) {
                        found = found_filter = 0;
                        for (j = 0;
                             j < (int)(sizeof(test_types) / sizeof(test_type));
                             j++) {
                                ret = local_strlen(test_types[j].type_name, &len); EG(ret, err);
                                ret = are_equal(argv[i], test_types[j].type_name, len + 1, &check); EG(ret, err);
                                if (check) {
                                        found_ops++;
                                        found = 1;
                                        break;
                                }
                                ret = are_equal(argv[i], "sign=", sizeof("sign=")-1, &check); EG(ret, err);
                                if(check){
                                        if(sign_filters_num >= MAX_FILTERS){
                                                ext_printf("Maximum number of sign filters %d exceeded!\n", sign_filters_num);
                                                ret = -1;
                                                goto err;
                                        }
                                        sign_filters[sign_filters_num++] = argv[i]+sizeof("sign=")-1;
                                        found_filter = 1;
                                        break;
                                }
                                ret = are_equal(argv[i], "hash=", sizeof("hash=")-1, &check); EG(ret, err);
                                if(check){
                                        if(hash_filters_num >= MAX_FILTERS){
                                                ext_printf("Maximum number of hash filters %d exceeded!\n", hash_filters_num);
                                                ret = -1;
                                                goto err;
                                        }
                                        hash_filters[hash_filters_num++] = argv[i]+sizeof("hash=")-1;
                                        found_filter = 1;
                                        break;
                                }
                                ret = are_equal(argv[i], "curve=", sizeof("curve=")-1, &check); EG(ret, err);
                                if(check){
                                        if(curve_filters_num >= MAX_FILTERS){
                                                ext_printf("Maximum number of curve filters %d exceeded!\n", curve_filters_num);
                                                return -1;
                                        }
                                        curve_filters[curve_filters_num++] = argv[i]+sizeof("curve=")-1;
                                        found_filter = 1;
                                        break;
                                }
                        }
                        if ((found == 0) && (found_filter == 0)) {
                                print_help(argv[i]);
                                ret = -1;
                                goto err;
                        }
                }
                if (found_ops == 0) {
                        if(found_filter == 0){
                                ext_printf("Error: no operation asked ...\n");
                                print_help(NULL);
                                ret = -1;
                                goto err;
                        }
                }
                else{
                        tests_to_do = 0;
                        for (i = 1; i < argc; i++) {
                                for (j = 0;
                                     j < (int)(sizeof(test_types) / sizeof(test_type));
                                     j++) {
                                        ret = local_strlen(test_types[j].type_name, &len); EG(ret, err);
                                        ret = are_equal(argv[i], test_types[j].type_name, len + 1, &check); EG(ret, err);
                                        if (check){
                                                tests_to_do |= test_types[j].type_mask;
                                        }
                                }
                        }
                }
        }
        /* If we do not have filters, we put NULL to tell that we do not filter */
        if(sign_filters_num == 0){
                sign_filters_num = 1;
                sign_filters[0] = NULL;
        }
        if(hash_filters_num == 0){
                hash_filters_num = 1;
                hash_filters[0] = NULL;
        }
        if(curve_filters_num == 0){
                curve_filters_num = 1;
                curve_filters[0] = NULL;
        }
        for(i = 0; i < sign_filters_num; i++){
                for(j = 0; j < hash_filters_num; j++){
                        for(k = 0; k < curve_filters_num; k++){
                                if(perform_tests(tests_to_do, sign_filters[i], hash_filters[j], curve_filters[k])){
                                        const char *curr_sign_filters = sign_filters[i];
                                        const char *curr_hash_filters = hash_filters[j];
                                        const char *curr_curve_filters = curve_filters[k];
                                        const char *all = "all";
                                        if(curr_sign_filters == NULL){
                                                curr_sign_filters = all;
                                        }
                                        if(curr_hash_filters == NULL){
                                                curr_hash_filters = all;
                                        }
                                        if(curr_curve_filters == NULL){
                                                curr_curve_filters = all;
                                        }
                                        ext_printf("Test for sign=%s/hash=%s/curve=%s failed!\n", curr_sign_filters, curr_hash_filters, curr_curve_filters);
                                        ret = -1;
                                        goto err;
                                }
                        }
                }
        }

        ret = 0;

err:
        return ret;
}