/*
 * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
 * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
 */
package com.megatim.fdxconvert.util;

import com.megatim.typefichier.validator.model.enums.FileExtension;
import com.megatim.typefichier.validator.utilities.Constantes;
import com.megatim.fdxconvert.exceptions.ValidatorException;
import com.megatim.fdxconvert.model.Validateur;
import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;
import java.nio.charset.Charset;
import java.util.Map;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.NodeList;

/**
 *
 * @author ASUS
 */
public class ParserUtils {

    private ParserUtils() {

    }

    public static boolean isConvertDataBeforeValidation(File file) throws Exception {
        String extension = null;
        boolean result = true;
        Document doc = intialize(file);
        NodeList entityList = doc.getElementsByTagName("entity"); //Liste des noeud <entity>

        //Le validateur XML doit avoir au moins deux balises <entity> pour être conforme
        if (entityList.getLength() >= 2) {
            NamedNodeMap attributes = entityList.item(1).getAttributes();

            for (int i = 0; i < attributes.getLength(); i++) {
                String assertionAttributeName = attributes.item(i).getNodeName();
                String assertionAttributeValue = attributes.item(i).getNodeValue();

                if (assertionAttributeName.equalsIgnoreCase(Constantes.EXTENSION)) {
                    extension = assertionAttributeValue;

                    if (extension != null
                            && (extension.equalsIgnoreCase(FileExtension.CSV.name())
                            || extension.equalsIgnoreCase(FileExtension.XLS.name())
                            || extension.equalsIgnoreCase(FileExtension.XLSX.name()))) {
                        result = false;
                        break;
                    }
                }
            }
        }
        return result;
    }

    /**
     * Méthode qui extrait les informations de validation d'un fichier xml et
     * les renvoie dans une map
     *
     * @param validateur : Validateur dont on veut extraire les infos
     * @return : retourne une map de la forme
     * <position_colonne_dans_une_ligne_de_donnee, informations_sur_la_colonne>
     * @throws Exception
     */
    public static Map<Integer, Map> getValidateurElements(Validateur validateur) throws Exception {
        return com.megatim.typefichier.validator.utilities.ParserUtils.getValidateurElements(validateur.getContent());
    }

    /**
     * Méthode qui retire le caractère retour charriot dans une chaîne
     *
     * @param str
     * @return
     */
//    public static String removeReturnCharriot(String str) {
//        String result = str;
//
//        if (str != null && !str.isEmpty()) {
//            String[] tab = str.split("\n");
//            result = "";
//
//            for (String s : tab) {
//                result += s;
//            }
//        }
//        return result;
//    }
    /**
     * Méthode utilitaire pour extraire les données dans un fichier xml
     *
     * @param array
     * @return
     * @throws Exception
     */
    private static Document intialize(byte[] array) throws Exception {

        /**
         * Défini un factory qui aide à obtenir un parseur qui produit un arbre
         * d'objets DOM à partir d'un docuent XML.
         */
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();

        /**
         * création d'un objet du builder pour parser le fichier XML.
         */
        DocumentBuilder db = dbf.newDocumentBuilder();

        Document doc = db.parse(new ByteArrayInputStream(array));

        doc.getDocumentElement().normalize();

        return doc;
    }

    private static Document intialize(File file) throws Exception {
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
        DocumentBuilder db = dbf.newDocumentBuilder();
        Document doc = db.parse(file);
        doc.getDocumentElement().normalize();

        return doc;
    }

    /**
     * Méthode pour obtenir l'objet de typr char correspondant à chaque
     * délimiteur
     *
     * @param delimiteur
     * @return
     */
    public static char characterOfDelimiteur(String delimiteur) {
        char character;

        switch (delimiteur) {
            case "\\t":
                character = '\t';
                break;
            case "\\n":
                character = '\n';
                break;
            case "":
                character = '\0';
                break;
            default:
                character = delimiteur.charAt(0);
        }

        return character;
    }

    /**
     * Méthode permettant d'encoder une chaîne de caractères
     *
     * @param datas : tableau de String à encoder
     * @param charset : encodage à utiliser
     * @return
     */
    public static String[] encodeStrings(String[] datas, Charset charset) {
        String[] encodedStrings = new String[datas.length];

        for (int i = 0; i < encodedStrings.length; i++) {
            byte[] bytesOfString = datas[i].getBytes();
            encodedStrings[i] = new String(bytesOfString, charset);

        }
        return encodedStrings;
    }

    /**
     * Méthode qui extrait une sous-chaîne dans une chaîne de caractères en
     * utilisant un délimiteur
     *
     * @param line : chaîne mère à séparer
     * @param character : délimiteur de chaîne
     * @return : retourne un tableau contenant les châines extraites
     */
    public static String[] splitIntoColumns(String line, char character) {

        int count = 0;

        for (int i = 0; i < line.length(); i++) {

            if (line.charAt(i) == character) {
                count++;
            }

        }

        String[] columns = new String[count + 1];

        StringBuilder builder = new StringBuilder(0);

        count = 0;

        for (int i = 0; i < line.length(); i++) {

            if (line.charAt(i) == character) {

                columns[count] = builder.toString();

                builder = new StringBuilder(0);

                count++;

            } else {

                builder.append(line.charAt(i));
            }

        }

        columns[count] = builder.toString();

        return columns;
    }

    /**
     * Méthode qui écrit dans un fichier
     *
     * @param finalColumnsTableLine : liste des châines à écrire dans le fichier
     * @param bufferWriter : ressource permettant d'écrire dans le fichier
     */
    public static void writeToFile(String[] finalColumnsTableLine, final BufferedWriter bufferWriter) throws IOException {

        //Ecriture dans le fichier output
        StringBuilder safeLineBuilder = new StringBuilder(0);

        for (String s : finalColumnsTableLine) {
            safeLineBuilder.append(s);
        }

        String safeLine = safeLineBuilder.toString();

        if (safeLine.length() > 0) {
            bufferWriter.write(safeLine + System.lineSeparator());

        }
    }
}