#ifndef SIMPLE_CONSOLE_HPP
#define SIMPLE_CONSOLE_HPP

#include <sstream>
#include <string>

// First, a couple of useful helpers

template <typename T = std::string, typename...Args>
T build_string( Args...args )
{
  std::ostringstream oss;
  (oss << ... << args);
  return T( oss.str() );
}

template <typename E = std::runtime_error, typename...Args>
E error( Args...args ) { return build_string <E> ( args... ); }

// Here’s our 24-bit color

struct rgb
{
  typedef unsigned char byte;

  byte red, green, blue;

  rgb( byte r = 0, byte g = 0, byte b = 0 )
  : red{r}, green{g}, blue{b} { }
};

// basic queries (which do NOT auto-magically invoke our “raw” console mode)

struct width_height { int width, height; };
width_height get_terminal_size();

bool is_key_pressed( int timeout_ms ); // (-1) for INFINITY, 0 for no wait
void flush_input();

// and all basic output (which DO auto-magically start our fancy-pants console mode)

template <typename...Args>
void output( Args...args )
{
  void _output( const std::string & );
  _output( build_string( args... ) );
}

void title( const std::string & );
void clear_screen();
void gotoxy( int x, int y ); // home == 0,0
void cursor( bool );
void colors( const rgb & fg, const rgb & bg );
void fcolor( const rgb & c );
void bcolor( const rgb & c );

#endif 

#include <ciso646>
#include <cstdio>
#include "console.hpp"

bool _is_initialized = false;
#define Q(b) if (_is_initialized == b) return;  _is_initialized = b

// All Windows-specifc code begins with the following incantation:

#ifdef _WIN32

  #include <windows.h>

  #define hstdin  GetStdHandle( STD_INPUT_HANDLE )
  #define hstdout GetStdHandle( STD_OUTPUT_HANDLE )

  static DWORD input_mode,     output_mode;
  static UINT  input_codepage, output_codepage;

  #define CSBI \
    CONSOLE_SCREEN_BUFFER_INFO csbi; \
    GetConsoleScreenBufferInfo( hstdout, &csbi );

  width_height get_terminal_size()
  {
    CSBI return {
      csbi.srWindow.Right  - csbi.srWindow.Left + 1,
      csbi.srWindow.Bottom - csbi.srWindow.Top  + 1 };
  }

  bool is_key_pressed( int timeout_ms )
  {
    return WaitForSingleObject( hstdin, (DWORD)timeout_ms ) == WAIT_OBJECT_0;
  }

  void flush_input() { FlushConsoleInputBuffer( hstdin ); }

  // On Windows, the only One True Way™ to print Unicode output is using WriteConsoleW().
  // This works for ANY code page on both Windows Console and Windows Terminal.

  void _write( const std::string & s )
  {
    DWORD n;
    std::wstring w( s.size(), 0 );  // Convert to UTF-16
    w.resize( MultiByteToWideChar( CP_UTF8, 0, (char *)s.c_str(), (int)s.size(), (wchar_t *)w.c_str(), (int)w.size() ) );
    WriteConsoleW( hstdout, (wchar_t *)w.c_str(), (DWORD)w.size(), &n, NULL );
  }

  void _finalize()
  {
    Q(false);
    _write( "\033[?1049l" "\033[?25h" );
    SetConsoleCP( input_codepage );
    SetConsoleOutputCP( output_codepage );
    SetConsoleMode( hstdin,  input_mode );
    SetConsoleMode( hstdout, output_mode );
  }

  void _initialize()
  {
    Q(true);
    GetConsoleMode( hstdin,  &input_mode );
    GetConsoleMode( hstdout, &output_mode );
    SetConsoleMode( hstdin,  ENABLE_VIRTUAL_TERMINAL_INPUT | ENABLE_EXTENDED_FLAGS );
    SetConsoleMode( hstdout, ENABLE_VIRTUAL_TERMINAL_PROCESSING | ENABLE_PROCESSED_OUTPUT );
    input_codepage  = GetConsoleCP();
    output_codepage = GetConsoleOutputCP();
    SetConsoleCP( 65001 );
    SetConsoleOutputCP( 65001 );
    setlocale( LC_ALL, ".UTF-8" );
    _write( "\033[?1049h" "\033[?25l" );
    atexit( &_finalize );
  }

