#include <iostream>
#include <fstream>
#include <string>
#include <sstream>
#include <map>

class initialization
{
    private:
        int amount, highestCount;
        std::string brailleLine, str[3];

    public:

        std::string readLinesFromText(char *file[]);
        void setAmountOfLines(char *file[]);
        int returnAmount() { return amount; }
        void populateTempCharArr(std::string tempStr1);
        int returnHighestCount(){ return highestCount; }

};

class brailleReading : public initialization
{
    private:
        std::map<int, std::string> numSequence;

    public:
        void populateMemoryCharacterMap();
        int stringToNumber(std::string tempString);
        std::string translateBrailleToEnglish(std::string tempPassStr);
        void initiateTranslation(std::string input);

};

void initialization::setAmountOfLines(char *file[])
{
    std::string line;
    std::ifstream myFile;
    int count = 0, iterator = 0;


    myFile.open(file[1]);


    if(myFile.is_open())
    {
        while(myFile.good())
        {
            getline(myFile, line);

            for( ; iterator < 3; iterator++)
                str[iterator] = line;

            ++count;
        }

        myFile.close();

    }
    else
        std::cout << "Unable to open file\n";


    amount = count - 1;

}


std::string initialization::readLinesFromText(char *file[])
{
    std::ifstream brailleFile;
    int iterator = 0;
    std::string tempStr, tempStr2;
    std::ostringstream stringStream;

    brailleFile.open(file[1]);


    if(brailleFile.is_open())
    {
        while(brailleFile.good())
        {
            getline(brailleFile, brailleLine, '\0');

            stringStream << brailleLine;

            tempStr += stringStream.str();


        }

        while(iterator < tempStr.length())
        {
            if((tempStr[iterator] == ' ') || (tempStr[iterator] == '.'))
                tempStr2 += tempStr[iterator];

            ++iterator;

        }


        brailleFile.close();

    }
    else
        std::cout << "Unable to open file\n";

    return tempStr2;

}

void brailleReading::populateMemoryCharacterMap()
{
    numSequence[1]     = "a";
    numSequence[2]     = "b";
    numSequence[14]    = "c";
    numSequence[145]   = "d";
    numSequence[15]    = "e";
    numSequence[124]   = "f";
    numSequence[1245]  = "g";
    numSequence[125]   = "h";
    numSequence[24]    = "i";
    numSequence[245]   = "j";
    numSequence[13]    = "k";
    numSequence[123]   = "l";
    numSequence[134]   = "m";
    numSequence[1345]  = "n";
    numSequence[135]   = "o";
    numSequence[1234]  = "p";
    numSequence[12345] = "q";
    numSequence[1235]  = "r";
    numSequence[234]   = "s";
    numSequence[2345]  = "t";
    numSequence[136]   = "u";
    numSequence[1236]  = "v";
    numSequence[2456]  = "w";
    numSequence[1346]  = "x";
    numSequence[13456] = "y";
    numSequence[1356]  = "z";

}

int brailleReading::stringToNumber(std::string tempString)
{
    int result;

    std::stringstream convert(tempString);

    if( !(convert >> result) )
        result = 0;

    return result;

}

std::string brailleReading::translateBrailleToEnglish(std::string tempPassStr)
{
    int key = 0;

    populateMemoryCharacterMap();
    key = stringToNumber(tempPassStr);

    for( std::map<int, std::string>::iterator intIter = numSequence.begin(); intIter != numSequence.end(); ++intIter )
    {
        if( (*intIter).first == key )
            return (*intIter).second;

    }
}

void brailleReading::initiateTranslation(std::string input)
{
        //starting positions for first braille character
    int letter1 = 0, letter2 = input.length() / 3, letter3 = letter2 * 2, letter4 = 1, letter5 = letter2 + 1, letter6 = letter3 + 1;
    std::string numberSeq = "\0";

    while( letter1 <= input.length() / 3 )
    {
        if(input[letter1] == '.')
            numberSeq = numberSeq + '1';

        if(input[letter2] == '.')
            numberSeq = numberSeq + '2';

        if(input[letter3] == '.')
            numberSeq = numberSeq + '3';

        if(input[letter4] == '.')
            numberSeq = numberSeq + '4';

        if(input[letter5] == '.')
            numberSeq = numberSeq + '5';

        if(input[letter6] == '.')
            numberSeq = numberSeq + '6';


        letter1 += 3;
        letter2 += 3;
        letter3 += 3;
        letter4 = letter1 + 1;
        letter5 = letter2 + 1;
        letter6 = letter3 + 1;

       if(numberSeq == "\0")
           std::cout << ' ';      //this will check for spaces and add them
       else
           std::cout << translateBrailleToEnglish(numberSeq);


        numberSeq = "\0";

    }
}

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

    brailleReading rayCharles;

    rayCharles.setAmountOfLines(argv);
    rayCharles.initiateTranslation( rayCharles.readLinesFromText(argv) );

    std::cout << '\n';



    return 0;

}