#include <iostream>
#include <string>
#include <vector>
#include <array>
#include <memory>
#include <stdint.h>


class IFrame
{
public:
    using FieldKey = int;

    virtual bool read(const std::vector<uint8_t> &data) = 0;
    virtual bool write(std::vector<uint8_t> &data) const = 0;
    virtual bool set(const FieldKey key, int index, T value) = 0;
    bool set(const FieldKey key, T value)
};

/*
class Codec
{
public:
    virtual bool encode() = 0
};*/

class TextFrame : public IFrame
{
public:
    std::string text;

    TextFrame(const std::string &text) : text(text) {}

    virtual bool read(const std::vector<uint8_t> &data) override {
        text = std::string(data.begin(), data.end());
        return true;
    }
    virtual bool write(std::vector<uint8_t> &data) const override {
        data = std::vector<uint8_t>(text.begin(), text.end());
        return true;
    }
};

class ComplexFrame : public IFrame
{
    uint32_t from;
    uint32_t to;
    uint8_t flags;
    std::vector<uint8_t> data;
};

class BaseCodec
{

};

template<class T>
class Codec
{
public:
    using FrameType = T;
    using DecodeSignal = Signal<void(const FrameType &frame)>;
    using EncodeSignal = Signal<void(const std::vector<uint8_t> &data)>;

    DecodeSignal decoded;
    EncodeSignal encoded;

    bool encode(const FrameType &input, std::vector<uint8_t> &output) {
        auto success = doEncode(input, output);
        if (success) encoded.emit(output);
        return success;
    }

    bool decode(const std::vector<uint8_t> &input, FrameType &output) {
        auto success = doDecode(input, output);
        if (success) decoded.emit(output);
        return success;
    }

    bool input(const std::vector<uint8_t> &decodable) {
        FrameType _;
        return decode(decodable, _);
    }

    bool output(const FrameType &encodable) {
        std::vector<uint8_t> _;
        return encode(encodable, _);
    }

protected:
    virtual bool doEncode(const FrameType &input, std::vector<uint8_t> &output) = 0;
    virtual bool doDecode(const std::vector<uint8_t> &input, FrameType &output) = 0;
};

class MorseCodec : public Codec<TextFrame>
{
private:
    static constexpr std::array<const char*, 128> ENCODE_LUT = []{
        std::array<const char*, 128> lut{};
        lut['A'] = ".-";
        lut['B'] = "-...";
        lut['C'] = "-.-.";
        lut['D'] = "-..";
        lut['E'] = ".";
        lut['F'] = "..-.";
        lut['G'] = "--.";
        lut['H'] = "....";
        lut['I'] = "..";
        lut['J'] = ".---";
        lut['K'] = "-.-";
        lut['L'] = ".-..";
        lut['M'] = "--";
        lut['N'] = "-.";
        lut['O'] = "---";
        lut['P'] = ".--.";
        lut['Q'] = "--.-";
        lut['R'] = ".-.";
        lut['S'] = "...";
        lut['T'] = "-";
        lut['U'] = "..-";
        lut['V'] = "...-";
        lut['W'] = ".--";
        lut['X'] = "-..-";
        lut['Y'] = "-.--";
        lut['Z'] = "--..";
        lut['0'] = "-----";
        lut['1'] = ".----";
        lut['2'] = "..---";
        lut['3'] = "...--";
        lut['4'] = "....-";
        lut['5'] = ".....";
        lut['6'] = "-....";
        lut['7'] = "--...";
        lut['8'] = "---..";
        lut['9'] = "----.";
        return lut;
    }();
public:
    bool encode(const IFrame &input, std::vector<uint8_t> &data) {
        bool succ = true;
        std::vector<uint8_t> bytes;
        data.clear();
        input.write(bytes);
        for (const auto b : bytes) {
            auto i = static_cast<size_t>(b);
            auto morse = ENCODE_LUT[std::toupper(i)];
            if (morse) {
                for (const auto c : std::string(morse)) {
                    data.push_back(static_cast<uint8_t>(c));
                }
                data.push_back(' ');
            } else {
                succ = false;
            }
        }
        return succ;
    }

    bool decode(const std::vector<uint8_t> &data, std::shared_ptr<IFrame> &frame)
    {
        return false;
    }
};


int main()
{
    MorseCodec morse;
    std::string message = "Welcome back 1848.";

    std::cout << "Encoding \"" << message << "\"" << std::endl;
    std::shared_ptr<IFrame> input = std::make_shared<TextFrame>(message);
    std::vector<uint8_t> coded;
    bool ok = morse.encode(*input, coded);

    std::cout << "Encoded: " << std::string(coded.begin(), coded.end()) << std::endl;


    /*
    MultiCodec codec{std::make_shared<MorseCodec>(), std::make_shared<ComplexCodec>()};

    std::shared_ptr<IFrame> output;
    if (codec.decode(coded, output)) {
        // That's certainly one way to do it, but that's whack.
        output.get(ComplexFrame.FROM, )
    }*/

    auto morsey = std::make_shared<MorseCodec>();
    auto complex = std::make_shared<ComplexCodec>();

    MultiDecoder decoder{morsey, complex};

    // That's the way to do it, put the lambda on the P T R
    morsey.decoded.connect([](std::shared_ptr<TextFrame> frame) {
       std::cout << "Decoded morse: " << frame.text << std::endl;
    });

}