/*
    Licensed to the Apache Software Foundation (ASF) under one
    or more contributor license agreements.  See the NOTICE file
    distributed with this work for additional information
    regarding copyright ownership.  The ASF licenses this file
    to you under the Apache License, Version 2.0 (the
    "License"); you may not use this file except in compliance
    with the License.  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing,
    software distributed under the License is distributed on an
    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    KIND, either express or implied.  See the License for the
    specific language governing permissions and limitations
    under the License.
*/
/**
 * @file test_output_functions.c
 * @author Alessandro Budroni
 * @brief Test output functions for debug
 *
 */


#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "arch.h"
#include "amcl.h"
#include "utils.h"
#include "big_XXX.h"
#include "fp_YYY.h"
#include "fp2_YYY.h"
#include "fp4_YYY.h"
#include "ecp_ZZZ.h"
#if CURVE_SECURITY_ZZZ == 128
#include "fp12_YYY.h"
#include "ecp2_ZZZ.h"
#elif CURVE_SECURITY_ZZZ == 192
#include "fp8_YYY.h"
#include "fp24_YYY.h"
#include "ecp4_ZZZ.h"
#elif CURVE_SECURITY_ZZZ == 256
#include "fp8_YYY.h"
#include "fp16_YYY.h"
#include "fp48_YYY.h"
#include "ecp8_ZZZ.h"
#endif

extern int dup(int oldfd);
extern int dup2(int oldfd, int newfd);
extern int close(int fildes);
extern int fileno(FILE *stream);

#if CURVE_SECURITY_ZZZ == 128
#define LINE_LEN 2000
#elif CURVE_SECURITY_ZZZ == 192
#define LINE_LEN 4000
#elif CURVE_SECURITY_ZZZ == 256
#define LINE_LEN 8000
#endif


/*
 * Skips n closed brackets.
 * Null terminates after the nth bracket and
 * returns a pointer to the next char
 */
char* skip_cb(char* str, int n)
{
    int i;
    char* next=str;

    for(i=0; i<n; i++)
    {
        next = strchr(++next,']');
        if (next == NULL)
        {
            printf("ERROR unexpected test vector\n");
            exit(EXIT_FAILURE);
        }
    }
    *(++next) = '\0';

    return next++;
}

void read_BIG_XXX(BIG_XXX A, char* string)
{
    int len;
    char support[LINE_LEN];
    BIG_XXX_zero(A);
    len = strlen(string)+1;
    amcl_hex2bin(string,support,len);
    len = (len-1)/2;
    BIG_XXX_fromBytesLen(A,support,len);
    BIG_XXX_norm(A);
}

void read_DBIG_XXX(DBIG_XXX A, char* string)
{
    int len;
    char support[LINE_LEN] = "0";
    BIG_XXX_dzero(A);

    // replace eventual line feed
    len=strlen(string);
    if(string[len-1] == '\x0a')
    {
        string[len-1]='\0';
        len--;
    }

    // Handle odd length strings
    if(len %2 == 0)
        support[0]='\0';
    strcat(support,string);

    len = strlen(support);
    amcl_hex2bin(support,support,len);
    BIG_XXX_dfromBytesLen(A,support,len/2);
    BIG_XXX_dnorm(A);
}

void read_FP2_YYY(FP2_YYY *fp2, char* stringx)
{
    char *stringy;
    BIG_XXX x,y;

    stringy = strchr(++stringx,',');
    if (stringy == NULL)
    {
        printf("ERROR unexpected test vector\n");
        exit(EXIT_FAILURE);
    }
    *(stringy)=0;
    skip_cb(stringy++,1);

    read_BIG_XXX(x,stringx);
    read_BIG_XXX(y,stringy);

    FP2_YYY_from_BIGs(fp2,x,y);
}

void read_FP4_YYY(FP4_YYY *fp4, char* stringx)
{
    char *stringy;
    FP2_YYY x,y;

    stringy = skip_cb(stringx++,1);
    skip_cb(stringy++,1);

    read_FP2_YYY(&x,stringx);
    read_FP2_YYY(&y,stringy);

    FP4_YYY_from_FP2s(fp4,&x,&y);
}

int read_ECP_ZZZ(ECP_ZZZ *ecp, char* string)
{
    BIG_XXX x;
    char *end;
    BIG_XXX y;
    char *stringy;
    string++;
    stringy = strchr(string,',');
    if (stringy == NULL)
    {
        printf("ERROR unexpected test vector\n");
        exit(EXIT_FAILURE);
    }
    stringy[0] = '\0';
    stringy++;
    end = strchr(stringy,')');
    if (end == NULL)
    {
        printf("ERROR unexpected test vector\n");
        exit(EXIT_FAILURE);
    }
    end[0] = '\0';
    read_BIG_XXX(x,string);
    read_BIG_XXX(y,stringy);
    return ECP_ZZZ_set(ecp,x,y);
}