// If it ain’t Windows, it must be Linux / OS X / etc

#else 

  #include <sys/types.h>
  #include <sys/ioctl.h>
  #include <poll.h>
  #include <termios.h>
  #include <unistd.h>

  static int _esc_delay = 100;
  static struct termios _initial_settings;

  width_height get_terminal_size()
  {
    struct winsize ws;
    ioctl( 0, TIOCGWINSZ, &ws );
    return { ws.ws_col, ws.ws_row };
  }

  bool is_key_pressed( int timeout_ms )
  {
    struct pollfd pls[ 1 ];
    pls[ 0 ].fd     = STDIN_FILENO;
    pls[ 0 ].events = POLLIN | POLLPRI;
    return poll( pls, 1, timeout_ms ) > 0;
  }

  void flush_input() { while (is_key_pressed( 0 )) getchar(); }

  // The Linux console has been UTF-8 capable for ages now.
  // Alas, we must still convert individual code point values to UTF-8 before output.

  void _write( const std::string & s ) { printf( "%s", s.c_str() ); fflush( stdout ); }

  void _finalize()
  {
    Q(false);
    _write( "\033[?1049l" "\033[?25h" );
    tcsetattr( STDIN_FILENO, TCSANOW, &_initial_settings );
  }

  void _initialize()
  {
    Q(true);
    const char * eds = getenv( "ESCDELAY" );
    if (eds) _esc_delay = atoi( eds );
    _esc_delay = (_esc_delay < 50) ? 50 : _esc_delay;

    auto e = error( "Could not initialize terminal" );

    if (tcgetattr( STDIN_FILENO, &_initial_settings ) < 0) throw e;
    auto settings = _initial_settings;
    settings.c_iflag &= ~(IGNBRK | BRKINT | IGNPAR | ICRNL | ISTRIP | INLCR | IXON );
    settings.c_oflag &= ~(OPOST);
    settings.c_cflag |=  (CS8);
    settings.c_lflag &= ~(ICANON | ISIG | ECHO | IEXTEN | TOSTOP);
    settings.c_cc[VMIN] = 0;
    settings.c_cc[VTIME] = 0;

    if (tcsetattr( STDIN_FILENO, TCSANOW, &settings ) < 0) throw e;

    setlocale( LC_ALL, ".UTF-8" );
    _write( "\033[?1049h" "\033[?25l" );
    atexit( &_finalize );
  }

#endif

void _output( const std::string & s ) { _initialize(); _write( s ); }

template <typename...Args> void OSC( Args...args ) { output( "\033]", args..., "\033\\" ); }
template <typename...Args> void CSI( Args...args ) { output( "\033[", args... ); }

void title( const std::string & s ) { OSC( "0;", s ); }
void clear_screen()                 { CSI( "2J" ); }
void gotoxy( int x, int y )         { CSI( y+1, ";", x+1, "H" ); }  // Home --> 0,0
void cursor( bool visible )         { CSI( visible ? "\?25h" : "\?25l" ); }
void colors( const rgb & fg, const rgb & bg )
#define C(F,c,L) F "8;2;", (int)c.red, ";", (int)c.green, ";", (int)c.blue, L
{
  CSI(C( "3", fg, ";" ), C( "4", bg, "m" ));
}
void fcolor( const rgb & c ) { CSI(C( "3", c, "m" )); }
void bcolor( const rgb & c ) { CSI(C( "4", c, "m" )); }

#include "console.hpp"

