/*
 * 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.fdxgenerator.utilities;

import java.beans.IntrospectionException;
import java.beans.PropertyDescriptor;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.LineNumberReader;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author mela
 */
public class ImportData {

    /**
     * Méthode qui parse le fichier csv et en extrait les données
     *
     * @param datIm
     * @return
     */
    public static <T> List<T> importDataFromCsvFile(DataToImport<T> datIm) throws AttributeFormatException {
        FileReader reader = null;
        List<String[]> datas = new ArrayList<>();
        List<T> listeToReturn = new ArrayList<>();

        if (datIm != null) {
            try {
                reader = new FileReader(datIm.getFile() + "");
                LineNumberReader lineReader = new LineNumberReader(reader);
                String line = "";

                while ((line = lineReader.readLine()) != null) {
                    String[] row = line.split(datIm.getRowDelimiter());
                    for (String r : row) {
                        String[] values = new String[datIm.getFields().size()];
                        String[] columns = r.split(datIm.getColumnDelimiter());

                        int ss = 0;
                        while (ss < datIm.getFields().size() && ss < columns.length) {
                            values[ss] = columns[ss];
                            ss++;
                        }
                        datas.add(values);
                    }

                }
            } catch (FileNotFoundException ex) {
                Logger.getLogger(ImportData.class.getName()).log(Level.SEVERE, ex.getMessage(), ex);
            } catch (IOException ex) {
                Logger.getLogger(ImportData.class.getName()).log(Level.SEVERE, ex.getMessage(), ex);
            } finally {
                try {
                    reader.close();
                } catch (IOException | NullPointerException ex) {
                    Logger.getLogger(ImportData.class.getName()).log(Level.SEVERE, ex.getMessage(), ex);
                }
            }

            if (!datas.isEmpty()) {

                //tous les champs du type paramétré
                Field[] fields = datIm.getType().getDeclaredFields();

                // mettre les champs du type paramétré dans une map afin de faciliter leur accès
                Map<String, Field> fieldsToMap = fieldsToMap(fields);
                datas.forEach(d -> {
                    try {
                        T obj = datIm.getType().newInstance();
                        Map<String, String> map = tabToMap(datIm.getFields(), d);
                        for (Field field : fields) {
                            String fieldName = field.getName();
                            if (map.containsKey(fieldName) && fieldsToMap.containsKey(fieldName)) {
                                try {
                                    Object converted = convertToPrimitive(field, map.get(fieldName));
                                    Method method = new PropertyDescriptor(fieldName, datIm.getType()).getWriteMethod();
                                    method.invoke(obj, converted);
                                } catch (IntrospectionException | IllegalAccessException | InvocationTargetException ex) {
                                    Logger.getLogger(ImportData.class.getName()).log(Level.SEVERE, ex.getMessage(), ex);
                                } catch (IllegalArgumentException | ClassCastException ex) {
                                    throw new AttributeFormatException("Erreur de type sur le champ " + fieldName);
                                }
                            }
                        }
                        listeToReturn.add(obj);
                    } catch (InstantiationException | IllegalAccessException ex) {
                        Logger.getLogger(ImportData.class.getName()).log(Level.SEVERE, ex.getMessage(), ex);
                    }

                });
            }
        }
        return listeToReturn;
    }

    /**
     * Méthode qui met les libellés des colonnes et leurs valeurs
     * correspondantes dans une map
     *
     * @param titles : ensemble des noms de colonnes
     * @param values : ensemble des données
     * @return : rentourne une map (clé,valeur) = (nom_de_la_colonne,
     * valeur_colonne)
     */
    private static Map<String, String> tabToMap(List<String> titles, String[] values) {
        Map<String, String> map = new HashMap<>();
        for (int i = 0; i < titles.size(); i++) {
            map.put(titles.get(i), values[i]);
        }

        return map;
    }

    /**
     * Méthode qui met un tableau de Field dans une
     * map<nom_du_champ,objet représentant_le_champ>
     * afin de faciliter leur accès
     *
     * @param fields
     * @return
     */
    private static Map<String, Field> fieldsToMap(Field[] fields) {
        Map<String, Field> map = new HashMap<>();
        for (Field f : fields) {
            map.put(f.getName(), f);
        }

        return map;
    }

    /**
     * Méthode qui fait la conversion de la donnée extraite vers un type
     * primitif
     *
     * @param field : objet contenant les informations sur le type auquel
     * appartient le champ de la donnée extraite
     * @param value : donnée à convertir
     * @return : retourne un String si le type du champ ne figure pas dans la
     * liste ci-dessus
     */
    private static Object convertToPrimitive(Field field, String value) {
        Object obj = value;

        if (field.getType().isAssignableFrom(Integer.class)
                || field.getType().isAssignableFrom(int.class)) {
            obj = Integer.parseInt(value);
        } else if (field.getType().isAssignableFrom(Double.class)
                || field.getType().isAssignableFrom(double.class)) {
            obj = Double.parseDouble(value);
        } else if (field.getType().isAssignableFrom(java.math.BigDecimal.class)) {
            obj = new java.math.BigDecimal(value);
        } else if (field.getType().isAssignableFrom(Float.class)
                || field.getType().isAssignableFrom(float.class)) {
            obj = Float.valueOf(value);
        } else if (field.getType().isAssignableFrom(Long.class)
                || field.getType().isAssignableFrom(long.class)) {
            obj = Long.parseLong(value);
        } else if (field.getType().isAssignableFrom(Boolean.class)
                || field.getType().isAssignableFrom(boolean.class)) {
            Boolean.parseBoolean(value);
        }

        return obj;
    }
}