/*
 * 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.fdxcommons.tools.utils;

import com.megatim.fdxcommons.model.enumeration.TypeDonnee;
import com.megatim.fdxcommons.model.pojo.Constantes;
import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.apache.poi.ss.usermodel.CellValue;
import org.apache.poi.ss.usermodel.DataFormatter;
import org.apache.poi.ss.usermodel.DateUtil;
import org.apache.poi.ss.usermodel.FormulaEvaluator;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.ss.util.NumberToTextConverter;
import org.dhatim.fastexcel.reader.Cell;
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

/**
 *
 * @author ASUS
 */
public class ParserUtils {
    //Nombre be balise <entity> dans le validateur XML

    private static final int ENTITY_LIST_SIZE = 2;

    private ParserUtils() {

    }

    public static Map<Integer, Map> getValidateurElements(File file) throws Exception {
        byte[] bytes = Files.readAllBytes(file.toPath());
        return getValidateurElements(bytes);
    }

    public static Map<Integer, Map> getValidateurElements(byte[] bytes) throws Exception {
        Document doc = intialize(bytes);
        NodeList entityList = doc.getElementsByTagName("entity"); //Liste des noeud <entity>

        //Map qui stocke le champ à une position, ainsi que les caractéristiques de champ(typeDonnee, taille, index de debut d'extraction)
        Map<Integer, Map> mapParams = new HashMap<>();

        int position = 0;

        if (entityList.getLength() == ENTITY_LIST_SIZE) {

            //Liste des noeud de type <validation> du deuximème Noeud <entity>
            NodeList entityFileLineChildren = entityList.item(1).getChildNodes();

            //parcours de la balise <entity> pour récupérer ses enfants
            for (int i = 0; i < entityFileLineChildren.getLength(); i++) {

                if (entityFileLineChildren.item(i) != null && entityFileLineChildren.item(i).getAttributes() != null) {

                    //balise <validation>
                    Node validation = entityFileLineChildren.item(i);

                    if (validation != null) {

                        position++;

                        //Liste des assertions de la balise <validation>
                        NodeList assertions = validation.getChildNodes();

                        for (int r = 0; r < assertions.getLength(); r++) {
                            Node assertion = assertions.item(r);
                            Map<String, String> mapAttributes = new HashMap<>();

                            if (assertion != null && assertion.getAttributes() != null) {

                                //Les attributs de la balise <assertion>
                                NamedNodeMap attributesAssertion = assertion.getAttributes();

                                for (int k = 0; k < attributesAssertion.getLength(); k++) {

                                    String nodeValue = attributesAssertion.item(k).getNodeValue();
                                    String nodeName = attributesAssertion.item(k).getNodeName();

                                    if (nodeName.equals("error-code")) {
                                        mapAttributes.put(nodeName, nodeValue);
                                        break;
                                    }
                                }

                                //Liste des balises <param-value> de la balise <assertion>
                                NodeList params = assertion.getChildNodes();
                                Integer positionValue = null;

                                for (int j = 0; j < params.getLength(); j++) {

                                    if (params.item(j) != null && params.item(j).getAttributes() != null) {

                                        //Les attributs de la balise <param-value>
                                        NamedNodeMap attributesParamValue = params.item(j).getAttributes();

                                        for (int k = 0; k < attributesParamValue.getLength(); k++) {

                                            String nodeValue = attributesParamValue.item(k).getNodeValue();
                                            String nextNodeValue = attributesParamValue.item(++k).getNodeValue();
                                            mapAttributes.put(nodeValue, nextNodeValue);

                                            if (nodeValue.equals(Constantes.POSITION)) {
                                                positionValue = Integer.valueOf(nextNodeValue);
                                            }
                                        }
                                        mapParams.put(positionValue != null ? positionValue : position, mapAttributes);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        return mapParams;

    }

    public static String getXlxsCellValue(org.apache.poi.ss.usermodel.Cell cell, Workbook wb, String typeDonnee, String formatDate) {
        if (cell != null) {
            String formatString = cell.getCellStyle().getDataFormatString();

            switch (cell.getCellTypeEnum()) {
                case STRING:
                    if (typeDonnee.equalsIgnoreCase(TypeDonnee.DATE.getValue())) {
                        Date date = DateUtil.getJavaDate(Double.parseDouble(cell.getStringCellValue()));
                        return formatDate(date, formatDate);

                    } else if (typeDonnee.equalsIgnoreCase(TypeDonnee.NUMERIQUE.getValue())) {
                        DataFormatter formatter = new DataFormatter();
                        String formattedValue = formatter.formatCellValue(cell);
                        return formattedValue.replace(",", "");
                    }
                    return cell.getStringCellValue();
                case NUMERIC:
                    if (typeDonnee.equalsIgnoreCase(TypeDonnee.DATE.getValue())) {
                        Date date = DateUtil.getJavaDate(cell.getNumericCellValue());
                        return formatDate(date, formatDate);

                    } else if (DateUtil.isCellDateFormatted(cell)) {
                        return convertToDate(cell, formatDate);

                    } else if (formatString != null && formatString.contains("%")) {
                        return String.valueOf(cell.getNumericCellValue());

                    } else {
                        return NumberToTextConverter.toText(cell.getNumericCellValue());
                    }
                case BOOLEAN:
                    return String.valueOf(cell.getBooleanCellValue());
                case BLANK:
                    return "";
                case FORMULA:
                    FormulaEvaluator evaluator = wb.getCreationHelper().createFormulaEvaluator();
                    CellValue cellValue = evaluator.evaluate(cell);
                    return cellValue.formatAsString();
                default:
                    return "";
            }
        }
        return "";
    }

    private static String convertToDate(org.apache.poi.ss.usermodel.Cell cell, String formatDate) {
        Date date = cell.getDateCellValue();
        return formatDate(date, formatDate);
    }

    private static String formatDate(Date date, String formatDate) {
        SimpleDateFormat sdf
                = new SimpleDateFormat(formatDate != null && !formatDate.isEmpty()
                        ? formatDate
                        : "dd/MM/yyyy");
        return sdf.format(date);
    }

    /**
     * Méthode permettant de convertir la données contenu dans une cellule excel
     * en chaîne de caractères
     *
     * @param cell
     * @return
     */
    public static String getCellValueAsString(Cell cell) {
        String val = "";

        if (cell != null) {
            switch (cell.getType()) {

                case EMPTY:
                    break;

                case STRING:

                    if (!cell.getText().equals("null")) {

                        val = cell.getText().replaceAll("\\p{Cntrl}", "");

                    }

                    break;

                case NUMBER:

                    val = cell.asNumber().toPlainString();

                    if (val.equals("null")) {

                    }

                    break;

                case BOOLEAN:

                    val = String.valueOf(cell.asBoolean());

                    if (val.equals("null")) {

                    }

                    break;

                default:
                    break;

            }

        }

        return val;

    }

    /**
     * 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());

        }
    }
}