#pragma once

#include <string>
#include <fstream>
#include <iostream>
#include <cmath>
#include <chrono>
#include <random>
#include <cctype>

using Map = std::unordered_map<std::string, double>;

inline Map ReadNgrams(const std::string& filename) {
    const int64_t TOTAL_SUM = 4224127912;

    std::ifstream ngramms_file(filename, std::ifstream::in);
    Map res;

    std::string ngram;
    double number;
    while (ngramms_file >> ngram >> number) {
        res[ngram] = std::log(number / static_cast<double>(TOTAL_SUM));
    }
    return res;
}

inline double Evaluate(const std::vector<char>& perm, const std::string& text, const Map& dict) {
    std::vector<char> cur_letters;
    double cur_res = 0;
    for (int letter_in_text = 0; letter_in_text < text.size(); ++letter_in_text) {
        if (isalpha(text[letter_in_text])) {
            cur_letters.push_back(text[letter_in_text]);
        }
        if (cur_letters.size() >= 4) {
            std::string cur_ngramm = "    ";
            for (size_t letter_in_ngramm = 0; letter_in_ngramm < 4; ++letter_in_ngramm) {
                char cur_letter = cur_letters[cur_letters.size() - 1 - 3 + letter_in_ngramm];
                cur_ngramm[letter_in_ngramm] = perm[toupper(cur_letter) - 'A'];
            }
            if (dict.find(cur_ngramm) != dict.end()) {
                cur_res += dict.at(cur_ngramm);
            } else {
                cur_res += -50;
            }
        }
    }
    return cur_res;
}

inline std::string Decode(const std::string& text, const Map& dict) {
    int number = 0;
    std::minstd_rand0 random_gen(1234122);
    std::uniform_int_distribution<int> dist(0, 25);

    std::string cur_text = text;
    std::vector<char> cur_perm;
    for (char c = 0; c < 26; ++c) {
        cur_perm.push_back('A' + c);
    }
    double cur_score = Evaluate(cur_perm, cur_text, dict);

    for (int time = 0; time < 10000; ++time) {
        std::vector<char> tmp_perm = cur_perm;
        int char1 = -1, char2 = -1;
        while (char1 == char2) {
            char1 = dist(random_gen);
            char2 = dist(random_gen);
        }
        {
            char old_char = tmp_perm[char1];
            tmp_perm[char1] = tmp_perm[char2];
            tmp_perm[char2] = old_char;
        }

        double tmp_score = Evaluate(tmp_perm, cur_text, dict);
        if (tmp_score > cur_score) {
            cur_score = tmp_score;
            cur_perm = tmp_perm;
            number++;
        }
         std::cout << time + 1 << std::endl;
    }
    std::string decoded_text = text;
    for (int i = 0; i < decoded_text.size(); ++i) {
        if (isalpha(decoded_text[i])) {
            if (isupper(decoded_text[i])) {
                decoded_text[i] = cur_perm[decoded_text[i] - 'A'];
            } else {
                decoded_text[i] = tolower(cur_perm[toupper(decoded_text[i]) - 'A']);
            }
        }
        // std::cout << decoded_text[i];
    }
    std::cout << number << "\n";
    return decoded_text;
}