#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")

enum TEST_MODE { NORMAL, BLACKLIST, RANGE };

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

#ifndef __DEBUG
inline 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

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

void RemoveW(unsigned nIndex)
{
	if (nIndex < nAmount)
	{
		WordsEng.erase(WordsEng.begin() + nIndex);
		WordsPol.erase(WordsPol.begin() + nIndex);
		isSound.erase(isSound.begin() + nIndex);
		blackList.erase(blackList.begin() + nIndex);
		--nAmount;
	}
	else std::cout<<">>Nie ma slowka z takim numerem!"<<std::endl;
}

void DownloadS(std::string sWord, std::string sFunc)
{
	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)
{
	FuckS(sWord);
	std::string sPath = "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();

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

	while (!file.eof())
	{
		std::getline(file, sTemp);
		if (sTemp == "") continue; 
		blackList.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();
	file.clear();

	file.open("blacklist.txt");
	for (unsigned i = 0; i<nAmount; ++i) file<<blackList[i]<<std::endl;
	file.close();
	file.clear();
	
}

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

	if (nAmountOfWords == 0 ) nCount = nAmount;
	else nCount = nAmountOfWords;

	nCountT = nCount;

	for (unsigned i = nRangeFrom; i<nRangeTo; ++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;
			}
		}
	} 

	std::cout<<"Wpisz x aby przerwac!"<<std::endl<<std::endl;

	for (unsigned i = 0; i<nCount; i++)
	{
		switch (cMode)
		{
			case '1':
				if (eType == BLACKLIST && !blackList[vuIndex[i]]) { --nCountT; continue; }
				std::cout<<">>Co oznacza: "<<WordsEng[vuIndex[i]]<<"?"<<std::endl;
				std::getline(std::cin, sWord);
				if (sWord == "x") { i = nCount-1; std::cout<<">>Test przerwany!"<<std::endl; }
				else if (sWord == WordsPol[vuIndex[i]]) { std::cout<<">>Bardzo dobrze!"<<std::endl; ++nGood; blackList[vuIndex[i]] = false; }
				else { std::cout<<">>Zle! To slowko oznacza: "<<WordsPol[vuIndex[i]]<<std::endl; blackList[vuIndex[i]] = true; }
				break;
			case '2':
				if (eType == BLACKLIST && !blackList[vuIndex[i]]) { --nCountT; continue; }
				std::cout<<">>Podaj angielskie slowko oznaczajace: "<<WordsPol[vuIndex[i]]<<"!"<<std::endl;
				std::getline(std::cin, sWord);
				if (sWord == "x") { i = nCount-1; std::cout<<">>Test przerwany!"<<std::endl; }
				else if (sWord == WordsEng[vuIndex[i]]) { std::cout<<">>Bardzo dobrze!"<<std::endl; ++nGood; blackList[vuIndex[i]] = false; }
				else { std::cout<<">>Zle! Chodzilo mi o slowko: "<<WordsEng[vuIndex[i]]<<std::endl; blackList[vuIndex[i]] = true; }
				break;
			case '3':
				if (eType == BLACKLIST && !blackList[vuIndex[i]]) { --nCountT; continue; }
				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 == "x") { i = nCount-1; std::cout<<">>Test przerwany!"<<std::endl; }
				else if (sWord == WordsEng[vuIndex[i]]) { std::cout<<">>Bardzo dobrze!"<<std::endl; ++nGood; blackList[vuIndex[i]] = false; }
				else { std::cout<<">>Zle!"<<std::endl; blackList[vuIndex[i]] = true; }
				std::cout<<WordsEng[vuIndex[i]]<<" - "<<WordsPol[vuIndex[i]]<<std::endl;
				break;
			case '4':
				if (eType == BLACKLIST && !blackList[vuIndex[i]]) { --nCountT; continue; }
				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 == "x") { i = nCount-1; std::cout<<">>Test przerwany!"<<std::endl; }
				else if (sWord == WordsEng[vuIndex[i]]) { std::cout<<">>Bardzo dobrze!"<<std::endl; ++nGood; blackList[vuIndex[i]] = false; }
				else { std::cout<<">>Zle!"<<std::endl; blackList[vuIndex[i]] = true; }
				std::cout<<">>A co oznacza to slowko po polsku?"<<std::endl;
				std::getline(std::cin, sWord);
				if (sWord == "x") { i = nCount-1; std::cout<<">>Test przerwany!"<<std::endl; }
				else if (sWord == WordsPol[vuIndex[i]]) { std::cout<<">>Bardzo dobrze!"<<std::endl; ++nGood; blackList[vuIndex[i]] = false; }
				else { std::cout<<">>Zle!"<<std::endl; blackList[vuIndex[i]] = true; }
				std::cout<<WordsEng[vuIndex[i]]<<" - "<<WordsPol[vuIndex[i]]<<std::endl;
				break;
			case '5':
				if (eType == BLACKLIST && !blackList[vuIndex[i]]) { --nCountT; continue; }
				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 == "x") { i = nCount-1; std::cout<<">>Test przerwany!"<<std::endl; }
				else if (sWord == WordsPol[vuIndex[i]]) { std::cout<<">>Bardzo dobrze!"<<std::endl; ++nGood; blackList[vuIndex[i]] = false; }
				else { std::cout<<">>Zle!"<<std::endl; blackList[vuIndex[i]] = true;}
				std::cout<<WordsEng[vuIndex[i]]<<" - "<<WordsPol[vuIndex[i]]<<std::endl;
				break;
			default:
				std::cout<<">>Nie ma takiego trybu!"<<std::endl;
				break;
			}
		if ((cMode == '1' || cMode == '2') && sWord != "x") pfPlayS(WordsEng[vuIndex[i]]);
		std::cout<<std::endl;
	}
	std::cout<<">>Wynik testu: "<<nGood<<"/"<<nCountT<<" - "<<((float)nGood/nCountT)*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 = "", sIndex = "";
	TEST_MODE eType;
	unsigned nRangeFrom, nRangeTo;
	

	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);
				}
				std::cout<<std::endl;
				break;
			case '2':
				std::cout<<">>Wpisz slowko: ";
				std::getline(std::cin, sWordEng);
				DownloadS(sWordEng, __FUNCTION__);
				PlayS(sWordEng);
				break;
			case '3':
				std::cout	<<">>Wybierz zrodlo slownictwa:"<<std::endl
							<<"1. Wszystkie slowka"<<std::endl
							<<"2. Czarna lista"<<std::endl
							<<"3. Zakres"<<std::endl;
				std::cin>>cChoice;
				switch(cChoice)
				{
					case '1':
						std::cout<<">>Ilosc slowek: ";
						std::cin>>nAmountOfWords;
						nRangeFrom = 0;
						nRangeTo = nAmount;
						if (nAmountOfWords > nAmount) { std::cout<<">>Blad! Nie ma tylu slowek w bazie!"<<std::endl; continue; }
						eType = NORMAL;
						break;
					case '2':
						nRangeFrom = 0;
						nRangeTo = nAmount;
						nAmountOfWords = 0;
						eType = BLACKLIST;
						break;
					case '3':
						std::cout<<">>Zakres..."<<std::endl;
						std::cout<<"od: ";
						std::cin>>nRangeFrom;
						std::cout<<"do: ";
						std::cin>>nRangeTo;
						nRangeFrom -= 1;
						nAmountOfWords = (nRangeTo - nRangeFrom);
						if (nAmountOfWords <= 0) { std::cout<<">>Blad! Ujemna ilosc slowek!"<<std::endl; continue; }
						if (nRangeFrom > nAmount || nRangeTo > nAmount) { std::cout<<">>Blad! Nie ma slowek o takich indeksach!"<<std::endl; continue; }
						eType = RANGE;
						break;
					default:
						std::cout<<">>Blad!"<<std::endl;
						continue;				
				}
				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;
				std::cin>>cChoice;
				std::cin.ignore();
				std::cout<<std::endl;
				Test(nAmountOfWords, PlayS, cChoice, eType, nRangeFrom, nRangeTo);
				break;
			case '4':
				for (unsigned i = 0; i<nAmount;++i)
				{
					std::cout<<i+1<<". "<<WordsEng[i]<<" - "<<WordsPol[i]<<std::endl;
				}
				while (cChoice != '2')
				{
					std::cout<<"=============================="<<std::endl
							<<"1. Usun slowka."<<std::endl
							<<"2. Wroc do menu."<<std::endl
							<<"=============================="<<std::endl;
					std::cin>>cChoice;
					std::cin.ignore();
					switch (cChoice)
					{
						case '1':
							std::cout<<">>Ktore slowko chcesz usunac? ";
							std::getline(std::cin, sIndex);
							RemoveW(std::stoi(sIndex)-1);
							break;
						case '2':
							break;
						default:
							std::cout<<">>Nie ma takiej opcji!"<<std::endl;
							break;
					}
				}
				break;
			default:
				BASS_Free();
				CoUninitialize();
				SaveW();
				exit(0);
		}
	}
}