extern crate csv;

use std::collections::HashMap;
use std::error::Error;
use std::fs;
use std::fs::File;
use std::io::{BufRead, BufReader};


// Handling strings

pub fn get_words_from_string(string_to_analyze: &str, dict_name: &str, return_type: &str) {
    let mut word_list: Vec<String> = Vec::new();
    for split_word in string_to_analyze.split(&[' ', '\''][..]) {
        word_list.push(split_word.to_string());
    }
    get_lemma_from_string(word_list, dict_name, return_type, string_to_analyze);
}

pub fn get_lemma_from_string(word_list: Vec<String>, dict_name: &str, return_type: &str, string_to_analyze: &str) {
    let dict_lines = vec![dict_name];

    let mut lemma_map: HashMap<String, String> = HashMap::new();
    for dline in dict_lines {
        let mut rdr = csv::Reader::from_path(dline).unwrap();

        for rec in rdr.records() {
            let rr = rec.unwrap();
            let lemma = rr.get(0).unwrap();
            let derivatives = rr.get(1).unwrap();
            lemma_map.insert(lemma.into(), derivatives.into());
        }
    }
    process_data_from_string(word_list, lemma_map, return_type, string_to_analyze);
}

pub fn process_data_from_string(word_list: Vec<String>, lemma_map: HashMap<String, String>, return_type: &str, string_to_analyze: &str) {
    let mut lemma_string: Vec<String> = Vec::new();
    let mut lemma_line: Vec<String> = Vec::new();

    for word in &word_list {
        let mut changed_words: Vec<String> = Vec::new();
        for (lemma, derivatives) in &lemma_map {
            if derivatives.contains(",") {
                let split = derivatives.split(",");
                for s in split {
                    if s.trim() == word {
                        lemma_line.push(lemma.to_string());
                        changed_words.push(word.to_string());
                        }
                    }
                } else if derivatives == word {
                    lemma_line.push(lemma.to_string());
                    changed_words.push(word.to_string());
                }
            }
            if changed_words.contains(&word.to_string()) {
            } else {
                lemma_line.push(word.to_string());
            }
        }
    lemma_string.push(lemma_line.join(" "));
    if return_type == "vec" {
        return_lemmatized_vec(lemma_string);
    }
    else if return_type == "txt" {
        output_lemmatized_txt(lemma_string);
}
    else if return_type == "csv" {
        let mut original_text: Vec<String> = Vec::new();
        original_text.push(string_to_analyze.to_string());
        if let Err(e) = output_lemmatized_csv(original_text, lemma_string) {
        eprintln!("{}", e);
    }
    }
}

pub fn return_lemmatized_vec(lemma_string: Vec<String>) -> Vec<String> {
    return lemma_string
}

// Handling files

pub fn get_words(filename: &str, dict_name: &str, file_output: &str) {
    let reader = BufReader::new(File::open(filename).expect("Cannot open file"));

    let mut word_list: Vec<String> = Vec::new();
    let mut original_text: Vec<String> = Vec::new();

    for line in reader.lines() {
        let mut line_words: Vec<String> = Vec::new();
        let mut unsplit_words: Vec<String> = Vec::new();
        for word in line.unwrap().split_whitespace() {
            unsplit_words.push(word.to_string());
            for split_word in word.split(&[' ', '\''][..]) {
                line_words.push(split_word.to_string());
            }
        }
        word_list.push(line_words.join(" "));
        original_text.push(unsplit_words.join(" "));

    }
    get_lemma(word_list, dict_name, file_output, original_text);
}

pub fn get_lemma(word_list: Vec<String>, dict_name: &str, file_output: &str, original_text: Vec<String>) {
    let dict_lines = vec![dict_name];

    let mut lemma_map: HashMap<String, String> = HashMap::new();
    for dline in dict_lines {
        let mut rdr = csv::Reader::from_path(dline).unwrap();

        for rec in rdr.records() {
            let rr = rec.unwrap();
            let lemma = rr.get(0).unwrap();
            let derivatives = rr.get(1).unwrap();
            lemma_map.insert(lemma.into(), derivatives.into());
        }
    }
    process_data(word_list, lemma_map, file_output, original_text);
}

pub fn process_data(word_list: Vec<String>, lemma_map: HashMap<String, String>, file_output: &str, original_text: Vec<String>) {
    let mut lemma_string: Vec<String> = Vec::new();

    for line in &word_list {
        let mut lemma_line: Vec<String> = Vec::new();
        let mut changed_words: Vec<String> = Vec::new();
        for word in line.split_whitespace() {
            for (lemma, derivatives) in &lemma_map {
                if derivatives.contains(",") {
                    let split = derivatives.split(",");
                    for s in split {
                        if s.trim() == word {
                            lemma_line.push(lemma.to_string());
                            changed_words.push(word.to_string());
                        }
                    }
                } else if derivatives == word {
                    lemma_line.push(lemma.to_string());
                    changed_words.push(word.to_string());
                }
            }
            if changed_words.contains(&word.to_string()) {
            } else {
                lemma_line.push(word.to_string());
            }
        }
        lemma_string.push(lemma_line.join(" "));
    }
    if file_output == "csv" {
        if let Err(e) = output_lemmatized_csv(original_text, lemma_string) {
        eprintln!("{}", e);
        }
    } else if file_output == "txt"{
        output_lemmatized_txt(lemma_string);
    }
    else if file_output == "vec" {
        return_lemmatized_vec(lemma_string);
    }
    else {
        if let Err(e) = output_lemmatized_csv(original_text, lemma_string) {
        eprintln!("{}", e);
        }
    }
}

pub fn output_lemmatized_txt(lemma_string: Vec<String>) {
    let mut writable_lemmas: Vec<String> = Vec::new();
    for word in lemma_string {
        writable_lemmas.push(word);
    }
    fs::write("lemmatized.txt", writable_lemmas.join("\n")).expect("Cannot write");
}

pub fn output_lemmatized_csv(
    original_text: Vec<String>,
    lemma_string: Vec<String>,
) -> Result<(), Box<dyn Error>> {
    let combined_vector = original_text.into_iter().zip(lemma_string).collect::<Vec<_>>();

    let mut wtr = csv::Writer::from_path("lemmatized.csv")?;
    wtr.write_record(&["Original Text", "Lemmatized Text"])?;
    for (pair, pair2) in combined_vector {
        wtr.write_record(&[pair, pair2])?;
    }

    wtr.flush()?;
    Ok(())
}