#include <cstdint>
#include <cstdlib>
#include <fstream>
#include <ios>
#include <iostream>
#include <istream>
#include <map>
#include <ostream>
#include <string>
#include <vector>
using namespace std;



void kodowanie(istream &wejscie, ostream &wyjscie)
{
    map<vector<char>, uint16_t> Slownik;

    uint16_t n=0;
    for (int i = -128; i <= 127; i++)
    {
        Slownik[{(char)(i)}] = n;
        n++;
    }

    vector<char> ciag_znakow; // String
    char znak_zczytywany;

    while (wejscie.get(znak_zczytywany))
    {


        ciag_znakow.push_back(znak_zczytywany);

        if (Slownik.count(ciag_znakow) == 0)
        {


            Slownik[ciag_znakow] = n;
            n++;
            ciag_znakow.pop_back();
            wyjscie.write((char*) (&Slownik.at(ciag_znakow)), sizeof (uint16_t));
            ciag_znakow = {znak_zczytywany};


        }
    }

    if (!ciag_znakow.empty())
    {

        wyjscie.write((char*)(&Slownik.at(ciag_znakow)), sizeof (uint16_t));

    }
}



void dekodowanie(istream &wejscie, ostream &wyjscie)
{
    vector<vector<char>> Slownik;



    for (int i = -128; i <= 127; i++)
    {
         Slownik.push_back({(char)(i)});
    }
    vector<char> ciag_znakow; // String
    uint16_t k; // Key

    while (wejscie.read(reinterpret_cast<char *> (&k), sizeof (uint16_t)))
    {

        if (k == Slownik.size()){
            ciag_znakow.push_back(ciag_znakow[0]);
            Slownik.push_back(ciag_znakow);
        }
        else
        if (!ciag_znakow.empty())
        {
            ciag_znakow.push_back(Slownik.at(k).front());
            Slownik.push_back(ciag_znakow);
        }


        wyjscie.write(&Slownik.at(k).front(), Slownik.at(k).size());
        ciag_znakow = Slownik.at(k);
    }

}


int main(int argc, char *argv[])
{


    enum class Mode {
        Kodowanie,
        Dekodowanie
    };

    Mode m;

    if (std::string(argv[1]) == "-znak_zczytywany")
        m = Mode::Kodowanie;
    else
    if (std::string(argv[1]) == "-d")
        m = Mode::Dekodowanie;


    ifstream input_file(argv[2], std::ios_base::binary);


    ofstream output_file(argv[3], std::ios_base::binary);

        if (m == Mode::Kodowanie)
            kodowanie(input_file, output_file);
        else
        if (m == Mode::Dekodowanie)
            dekodowanie(input_file, output_file);


}