#if CURVE_SECURITY_ZZZ == 128
void read_FP12_YYY(FP12_YYY *fp12, char *stringx)
{
    char *stringy, *stringz;
    FP4_YYY x,y,z;

    stringy = skip_cb(stringx++,3);
    stringz = skip_cb(stringy++,3);
    skip_cb(stringz++,3);

    read_FP4_YYY(&x,stringx);
    read_FP4_YYY(&y,stringy);
    read_FP4_YYY(&z,stringz);

    FP12_YYY_from_FP4s(fp12,&x,&y,&z);
}
int read_ECP2_ZZZ(ECP2_ZZZ *ecp2, char* stringx)
{
    char *stringy;
    FP2_YYY x,y;

    stringy = skip_cb(stringx++,1);
    skip_cb(stringy++,1);

    read_FP2_YYY(&x,stringx);
    read_FP2_YYY(&y,stringy);

    return ECP2_ZZZ_set(ecp2,&x,&y);
}
#else
void read_FP8_YYY(FP8_YYY *fp8, char* stringx)
{
    char *stringy;
    FP4_YYY x,y;

    stringy = skip_cb(stringx++,3);
    skip_cb(stringy++,3);

    read_FP4_YYY(&x,stringx);
    read_FP4_YYY(&y,stringy);

    FP8_YYY_from_FP4s(fp8,&x,&y);
}
#if CURVE_SECURITY_ZZZ == 192
void read_FP24_YYY(FP24_YYY *fp24, char *stringx)
{
    char *stringy, *stringz;
    FP8_YYY x,y,z;

    stringy = skip_cb(stringx++,7);
    stringz = skip_cb(stringy++,7);
    skip_cb(stringz++,7);

    read_FP8_YYY(&x,stringx);
    read_FP8_YYY(&y,stringy);
    read_FP8_YYY(&z,stringz);

    FP24_YYY_from_FP8s(fp24,&x,&y,&z);

}
int read_ECP4_ZZZ(ECP4_ZZZ *ecp4, char* stringx)
{
    char *stringy;
    FP4_YYY x,y;

    stringy = skip_cb(stringx++,3);
    skip_cb(stringy++,3);

    read_FP4_YYY(&x,stringx);
    read_FP4_YYY(&y,stringy);

    return ECP4_ZZZ_set(ecp4,&x,&y);
}
#elif CURVE_SECURITY_ZZZ == 256
void read_FP16_YYY(FP16_YYY *fp16, char* stringx)
{
    char *stringy;
    FP8_YYY x,y;

    stringy = skip_cb(stringx++,7);
    skip_cb(stringy++,7);
    read_FP8_YYY(&x,stringx);
    read_FP8_YYY(&y,stringy);

    FP16_YYY_from_FP8s(fp16,&x,&y);
}
void read_FP48_YYY(FP48_YYY *fp48, char *stringx)
{
    char *stringy, *stringz;
    FP16_YYY x,y,z;

    stringy = skip_cb(stringx++,15);
    stringz = skip_cb(stringy++,15);
    skip_cb(stringz++,15);

    read_FP16_YYY(&x,stringx);
    read_FP16_YYY(&y,stringy);
    read_FP16_YYY(&z,stringz);

    FP48_YYY_from_FP16s(fp48,&x,&y,&z);
}
int read_ECP8_ZZZ(ECP8_ZZZ *ecp8, char* stringx)
{
    char *stringy;
    FP8_YYY x,y;

    stringy = skip_cb(stringx++,7);
    skip_cb(stringy++,7);

    read_FP8_YYY(&x,stringx);
    read_FP8_YYY(&y,stringy);

    return ECP8_ZZZ_set(ecp8,&x,&y);
}
#endif
#endif

void read_OCT(octet *oct, char* string, int len)
{
    char buff[len];
    strncpy(buff,string,len-1);
    buff[len-1] = '\0';
    OCT_fromHex(oct,buff);
}