int main()
{
  title( "Console Example" );
  colors( rgb( 255, 255, 128 ), rgb( 0, 64, 32 ) );
  clear_screen();

  auto [width, height] = get_terminal_size();
  int x = width / 2 - 15;
  int y = height * 4 / 10;

  gotoxy( x, y );
  output( "Los niños dicen ¿qúe sapo, yo?" );

  gotoxy( x, y+1 );
  fcolor( rgb( 128, 128, 128 ) );

  output( "Now press the ‘ANY’ key..." );
  flush_input();
  is_key_pressed( -1 );
  flush_input();
}

//

#include <iostream>
#include <random>
#include <fstream>
#include <string>
#include <limits>

#define underline "\033[4m"
#define noUnderline "\033[0m"
#define clr "\033[2J\033[1;1H"

int main()
{
	std::random_device rd;
	std::mt19937 mersenne(rd());
	std::uniform_int_distribution<> die(0, 12880);

	int num = die(mersenne);

	std::ifstream inFile("wof.txt");

	if (!inFile.is_open())
	{
		std::cout << "Could Not Open File...\n";
		return 1;
	}

	std::string phrase, correct = "", guesses = "";

	for (int i = 0; i <= num; i++)
		getline(inFile, phrase);

	for (auto& i : phrase)
		i = toupper(i);

	bool won;
	num = 6;
	char g;
	do
	{
		std::cout << "\n\n\n" << clr;
		won = true;

		std::cout << "Tries Left: " << num << "\nPrevious Guesses: ";
		for (auto& i : guesses)
			std::cout << i << ' ';

		std::cout << "\n\n";

		for (auto& i : phrase)
		{
			if (i == ' ') std::cout << "  ";
			else if (!isalpha(i)) std::cout << i;
			else if(correct.find(i) != std::string::npos) std::cout << underline << i << noUnderline << ' ';
			else std::cout << underline << ' ' << noUnderline << ' ' && (won = false);
		}

		if (won)
			break;

		std::cout << "\n\nEnter Your Guess: ";
		std::cin >> g;

		//Left out so you can type whole words or letters if you know them
		//std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

		if (!isalpha(g))
			continue;

		g = toupper(g);

		if (phrase.find(g) == std::string::npos)
		{
			if (guesses.find(g) == std::string::npos)
			{
				num--;
				guesses += g;
			}
		}
		else correct += g;

	} while (!won && num);

	if (won) std::cout << "\n\nYou've Won!\n";
	else std::cout << "\nYou suck... You've lost.\n";

	for (auto& i : phrase)
	{
		if (i == ' ') std::cout << "  ";
		else if (!isalpha(i)) std::cout << i;
		else std::cout << underline << i << noUnderline << ' ';
	}

	std::cout << '\n';
}

#include <iostream>
#include <fstream>
#include <vector>
#include <random>
#include <ctime>

class giveMeDate {

private:
    struct tm newtime;
    __time32_t aclock;
    char buffer[32];
    errno_t errNum;

public:
    giveMeDate();
};

giveMeDate::giveMeDate()
{
    _time32(&aclock);
    _localtime32_s(&newtime, &aclock);

    errNum = asctime_s(buffer, 32, &newtime);
    std::cout << "Welcome : " << buffer << std::endl;
}

class guessMyWord : giveMeDate {

public:
    guessMyWord(std::string& myBook, int length = 4);
    bool bAnagram(std::string lhs, std::string rhs);
    void showSecretWords(std::string& guess, bool hiddenWord);
    // all words from the dictionary
    std::vector<std::string> words;
    std::pair<std::string, std::string> secretWord; // !!!

private:
    size_t randomNumber(const int min_, const int max_);
    void selectWord();
    std::string shuffleWord(std::string& word);
};
// constructor
guessMyWord::guessMyWord(std::string& myBook, int length)
{
    std::string word;
    std::ifstream input_file(myBook);

    if (!input_file.is_open())
    {
        std::cout << "Could not open the file " << myBook << std::endl;
        exit(EXIT_FAILURE);
    }

    while (input_file >> word)
        if (word.size() == length)
            words.push_back(word);

    input_file.close();
    // selects one word in the main vector
    selectWord();
}

