Vocabulary v0.3

#include<tchar.h>
#include<urlmon.h>
#include<iostream>
#include<conio.h>
#include<string>
#include<fstream>
#include<vector>
#include<iosfwd>
#include<algorithm>
#include<ctime>
#include<deque>
#include"bass.h"

#pragma comment(lib, "bass.lib")
#pragma comment(lib, "urlmon.lib")

std::vector<std::string> WordsEng;
std::vector<std::string> WordsPol;
std::deque<bool> isSound;
unsigned nAmount;

#ifndef __DEBUG
std::wstring s2ws(const std::string& s)
{
    int len;
    int slength = (int)s.length() + 1;
    len = MultiByteToWideChar(CP_ACP, 0, s.c_str(), slength, 0, 0);
    std::wstring r(len, L'\0');
    MultiByteToWideChar(CP_ACP, 0, s.c_str(), slength, &r[0], len);
    return r;
}
#endif

std::string FuckS(std::string sWord)
{
    for (unsigned i = 0; i < sWord.length(); ++i)
    {
        if (sWord[i] == ' ')
        {
            sWord.replace(i, 1, "_");
        }
    }
    return sWord;
}

void DownloadS(std::string sWord, std::string sFunc)
{
    sWord = FuckS(sWord);
    std::string sUrl = "http://www.diki.pl/images/en/mp3/"+ sWord + ".mp3";
    std::string sDest = "Sounds/"+ sWord + ".mp3";
    HRESULT result = URLDownloadToFile(NULL, s2ws(sUrl).c_str(), s2ws(sDest).c_str(), 0, NULL );
    //HRESULT result = URLDownloadToFile(NULL, sUrl.c_str(), sDest.c_str(), 0, NULL);
    if (sFunc == "AddW") isSound.push_back(result == S_OK);

}

void PlayS(std::string sWord)
{
    sWord = FuckS(sWord);
    std::string sPath = "C:/Vocabulary/Sounds/"+ sWord + ".mp3";
    HSTREAM stream = BASS_StreamCreateFile(FALSE, sPath.c_str(), 0, 0, 0);
    BASS_ChannelPlay(stream, FALSE);
    Sleep(1500);
    BASS_StreamFree(stream);
}

void AddW(const std::string& sWordEng, const std::string& sWordPol, void (*pfDownloadS)(std::string, std::string))
{
    ++nAmount;

    WordsEng.push_back(sWordEng);
    WordsPol.push_back(sWordPol);

    pfDownloadS(sWordEng, __FUNCTION__);
}

void LoadW()
{
    std::fstream file;
    std::string sTemp = "";

    file.open("vocabulary.txt", std::ios::in);

    while (!file.eof())
    {
        std::getline(file, sTemp);
        ++nAmount;
        if (sTemp == "") { --nAmount; continue; }
        else if (!(nAmount%2==0)) WordsEng.push_back(sTemp);
        else WordsPol.push_back(sTemp);
    }
    nAmount /= 2;

    file.close();
    file.clear();

    file.open("sounds.txt", std::ios::in);

    while (!file.eof())
    {
        std::getline(file, sTemp);
        if (sTemp == "") continue;
        isSound.push_back(sTemp != "0");
    }

    file.close();
    file.clear();
}

void SaveW()
{
    std::ofstream file;
    file.open("vocabulary.txt");

    for (unsigned i = 0; i<nAmount; ++i)
    {
        file<<WordsEng[i]<<std::endl;
        file<<WordsPol[i]<<std::endl;
    }

    file.close();
    file.clear();

    file.open("sounds.txt");
    for (unsigned i = 0; i<nAmount; ++i) file<<isSound[i]<<std::endl;
    file.close();

}

