const Papa = require("papaparse");
import { RemoteSource } from "../src/freeDatas2HTMLInterfaces";
import { ParserForCSV as Parser } from "../src/freeDatas2HTMLParserForCSV";
const errors=require("../src/errors.js");

// Pas de test de Papa Parse, car module externe
// Mais tests d'instanciation et configuration de la classe l'utilisant
describe("Tests du parseur de CSV", () =>
{
    let parser: Parser;
    let papaParseOptions: {};
        
    beforeEach( () =>
    {
        parser=new Parser();
        papaParseOptions =
        {
            delimiter: "",
            newline: "",
            quoteChar: '"',
            escapeChar:  '"',
            header: true, 
            transformHeader: function(field: string, index: number): string { return field.trim() },
            preview: 0,
            comments: "",
            complete: function(results :any)
            {
                console.log(results);// peut importe cette partie pour les tests
            },
            download: undefined,
            downloadRequestHeaders: undefined, 
            skipEmptyLines:"greedy",
            fastMode: undefined,
            withCredentials: undefined, 
            transform: undefined,
        }
    });

    it("Doit avoir créé une instance du Parser",  () =>
    {
        expect(parser).toBeInstanceOf(Parser);
    });

    it("Doit générer une erreur si l'url fournie pour importer les données est une chaîne vide.", () =>
    {
        expect(() => { return parser.datasRemoteSource= { url:"" } }).toThrowError(errors.parserNeedUrl);
        expect(() => { return parser.datasRemoteSource= { url:"  " } }).toThrowError(errors.parserNeedUrl);
    });
    
    it("Doit accepter des paramètres valides pour la source de données distante.", () =>
    {
        let myRemoteSource: RemoteSource={ url:"zz" };
        parser.datasRemoteSource=myRemoteSource;
        expect(parser.datasRemoteSource).toEqual(myRemoteSource);
        myRemoteSource={ url:"zz", headers: [ { key:"test", value: "coucou"}, { key:"test2", value:"coucou2"}],  withCredentials:true };
        parser.datasRemoteSource=myRemoteSource;
        expect(parser.datasRemoteSource).toEqual(myRemoteSource);
    });

    it("Doit générer une erreur si la chaîne de données à parser est vide.", () =>
    {
        expect(() => { return parser. datas2Parse= "" }).toThrowError(errors.parserNeedDatas);
        expect(() => { return parser. datas2Parse= "  " }).toThrowError(errors.parserNeedDatas);
    });

    it("Doit accepter toute chaîne de caractères non vide pour les données à parser.", () =>
    {
        parser. datas2Parse="datas";
        expect(parser.datas2Parse).toEqual("datas");
    });
    
    it("Doit générer une erreur si le parseur est lancé sans source de données fournie.", async () =>
    {
        await expectAsync(parser.parse()).toBeRejectedWith(new Error(errors.parserNeedSource));
    });

    it("Si les données sont directement fournies, cela doit être pris en compte dans les options passées à Papa Parse.",  () =>
    {
        // Idéalement il faudrait tester les paramètres passés à PapaParse
        // Mais semble impossible à cause des fonctions callback ?
        spyOn(Papa, "parse");
        parser.datas2Parse="datas";
        parser.parse();
        expect(parser.privateOptions).toEqual(
        {
            header: true,
            download: false,
            downloadRequestHeaders: undefined, 
            skipEmptyLines:"greedy",
            withCredentials: undefined
        });
    }); 
    
    it("Si une ressource distante est fournie, cela doit être pris en compte dans les options passées à Papa Parse.", () =>
    {
        // Même remarque, test précédent
        spyOn(Papa, "parse");
        let myRemoteSource:  RemoteSource={ url:"http://localhost:9876/datas/datas1.csv",  withCredentials:true };
        parser.datasRemoteSource=myRemoteSource;
        parser.parse();
        expect(parser.privateOptions).toEqual(
        {
            header: true,
            download: true,
            downloadRequestHeaders: undefined, 
            skipEmptyLines: "greedy",
            withCredentials: true
        });
        myRemoteSource={ url:"http://localhost:9876/datas/datas1.csv",  headers: [ { key:"test", value: "coucou"}, { key:"test2", value:"coucou2"}] ,  withCredentials:false };
        parser.datasRemoteSource=myRemoteSource;
        parser.parse();
        expect(parser.privateOptions).toEqual(
        {
            header: true,
            download: true,
            downloadRequestHeaders: { test:"coucou", test2:"coucou2"}, 
            skipEmptyLines: "greedy",
            withCredentials: false
        });
        expect(Papa.parse).toHaveBeenCalledTimes(2);
    });

    it("Si le parseur a été appelé avec les données nécessaires, des résultats doivent être enregistrés.", async () =>
    {
        parser.datasRemoteSource={ url:"http://localhost:9876/datas/datas1.csv" };
        await parser.parse();
        expect(parser.parseResults).not.toBeUndefined();
        // Y compris si données fournies bidon :
        parser=new Parser();
        parser.datas2Parse="datas";
        await parser.parse();
        expect(parser.parseResults).not.toBeUndefined();
    });
});