/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package corpus;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;

/**
 *
 * @author user
 */
public class ExtractionNGram2 {

    /**
     *
     */
    public ExtractionNGram2() {
    }
    BufferedReader inFile;
    FileReader f;

// Fonction AccésAuFichier permet d'accéder au corpus annoté
    static BufferedReader AccésAuFichier(String path) {

        try {
            BufferedReader inFile = Files.newBufferedReader(Paths.get(path), StandardCharsets.UTF_8);
            return inFile;
        } catch (Exception e) {
            System.out.println("Vérifiez le chemin de votre fichier");
            return null;
        }
    }

    // Génération de N-grams       
    /**
     *
     * @param liste
     * @param str
     * @param n
     */
    static public void gnerationNGrams(ArrayList<String> liste, String str, int n) {
        if (str.length() <= n) { // (==n)
            liste.add(str);
            return;
        } else {
            int counter = 0;
            String gram = "";

            while (counter < n) {
                gram += str.charAt(counter);
                counter++;
            }
            liste.add(gram);
            gnerationNGrams(liste, str.substring(1), n);
        }
    }

    static void collectStats(BufferedReader file, int nombre) {
        String line = "";
        try {
            line = file.readLine();
            ArrayList<String> nGramsDT = new ArrayList<String>();
            ArrayList<String> nGramsNDT = new ArrayList<String>();

            while (line != null) {
                String[] ss = line.split("\\[");
                String line1 = ss[0].toLowerCase();
                String line2 = ss[1];  // DT] ou NDT]
                String firstChar = line2.substring(0, 1); // avec substring
                if (firstChar.equals("N")) {
                    gnerationNGrams(nGramsNDT, line1, nombre);

                } else {
                    gnerationNGrams(nGramsDT, line1, nombre);

                }
                line = file.readLine();
            }
            //DT_NDT
//            BufferedWriter fichNDT_DT = new BufferedWriter(new FileWriter(new File("B:/Recherche/Mes corpus/NDT_DT.txt")));
//            for (String str : nGramsNDT) {
//                fichNDT_DT.write(str);
//                fichNDT_DT.newLine();
//            }
//            fichNDT_DT.write("******************************************");
//            fichNDT_DT.newLine();
//            for (String str : nGramsDT) {
//                fichNDT_DT.write(str);
//                fichNDT_DT.newLine();
//            }
//            fichNDT_DT.close();
//            System.out.println("fichier DT_NDT.txt est créé avec succès !");

            //NDT
            System.out.println("Le nombre de " + nombre + "-gramme de la liste Non Dialecte Tunisien (NDT) = " + nGramsNDT.size());
            PrintWriter fichNDT = new PrintWriter(new FileWriter("B:/Recherche/Mes corpus/NDT.txt"));
            //BufferedWriter fichNDT = Files.newBufferedWriter(Paths.get("B:/Recherche/Mes corpus/NDT.txt"), StandardCharsets.UTF_8);
            //BufferedWriter fichNDT = new BufferedWriter(new FileWriter(new File("B:/Recherche/Mes corpus/NDT.txt")));
            //fichNDT.write(occurence(nGramsNDT));
            //fichNDT.newLine();
            ExtractionNGram2 EN = new ExtractionNGram2();
            fichNDT.print(EN.occurence(nGramsNDT));
            fichNDT.close();
            System.out.println("fichier NDT.txt est créé avec succès!");

            //DT
            System.out.println("Le nombre de " + nombre + "-gramme de la liste Dialecte Tunisien (DT) = " + nGramsDT.size());
            BufferedWriter fichDT = new BufferedWriter(new FileWriter(new File("B:/Recherche/Mes corpus/DT.txt")));
            fichDT.write(EN.occurence(nGramsDT));
            //fichDT.newLine();
            fichDT.close();
            System.out.println("fichier DT.txt est créé avec succès !");

        } catch (Exception e) {
            System.out.println("erreur");
        }

        // ,ArrayList<String> mot
    }

    /**
     * *********************************************************************
     * mot entré à partir du clavier avec un espace au debut et à la fin
     *
     * ***************************************************************** @param
     * list
     */
    static String lireChaine() {
        Scanner sc = new Scanner(System.in);
        System.out.println("Saisissez votre mot: ");
        String mot = sc.nextLine();
        System.out.println("Le mot à identifier sera limité par deux espaces: " + "_" + mot + "_");
        return "_" + mot + "_";

    }
    
//    static String lireChaine() {
//        return System.console().readLine();
// 
//    }
    
//      static String lireChaine() {
//        Scanner sc = new Scanner(System.console().readLine());
//        System.out.println("Saisissez votre mot: ");
//        String mot = sc.nextLine();
//        System.out.println("Le mot à identifier sera limité par deux espaces: " + "_" + mot + "_");
//        return "_" + mot + "_";
//
//    }
    //

    /**
     * *********************************************************************
     * Comptage de nombre d'occurence de chaque n-grame s
     *
     * ***************************************************************** @param
     * list
     */
//    static String occurence(ArrayList<String> list) {
//        StringWriter writer = new StringWriter();
//        PrintWriter out = new PrintWriter(writer);
//        Set<String> unique = new HashSet<String>(list);
//        for (String key : unique) {
//            out.println(key + ":" + Collections.frequency(list, key));
//        }
//        
//        return writer.toString();
//    }
    private List<Integer> listOcc = new ArrayList<>();