int main(int argc, char** argv)
{
    if (argc != 3)
    {
        printf("usage: ./test_ECP2_ZZZ_arithmetics [path to test vector file] [path to output directory]\n");
        exit(EXIT_FAILURE);
    }

    int fd, len, ch1 = 0, ch2 = 0, i=0, done;
    fpos_t pos;
    FILE *testVectFile, *writtenFile;

    char line[LINE_LEN];
    char * linePtr = NULL;

    BIG_XXX big, bigaux1, bigaux2;
    const char* BIGline = "BIG = ";
    const char* BIGrawline = "BIGraw = ";
    DBIG_XXX dbig;
    const char* DBIGline = "DBIG = ";
    FP_YYY fp;
    const char* FPline = "FP = ";
    const char* FPrawline = "FPraw = ";
    ECP_ZZZ ecp;
    ECP_ZZZ ecpinf;
    const char* ECPline = "ECP = ";
    const char* ECPxyzline = "ECPxyz = ";
    const char* ECPrawline = "ECPraw = ";
    const char* ECPinfline = "ECPinf = ";
    const char* ECPinfxyzline = "ECPinfxyz = ";
    const char* ECPinfrawline = "ECPinfraw = ";
    FP2_YYY fp2;
    const char* FP2line = "FP2 = ";
    const char* FP2rawline = "FP2raw = ";
    FP4_YYY fp4;
    const char* FP4line = "FP4 = ";
    const char* FP4rawline = "FP4raw = ";
# if CURVE_SECURITY_ZZZ == 128
    FP12_YYY fp12;
    const char* FP12line = "FP12 = ";
    FP2_YYY fp2aux;
    ECP2_ZZZ ecp2;
    ECP2_ZZZ ecp2inf;
    const char* ECP2line = "ECP2 = ";
    const char* ECP2xyzline = "ECP2xyz = ";
    const char* ECP2infline = "ECP2inf = ";
    const char* ECP2infxyzline = "ECP2infxyz = ";
#else
    FP8_YYY fp8;
    const char* FP8line = "FP8 = ";
    const char* FP8rawline = "FP8raw = ";
#if CURVE_SECURITY_ZZZ == 192
    FP24_YYY fp24;
    const char* FP24line = "FP24 = ";
    FP4_YYY fp4aux;
    ECP4_ZZZ ecp4;
    ECP4_ZZZ ecp4inf;
    const char* ECP4line = "ECP4 = ";
    const char* ECP4infline = "ECP4inf = ";
#elif CURVE_SECURITY_ZZZ == 256
    FP16_YYY fp16;
    const char* FP16line = "FP16 = ";
    const char* FP16rawline = "FP16raw = ";
    FP48_YYY fp48;
    const char* FP48line = "FP48 = ";
    FP8_YYY fp8aux;
    ECP8_ZZZ ecp8;
    ECP8_ZZZ ecp8inf;
    const char* ECP8line = "ECP8 = ";
    const char* ECP8infline = "ECP8inf = ";
#endif
#endif
    char octbuf[LINE_LEN];
    octet oct = {0,sizeof(octbuf),octbuf};
    const char* OCTline = "OCT = ";
    //const char* OCTstringline = "OCTstring = ";
    char bin[32];
    const char* HEXline = "HEX = ";

    testVectFile = fopen(argv[1],"r");
    if (testVectFile == NULL)
    {
        printf("ERROR opening test vector file\n");
        exit(EXIT_FAILURE);
    }

    fgetpos(stdout, &pos);
    fd = dup(fileno(stdout));

    if(freopen(argv[2], "w", stdout) == NULL)
    {
        printf("ERROR redirecting stdout\n");
        exit(EXIT_FAILURE);
    }

    while (fgets(line, LINE_LEN, testVectFile) != NULL)
    {
        i++;
        done=0;
        if (!strncmp(line,  BIGline, strlen(BIGline)))
        {
            len = strlen(BIGline);
            linePtr = line + len;
            read_BIG_XXX(big, linePtr);
            printf("%s",BIGline);
            BIG_XXX_output(big);
            printf("\n");
            printf("%s",BIGrawline);
            BIG_XXX_rawoutput(big);
            printf("\n");
            done = 1;
        }
        if (!strncmp(line,  DBIGline, strlen(DBIGline)))
        {
            len = strlen(DBIGline);
            linePtr = line + len;
            read_DBIG_XXX(dbig, linePtr);
            printf("%s",DBIGline);
            BIG_XXX_doutput(dbig);
            printf("\n");
            done = 1;
        }
        if (!strncmp(line,  FPline, strlen(FPline)))
        {
            len = strlen(FPline);
            linePtr = line + len;
            read_BIG_XXX(big,linePtr);
            FP_YYY_nres(&fp,big);
            printf("%s",FPline);
            FP_YYY_output(&fp);
            printf("\n");
            printf("%s",FPrawline);
            FP_YYY_rawoutput(&fp);
            printf("\n");
            done = 1;
        }
        if (!strncmp(line,  FP2line, strlen(FP2line)))
        {
            len = strlen(FP2line);
            linePtr = line + len;
            read_FP2_YYY(&fp2,linePtr);
            printf("%s",FP2line);
            FP2_YYY_output(&fp2);
            printf("\n");
            printf("%s",FP2rawline);
            FP2_YYY_rawoutput(&fp2);
            printf("\n");
            done = 1;
        }
        if (!strncmp(line,  FP4line, strlen(FP4line)))
        {
            len = strlen(FP4line);
            linePtr = line + len;
            read_FP4_YYY(&fp4,linePtr);
            printf("%s",FP4line);
            FP4_YYY_output(&fp4);
            printf("\n");
            printf("%s",FP4rawline);
            FP4_YYY_rawoutput(&fp4);
            printf("\n");
            done = 1;
        }
        if (!strncmp(line,  ECPline, strlen(ECPline)))
        {
            len = strlen(ECPline);
            linePtr = line + len;
            read_ECP_ZZZ(&ecp,linePtr);
            printf("%s",ECPline);
            ECP_ZZZ_output(&ecp);
            printf("%s",ECPxyzline);
            ECP_ZZZ_outputxyz(&ecp);
            printf("%s",ECPrawline);
            ECP_ZZZ_rawoutput(&ecp);
            FP_YYY_redc(bigaux1,&ecp.x);
            FP_YYY_redc(bigaux2,&ecp.y);
            BIG_XXX_inc(bigaux1,100);
            ECP_ZZZ_set(&ecpinf,bigaux1,bigaux2);
            printf("%s",ECPinfline);
            ECP_ZZZ_output(&ecpinf);
            printf("%s",ECPinfxyzline);
            ECP_ZZZ_outputxyz(&ecpinf);
            printf("%s",ECPinfrawline);
            ECP_ZZZ_rawoutput(&ecpinf);
            done = 1;
        }
#if CURVE_SECURITY_ZZZ == 128
        if (!strncmp(line,  FP12line, strlen(FP12line)))
        {
            len = strlen(FP12line);
            linePtr = line + len;
            read_FP12_YYY(&fp12,linePtr);
            printf("%s",FP12line);
            FP12_YYY_output(&fp12);
            printf("\n");
            done = 1;
        }
        if (!strncmp(line,  ECP2line, strlen(ECP2line)))
        {
            len = strlen(ECP2line);
            linePtr = line + len;
            read_ECP2_ZZZ(&ecp2,linePtr);
            printf("%s",ECP2line);
            ECP2_ZZZ_output(&ecp2);
            printf("%s",ECP2xyzline);
            ECP2_ZZZ_outputxyz(&ecp2);
            FP2_YYY_add(&fp2aux,&ecp2.x,&ecp2.y);
            ECP2_ZZZ_set(&ecp2inf,&fp2aux,&fp2aux);
            printf("%s",ECP2infline);
            ECP2_ZZZ_output(&ecp2inf);
            printf("%s",ECP2infxyzline);
            ECP2_ZZZ_outputxyz(&ecp2inf);
            done = 1;
        }
#else
        if (!strncmp(line,  FP8line, strlen(FP8line)))
        {
            len = strlen(FP8line);
            linePtr = line + len;
            read_FP8_YYY(&fp8,linePtr);
            printf("%s",FP8line);
            FP8_YYY_output(&fp8);
            printf("\n");
            printf("%s",FP8rawline);
            FP8_YYY_rawoutput(&fp8);
            printf("\n");
            done = 1;
        }
#if CURVE_SECURITY_ZZZ == 192
        if (!strncmp(line,  FP24line, strlen(FP24line)))
        {
            len = strlen(FP24line);
            linePtr = line + len;
            read_FP24_YYY(&fp24,linePtr);
            printf("%s",FP24line);
            FP24_YYY_output(&fp24);
            printf("\n");
            done = 1;
        }
        if (!strncmp(line,  ECP4line, strlen(ECP4line)))
        {
            len = strlen(ECP4line);
            linePtr = line + len;
            read_ECP4_ZZZ(&ecp4,linePtr);
            printf("%s",ECP4line);
            ECP4_ZZZ_output(&ecp4);
            FP4_YYY_add(&fp4aux,&ecp4.x,&ecp4.y);
            ECP4_ZZZ_set(&ecp4inf,&fp4aux,&fp4aux);
            printf("%s",ECP4infline);
            ECP4_ZZZ_output(&ecp4inf);
            done = 1;
        }
#elif CURVE_SECURITY_ZZZ == 256
        if (!strncmp(line,  FP16line, strlen(FP16line)))
        {
            len = strlen(FP16line);
            linePtr = line + len;
            read_FP16_YYY(&fp16,linePtr);
            printf("%s",FP16line);
            FP16_YYY_output(&fp16);
            printf("\n");
            printf("%s",FP16rawline);
            FP16_YYY_rawoutput(&fp16);
            printf("\n");
            done = 1;
        }
        if (!strncmp(line,  FP48line, strlen(FP48line)))
        {
            len = strlen(FP48line);
            linePtr = line + len;
            read_FP48_YYY(&fp48,linePtr);
            printf("%s",FP48line);
            FP48_YYY_output(&fp48);
            printf("\n");
            done = 1;
        }
        if (!strncmp(line,  ECP8line, strlen(ECP8line)))
        {
            len = strlen(ECP8line);
            linePtr = line + len;
            read_ECP8_ZZZ(&ecp8,linePtr);
            printf("%s",ECP8line);
            ECP8_ZZZ_output(&ecp8);
            FP8_YYY_add(&fp8aux,&ecp8.x,&ecp8.y);
            ECP8_ZZZ_set(&ecp8inf,&fp8aux,&fp8aux);
            printf("%s",ECP8infline);
            ECP8_ZZZ_output(&ecp8inf);
            done = 1;
        }
#endif
#endif
        if (!strncmp(line,  OCTline, strlen(OCTline)))
        {
            len = strlen(OCTline);
            linePtr = line + len;
            read_OCT(&oct,linePtr,strlen(linePtr));
            printf("%s",OCTline);
            OCT_output(&oct);
            done = 1;
        }
        if (!strncmp(line,  HEXline, strlen(HEXline)))
        {
            len = strlen(HEXline);
            linePtr = line + len;
            amcl_hex2bin(linePtr, bin, 64);
            printf("%s", HEXline);
            amcl_print_hex(bin,32);
            done = 1;
        }
        if (!strncmp(line, BIGrawline, strlen(BIGrawline))||
                !strncmp(line, FPrawline, strlen(FPrawline))||
                !strncmp(line, ECPxyzline, strlen(ECPxyzline))||
                !strncmp(line, ECPrawline, strlen(ECPrawline))||
                !strncmp(line, ECPinfline, strlen(ECPinfline))||
                !strncmp(line, ECPinfxyzline, strlen(ECPinfxyzline))||
                !strncmp(line, ECPinfrawline, strlen(ECPinfrawline))||
                !strncmp(line, FP2rawline, strlen(FP2rawline))||
                !strncmp(line, FP4rawline, strlen(FP4rawline)))
            done=1;
#if CURVE_SECURITY_ZZZ == 128
        if (!strncmp(line, ECP2xyzline, strlen(ECP2xyzline))||
                !strncmp(line, ECP2infline, strlen(ECP2infline))||
                !strncmp(line, ECP2infxyzline, strlen(ECP2infxyzline)))
            done=1;
#elif CURVE_SECURITY_ZZZ == 192
        if (!strncmp(line, FP8rawline, strlen(FP8rawline))||
                !strncmp(line, ECP4infline, strlen(ECP4infline)))
            done=1;
#elif CURVE_SECURITY_ZZZ == 256
        if (!strncmp(line, FP8rawline, strlen(FP8rawline))||
                !strncmp(line, FP16rawline, strlen(FP16rawline))||
                !strncmp(line, ECP8infline, strlen(ECP8infline)))
            done=1;
#endif
        if(!done)
            printf("%s",line);
    }

    // Restore stdout
    fflush(stdout);
    dup2(fd, fileno(stdout));
    close(fd);
    clearerr(stdout);
    fsetpos(stdout, &pos);        /* for C9X */

    writtenFile = fopen(argv[2],"r");
    if (writtenFile == NULL)
    {
        printf("ERROR opening output file\n");
        exit(EXIT_FAILURE);
    }
    fclose(testVectFile);

    // Check the equality of the output with the test vector file

    testVectFile = fopen(argv[1],"r");
    if (testVectFile == NULL)
    {
        printf("ERROR opening test vector file\n");
        exit(EXIT_FAILURE);
    }

    ch1 = getc(testVectFile);
    ch2 = getc(writtenFile);

    while ((ch1 != EOF) && (ch2 != EOF) && (ch1 == ch2))
    {
        ch1 = getc(testVectFile);
        ch2 = getc(writtenFile);
    }

    if (ch1 != ch2)
    {
        printf("ERROR output does not match the expected one \n");
        exit(EXIT_FAILURE);
    }
    fclose(writtenFile);
    fclose(testVectFile);

    remove(argv[2]);

    printf("SUCCESS TEST OUTPUT FUNCTIONS PASSED\n");
    exit(EXIT_SUCCESS);
}