size_t guessMyWord::randomNumber(const int min_, const int max_)
{
    std::random_device rd;
    std::mt19937 rng{ rd() };
    std::uniform_int_distribution<int> uid(min_, max_);

    return uid(rng);
}

void guessMyWord::selectWord()
{
    int rn = randomNumber(1, words.size() - 1);
    secretWord.first = words[rn];
    secretWord.second = shuffleWord(words[rn]); // debug mode
//  std::cout << "Hidden word : " << secretWord.first << " " << secretWord.second << std::endl;
}

std::string guessMyWord::shuffleWord(std::string& word) {
    
    std::string tmp{ word };

    do {
        std::shuffle(tmp.begin(), tmp.end(), std::default_random_engine(unsigned int(randomNumber(1, tmp.size() - 1))));
    } while (std::find(words.begin(), words.end(), tmp) != words.end());

    return tmp;
}

bool guessMyWord::bAnagram(std::string lhs, std::string rhs) 
{
    std::sort(lhs.begin(), lhs.end());
    std::sort(rhs.begin(), rhs.end());

    return lhs == rhs;
}

void guessMyWord::showSecretWords(std::string& guess, bool showHiddenWord)
{
    std::cout << std::endl;
    std::cout << "Anagrams available for this word (alternative good answers) :" << std::endl;
    int occ = 0;

    if (showHiddenWord)
    {
        std::cout << secretWord.first << std::endl;
        occ++;
    }

    for (size_t i = 0; i < words.size(); i++)
    {
        if (bAnagram(secretWord.first, words[i]) && guess != words[i])
        {
            std::cout << words[i] << std::endl;
            occ++;
        }
    }
    // no occurrence for anagrams
    occ == 0 ? std::cout << "[nothing]" << std::endl << std::endl
             : std::cout << std::endl;
}

int main()
{
    std::string dico = ".\\dictionary.txt";
    int letters = 4;

    while (true)
    {
        int tries{};
        std::string myGuess;
        // load dico, select a word, shuffle it...
        guessMyWord *gmw = new guessMyWord(dico, letters);

        std::cout << "~~ Guess My Word ~~" << std::endl;
        std::cout << "Words in the dictionary with " << letters << " letters : " << gmw->words.size() << std::endl;
        std::cout << std::endl;

        do
        {
            std::cout << "What is your suggestion for the letters [" << gmw->secretWord.second << "] ? " << std::endl;
            std::cin >> myGuess;
            // to lower case
            std::transform(myGuess.begin(), myGuess.end(), myGuess.begin(), [](unsigned char c) { return (unsigned char)std::tolower(c); });
            tries++;

            if (myGuess == "*cheat")
            {
                gmw->showSecretWords(gmw->secretWord.first, true);
                system("pause");
                return EXIT_SUCCESS;
            }
            // boring game?
            if (myGuess == "exit")
                return EXIT_SUCCESS;
            // not the right word length
            if (myGuess.length() != gmw->secretWord.first.length())
                std::cout << "Not the same length" << std::endl;
            else if (!gmw->bAnagram(myGuess, gmw->secretWord.first)) // one or more letters are not in the secret word
                std::cout << "Not the right letters" << std::endl; // the letters are good, the length too, but this word is weird
            else if (gmw->bAnagram(myGuess, gmw->secretWord.first) && std::find(gmw->words.begin(), gmw->words.end(), myGuess) == gmw->words.end())
                std::cout << "It seems that this word does not exist" << std::endl;
        } while (!gmw->bAnagram(myGuess, gmw->secretWord.first) || std::find(gmw->words.begin(), gmw->words.end(), myGuess) == gmw->words.end());
        // check if two strings are anagrams and if the guessed word exists in the dictionary - or loop again
        std::cout << "Correct! You got it in " << tries << " guesses!" << std::endl;
        // display alternatives - except the guessed word
        gmw->showSecretWords(myGuess, false);
        // increase difficulty
        letters++;
        // max difficulty
        if (letters > 14)letters = 14;
        // clean up
        delete gmw;
    }

    return EXIT_SUCCESS;
}