void Test(unsigned nAmountOfWords, void (*pfPlayS)(std::string), char& cMode)
{
    std::string sWord;
    unsigned nMode = 0, nGood = 0, nCount = 0, nCountT = 0;
    std::vector<unsigned> vuIndex;

    if (nAmountOfWords>nAmount)
    {
        std::cout<<"Bledna ilosc!"<<std::endl;
        return;
    }
    else if (nAmountOfWords == 0 ) nCount = nAmount;
    else nCount = nAmountOfWords;

    nCountT = nCount;

    for (unsigned i = 0; i<nAmount; ++i)    vuIndex.push_back(i);
    std::random_shuffle(vuIndex.begin(), vuIndex.end());

    if (nAmountOfWords != 0 && cMode != '1' && cMode != '2')
    {
        for (unsigned i = 0; i<nAmountOfWords; ++i)
        {
            if (!isSound[vuIndex[i]])
            {
                vuIndex.erase(vuIndex.begin() + i);
                --i;
            }
        }
    }

    for (unsigned i = 0; i<nCount; i++)
    {
        switch (cMode)
        {
            case '1':
                std::cout<<"Co oznacza: "<<WordsEng[vuIndex[i]]<<"?"<<std::endl;
                std::getline(std::cin, sWord);
                if (sWord == WordsPol[vuIndex[i]]) { std::cout<<"Bardzo dobrze!"<<std::endl; ++nGood; }
                else std::cout<<"Zle! To slowko oznacza: "<<WordsPol[vuIndex[i]]<<std::endl;
                break;
            case '2':
                std::cout<<"Podaj angielskie slowko oznaczajace: "<<WordsPol[vuIndex[i]]<<"!"<<std::endl;
                std::getline(std::cin, sWord);
                if (sWord == WordsEng[vuIndex[i]]) { std::cout<<"Bardzo dobrze!"<<std::endl; ++nGood; }
                else std::cout<<"Zle! Chodzilo mi o slowko: "<<WordsEng[vuIndex[i]]<<std::endl;
                break;
            case '3':
                if (!isSound[vuIndex[i]]) { --nCountT; continue; }
                std::cout<<"Jakie slowko slyszysz?"<<std::endl;
                Sleep(500);
                pfPlayS(WordsEng[vuIndex[i]]);
                std::getline(std::cin, sWord);
                if (sWord == WordsEng[vuIndex[i]]) { std::cout<<"Bardzo dobrze!"<<std::endl; ++nGood; }
                else { std::cout<<"Zle!"<<std::endl; }
                std::cout<<WordsEng[vuIndex[i]]<<" - "<<WordsPol[vuIndex[i]]<<std::endl;
                break;
            case '4':
                if (!isSound[vuIndex[i]]) { --nCountT; continue; }
                ++nCountT;
                std::cout<<"Jakie slowko slyszysz?"<<std::endl;
                Sleep(500);
                pfPlayS(WordsEng[vuIndex[i]]);
                std::getline(std::cin, sWord);
                if (sWord == WordsEng[vuIndex[i]]) { std::cout<<"Bardzo dobrze!"<<std::endl; ++nGood; }
                else { std::cout<<"Zle!"<<std::endl; }
                std::cout<<"A co oznacza to slowko po polsku?"<<std::endl;
                std::getline(std::cin, sWord);
                if (sWord == WordsPol[vuIndex[i]]) { std::cout<<"Bardzo dobrze!"<<std::endl; ++nGood; }
                else { std::cout<<"Zle!"<<std::endl; }
                std::cout<<WordsEng[vuIndex[i]]<<" - "<<WordsPol[vuIndex[i]]<<std::endl;
                break;
            case '5':
                if (!isSound[vuIndex[i]]) { --nCountT; continue; }
                std::cout<<"Jakie slowko slyszysz?"<<std::endl;
                Sleep(500);
                pfPlayS(WordsEng[vuIndex[i]]);
                std::getline(std::cin, sWord);
                if (sWord == WordsPol[vuIndex[i]]) { std::cout<<"Bardzo dobrze!"<<std::endl; ++nGood; }
                else { std::cout<<"Zle!"<<std::endl; }
                std::cout<<WordsEng[vuIndex[i]]<<" - "<<WordsPol[vuIndex[i]]<<std::endl;
                break;
            /*case '6':
                nMode = rand()%2;
                switch (nMode)
                {
                    case 0:
                        std::cout<<"Co oznacza: "<<WordsEng[vuIndex[i]]<<"?"<<std::endl;
                        std::getline(std::cin, sWord);
                        if (sWord == WordsPol[vuIndex[i]]){ std::cout<<"Bardzo dobrze!"<<std::endl; ++nGood; }
                        else std::cout<<"Zle! To slowko oznacza: "<<WordsPol[vuIndex[i]]<<std::endl;
                        break;
                    case 1:
                        std::cout<<"Podaj angielskie slowko oznaczajace: "<<WordsPol[vuIndex[i]]<<"!"<<std::endl;
                        std::getline(std::cin, sWord);
                        if (sWord == WordsEng[vuIndex[i]]) { std::cout<<"Bardzo dobrze!"<<std::endl; ++nGood; }
                        else std::cout<<"Zle! Chodzilo mi o slowko: "<<WordsEng[vuIndex[i]]<<std::endl;
                        break;
                }
                break;*/
            default:
                std::cout<<"Nie ma takiego trybu!"<<std::endl;
                break;
            }
        if (cMode == '1' || cMode == '2') pfPlayS(WordsEng[vuIndex[i]]);
        std::cout<<std::endl;
    }
    nCount = nCountT;
    std::cout<<"Wynik testu: "<<nGood<<"/"<<nCount<<" - "<<((float)nGood/nCount)*100<<"%"<<std::endl;
}