    public String occurence(ArrayList<String> list) {
        StringWriter writer = new StringWriter();
        PrintWriter out = new PrintWriter(writer);
        Set<String> unique = new HashSet<String>(list);
        for (String key : unique) {
            out.println(key + ":" + Collections.frequency(list, key));
            listOcc.add(Collections.frequency(list, key));

        }
//        for (Integer occ : listOcc) {
//            out.println("----------------"+occ );
//            
//           
//        }

        return writer.toString();
    }

    /**
     * *********************************************************************
     * Chaercher les n-grammes dans lle fichier
     *
     * ***************************************************************** @param
     * list
     */
    public static int trouveMotFile(String fichier, String mot) throws FileNotFoundException {
//         try {
//        String line=null;
        boolean trouve = false;
        int x = 0;
//       line = fichier.readLine();
//       System.out.println("LLLLLLLLLLLLLL"+line);
//        if ((line!= null) && (!trouve)) {
        Scanner sc = new Scanner(new File(fichier),"utf8");

        while (sc.hasNextLine()) {
            String line = sc.nextLine();

            String[] ligne1 = line.split(":");
            int Fq = Integer.parseInt(ligne1[1]);
            String Gm = ligne1[0].toLowerCase();
            if (Gm.equals(mot)) {
                trouve = true;
                x = Fq;
            }

        }
        return x;
//          } catch (Exception e) {
//            
//            System.out.println("erreur");
//              return -1;
//        }
    }

    public static Map<String, Integer> ChercherChaineFichier(String fichier, ArrayList<String> listeMots) throws IOException {

        Map<String, Integer> frequences = new LinkedHashMap<String, Integer>();
        int freq = 0;
        for (String s : listeMots) {
            freq = trouveMotFile(fichier, s);
            frequences.put(s, freq);
        }

        for (Map.Entry<String, Integer> e : frequences.entrySet()) {
            System.out.println(e.getKey() + " = " + e.getValue());
        }
        return frequences;
    }

    /**
     * *********************************************************************
     * Compter les sommes des fréquences dans les fichiers
     *
     * ***************************************************************** @param
     * list
     */
    public static int sommeFrequences(BufferedReader fichier) throws IOException {
        String c = null;
        List<Integer> tab = new ArrayList<>();
        int j = 0;
        int somme = 0;
        while ((c = fichier.readLine()) != null) {

            String[] ligne = c.split(":");
            int Fq = Integer.parseInt(ligne[1]);

            tab.add(Fq);
        }
        for (int x : tab) {
            somme += x;
        }
        return somme;
    }

    /**
     * *********************************************************************
     * Calculer les probabilités
     *
     * ***************************************************************** @param
     */
    public static double probabilité(Map<String, Integer> map, int somme) throws IOException {
        double someProb = 0;
        for (Map.Entry<String, Integer> e : map.entrySet()) {
            double f = (e.getValue().doubleValue()) / somme;
            System.out.println(e.getKey() + " = " + f);///sommeFrequences(f));
            someProb += f;
        }

        return someProb;
    }

    // main
    /**
     *
     * @param args
     * @throws java.io.IOException
     */
    public static void main(String[] args) throws IOException {
        ArrayList l = new ArrayList<>();
        java.util.Scanner entree = new java.util.Scanner(System.in);
        System.out.println("Saisissez le nombre de gramme : Unigramme (n=1) | Bigramme (n=2) | Trigramme (n=3)  n ==> ");
        int x = entree.nextInt();
        if (x >= 1 && x <= 3) {
            BufferedReader BR = AccésAuFichier("B:/Recherche/Mes corpus/MonCorpus.txt");
            collectStats(BR, x);
        } else {
            System.out.println("nombre de n-gramme non autorisé !");
        }
        String Input = lireChaine();
        gnerationNGrams(l, Input, x);
        System.out.println("l'extraction de " + x + "-grames: " + l);
        System.out.println("les fréquences de chaque " + x + "-gram dans DT");
        Map<String, Integer> grammeFreqDT = ChercherChaineFichier("B:/Recherche/Mes corpus/DT.txt", l);
        System.out.println("les fréquences de chaque " + x + "-gram dans NDT");
        Map<String, Integer> grammeFreqNDT = ChercherChaineFichier("B:/Recherche/Mes corpus/NDT.txt", l);

        int sommeDT = sommeFrequences(AccésAuFichier("B:/Recherche/Mes corpus/DT.txt"));
        System.out.println("la somme des fréqeunce DT ==" + sommeDT);

        int sommeNDT = sommeFrequences(AccésAuFichier("B:/Recherche/Mes corpus/NDT.txt"));
        System.out.println("la somme des fréqeunce NDT ==" + sommeNDT);
        System.out.println("******************** DT ******************** ");
        double pDT = probabilité(grammeFreqDT, sommeDT);
        System.out.println("**** la somme des proba DT = " + pDT + " ******** ");

        double pNDT = probabilité(grammeFreqNDT, sommeNDT);
        System.out.println("**** la somme des proba NDT = " + pNDT + " ******** ");

        if (pDT > pNDT) {
            System.out.println("le mot " + Input + " est un DT");
        } else {
            System.out.println("le mot " + Input + " est un NDT");
        }
        System.out.println(System.getProperty("file.encoding"));
        System.out.println(System.console());
        
        
    }
}