package lemmaextractor;

import com.cybozu.labs.langdetect.Detector;
import com.cybozu.labs.langdetect.DetectorFactory;
import com.cybozu.labs.langdetect.LangDetectException;
import lemmaextractor.results.Result;
import org.ini4j.Ini;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.HashMap;

/**
 * Klasa udostępniająca działanie tagera WCRFT oraz modułu rozpoznawania nazw
 * własnych Liner2. Klasa umożliwia analizę czystego tekstu w języku polskim.
 * Wynikiem analizy są dwa ciągi zapiane w postaci obiektów typu String
 * zawierających słowa oddzielone spacjami.
 * Pierwszym ciągiem jest ciąg form podstawowych (lematów) wszystkich wyrazów
 * w tekście. Drugim ciągiem jest ciąg form podstawowych (lematów) tych wyrazów
 * z tekstu wejściowego, które należą do nazw własnych.
 * Dodatkowo, udostępniamy możliwość pobrania wszystkich form napotkanych
 * (odmienionych jak w tekście wejściowym), które należą do nazw własnych.
 * TODO: wyjątki, gdy nie uda się znaleźć/załadować configu tagera/linera?
 */
public class Extractor {

    private LanguageProcessor processor;

    private Detector langDetector;
    private HashMap<String, LanguageProcessor> processors;
    private boolean fixedLang;

    /**
     * Utworzenie modułu, inicjalizacja narzędzi określonych w pliku konfiguracyjnym.
     *
     * @param iniPath   -- ścieżka do pliku konfiguracyjnego (*.ini)
     *                     określającego język (możliwe automatyczne rozpoznanie)
     *                     oraz konfiguracje narzędzi dla poszczególnych języków
     */
    public Extractor(String iniPath) throws FileNotFoundException, LangDetectException {
        Ini extractorConfig = new Ini();
        try {
            extractorConfig.load(new FileReader(iniPath));
            extractorConfig.setFile(new File(iniPath));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("Could not load ini file from path: "+iniPath);
        }
        String iniDir = extractorConfig.getFile().getParent();
        Ini.Section main = extractorConfig.get("main");
        boolean useNER = Boolean.valueOf(main.get("useNER"));
        if( Boolean.valueOf(main.get("langDetection"))){
            fixedLang = false;
            if(DetectorFactory.getLangList().isEmpty()){
                DetectorFactory.loadProfile(new File(iniDir, "dependencies/langProfiles"));
            }
            processors = ProcessorFactory.initializeAll(extractorConfig, useNER);
        }
        else{
            fixedLang = true;
            String lang = main.get("default");
            processor = ProcessorFactory.initializeProcessor(lang, extractorConfig, iniDir, useNER);
        }

    }


    /**
     * Dokonuje analizy podanego tekstu wraz z rozpoznaniem nazw własnych.
     * Wynik analizy zwracany jako obiekt Result
     * @param text -- tekst do przetworzenia
     * @return obiekt zawierający wynik przetwarzania
     */
    public Result processFull(String text) throws Exception {
        if(fixedLang){
            return processor.processFull(text);
        }
        else{
            return getProcessor(detectLang(text)).processFull(text);
        }
    }

    /**
     * Dokonuje wyłącznie analizy morfosyntaktycznej podanego tekstu.
     * Wynik analizy zwracany jako obiekt Result
     * @param text -- tekst do przetworzenia
     * @return obiekt zawierający wynik przetwarzania
     */
    public Result processLemmas(String text) throws Exception {
        if(fixedLang){
            return processor.processLemmas(text);
        }
        else{
            return getProcessor(detectLang(text)).processLemmas(text);
        }
    }

    private String detectLang(String text) throws Exception {
        langDetector = DetectorFactory.create();
        langDetector.append(text);
        String detectedLang = langDetector.detect();
        return detectedLang;
    }

    private LanguageProcessor getProcessor(String lang){
        if(!processors.containsKey(lang)){
            DummyProcessor dummy = (DummyProcessor)processors.get("unknown");
            dummy.setLang(lang);
            return dummy;
        }
        else{
            return processors.get(lang);
        }
    }

    /**
     * Jawne zamknięcie modułu.
     */
    public void close(){}
}