int main()
{
    srand(static_cast<unsigned>(time(NULL)));

    BASS_Init(-1, 44100, 0, GetConsoleWindow(), NULL);
    CoInitializeEx(0, NULL);

    WordsEng.clear();
    WordsPol.clear();
    isSound.clear();
    nAmount = 0;
    LoadW();

    char cChoice;
    int nAmountOfWords;
    std::string sWordEng = "", sWordPol = "";


    for (;;)
    {
        std::cout   <<"=============================="<<std::endl
                    <<"|                            |"<<std::endl
                    <<"| 1.Dodaj nowe slowka        |"<<std::endl
                    <<"| 2.Posluchaj                |"<<std::endl
                    <<"| 3.Test                     |"<<std::endl
                    <<"| 4.Wypisz wszystkie slowka  |"<<std::endl
                    <<"|                            |"<<std::endl
                    <<"=============================="<<std::endl;
        std::cin>>cChoice;
        std::cin.ignore();
        switch (cChoice)
        {
            case '1':
                std::cout<<"Wpisz x aby przerwac!"<<std::endl<<"=============================="<<std::endl;
                for(;;)
                {
                    std::cout<<"angielski: ";
                    std::getline(std::cin, sWordEng);
                    if (sWordEng == "x") break;
                    std::cout<<"polski: ";
                    std::getline(std::cin, sWordPol);
                    if (sWordPol == "x") break;

                    std::cout<<"=============================="<<std::endl;
                    AddW(sWordEng, sWordPol, DownloadS);
                }
                break;
            case '2':
                std::cout<<"Wpisz slowko: ";
                std::getline(std::cin, sWordEng);
                DownloadS(sWordEng, __FUNCTION__);
                PlayS(sWordEng);
                break;
            case '3':
                std::cout<<"Ilosc slowek: ";
                std::cin>>nAmountOfWords;
                std::cout   <<"Wybierz forme testu:"<<std::endl
                            <<"1. ang -> pol"<<std::endl
                            <<"2. pol -> ang"<<std::endl
                            <<"3. sluch -> ang"<<std::endl
                            <<"4. sluch -> ang -> pol"<<std::endl
                            <<"5. sluch -> pol"<<std::endl;
                            //<<"6. losowo"<<std::endl;
                std::cin>>cChoice;
                std::cin.ignore();
                Test(nAmountOfWords, PlayS, cChoice);
                break;
            case '4':
                for (unsigned i = 0; i<nAmount;++i)
                {
                    std::cout<<i+1<<". "<<WordsEng[i]<<" - "<<WordsPol[i]<<std::endl;
                }
                break;
            default:
                BASS_Free();
                CoUninitialize();
                SaveW();
                exit(0);
        }
    }
}