/** header */
#include <stdio.h>
#include <iostream>
#include <Windows.h>
#include <ctime>
#include <string>
#include <array>

#ifndef hotel
#define hotel
enum level {
    stupid,
    disgusting,
    horrible,
    awful,
    meh,
    decent,
    good,
    better,
    best,
    fine,
    hot
};
class Logger {
public:
    Logger();
    void sout(std::string s);
private:
    const std::array<WORD, 5> colours{ {
        0x04,
        0x0E,
        0x02,
        0x0A,
        0x07
            } };
    std::string getLevel(int lvl);
    const HANDLE hstdout = GetStdHandle(STD_OUTPUT_HANDLE);
    void consolas(WORD colour);
    std::string sin();
    void shout(hotel::level lvl, std::string s);
    hotel::level getLevelFromSize(std::string s);
public:
    void log(hotel::level lvl, std::string message);
};
#endif

/** main */
#include <iostream>
#include <string>
#include <array>
#include <mutex>
#include <thread>
#include <Windows.h>
#include "hotel.h"

COORD setCursor(HANDLE hstdout, int x, int y) {
    COORD c;
    c.X = x;
    c.Y = y;
    SetConsoleCursorPosition(hstdout, c);
    return c;
}
COORD setCursor(HANDLE hstdout, COORD pos) {
    SetConsoleCursorPosition(hstdout, pos);
    return pos;
}
void writeToPos(HANDLE hstdout, hotel::Logger logger, std::string message, COORD pos) {
    setCursor(hstdout, pos);
    logger.sout(message);
}
void printAndUnderline(HANDLE hstdout, hotel::Logger logger, std::string text, COORD currentCursorPos) {
    logger.sout(text);
    setCursor(hstdout, currentCursorPos.X, currentCursorPos.Y + 1);
    std::string underline = "^";
    for (int i = 0; i < text.length() - 1; i++) {
        underline += "^";
    }
    logger.sout(underline);
}
void initScreen(HANDLE hstdout, hotel::Logger logger, SMALL_RECT size) {
    //area
    COORD c = setCursor(hstdout, (int)(size.Left + 1), (int)(size.Top));
    printAndUnderline(hstdout, logger, "AREA TITLE", c);

    //inv
    c = setCursor(hstdout, (int)(size.Right - 73), (int)(size.Top));
    printAndUnderline(hstdout, logger, "INVENTORY", c);

    //right border
    int x = (int)(size.Right - 75);
    for (int y = 0; y < size.Bottom; y++) {
        setCursor(hstdout, x, y);
        logger.sout("X"); //std::cout << "X" << endl;
    }

    //divider
    int y = (int)(size.Bottom / 3);
    for (x; x < size.Right; x++){
        setCursor(hstdout, x, y);
        logger.sout("X");
    }

    //chat
    c = setCursor(hstdout, (int)(size.Right - 73), (int)((size.Bottom / 3) + 1));
    printAndUnderline(hstdout, logger, "CHAT", c);

    //bottom border
    y = (int)size.Bottom - 3;
    for (x = 0; x < size.Right - 75; x++) {
        setCursor(hstdout, x, y);
        logger.sout("X");
    }
}
/// <see cref="http://support.microsoft.com/default.aspx?scid=kb;en-us;124103"></see>
HWND getConsoleHwnd() {
#define MY_BUFSIZE 1024 // Buffer size for console window titles.
    HWND hwndFound;         // This is what is returned to the caller.
    char pszNewWindowTitle[MY_BUFSIZE]; // Contains fabricated
    // WindowTitle.
    char pszOldWindowTitle[MY_BUFSIZE]; // Contains original
    // WindowTitle.

    // Fetch current window title.

    GetConsoleTitle(pszOldWindowTitle, MY_BUFSIZE);

    // Format a "unique" NewWindowTitle.

    wsprintf(pszNewWindowTitle, "%d/%d",
        GetTickCount(),
        GetCurrentProcessId());

    // Change current window title.

    SetConsoleTitle(pszNewWindowTitle);

    // Ensure window title has been updated.

    Sleep(40);

    // Look for NewWindowTitle.

    hwndFound = FindWindow(NULL, pszNewWindowTitle);

    // Restore original window title.

    SetConsoleTitle(pszOldWindowTitle);

    return(hwndFound);
}
int main(int argc, char *argv[]) {
    AllocConsole();
    HWND hwnd = getConsoleHwnd();
    MoveWindow(hwnd, 0, 0, 1, 1, false);
    const HANDLE hstdout = GetStdHandle(STD_OUTPUT_HANDLE);
    COORD bufSize = GetLargestConsoleWindowSize(hstdout);
    bufSize.X -= 2;
    bufSize.Y -= 1;
    SetConsoleScreenBufferSize(hstdout, bufSize);

    SMALL_RECT size;
    size.Top = 0;
    size.Left = 0;
    size.Bottom = bufSize.Y - 1;
    size.Right = bufSize.X - 1;
    SetConsoleWindowInfo(hstdout, true, &size);

    hotel::Logger logger = Logger();
    std::string s;

    initScreen(hstdout, logger, size);

    /*std::thread t1;
    COORD tmp;
    tmp.X = 10;
    tmp.Y = 10;
    t1 = std::thread(writeToPos, hstdout, logger, "thread 1 test", tmp);

    std::thread t2;
    tmp.X = 30;
    tmp.Y = 30;
    t2 = std::thread(writeToPos, hstdout, logger, "thread 2 test", tmp);*/

    //where da typin' goes
    logger.log(hotel::level::horrible, "type something you dumb bitch");
    setCursor(hstdout, 35, size.Bottom + 100);
    std::getline(std::cin, s);
    //t1.join();
    //t2.join();
    return 0;
}

/** Logger class */
#include <stdio.h>
#include <iostream>
#include <Windows.h>
#include <ctime>
#include <string>
#include <array>
#include "hotel.h"
class Logger {
public:
    Logger() {
    }
    void sout(std::string s) {
        std::cout << s << std::endl;
    }
private:
    const std::array<WORD, 5> colours{ {
        0x04,
        0x0E,
        0x02,
        0x0A,
        0x07
            } };
    std::string getLevel(int lvl) {
        switch (lvl) {
        case hotel::level::stupid:
            return "stupid";
        case hotel::level::disgusting:
            return "disgusting";
        case hotel::level::horrible:
            return "horrible";
        case hotel::level::awful:
            return "awful";
        case hotel::level::meh:
            return "meh";
        case hotel::level::decent:
            return "decent";
        case hotel::level::good:
            return "good";
        case hotel::level::better:
            return "better";
        case hotel::level::best:
            return "best";
        case hotel::level::fine:
            return "fine";
        case hotel::level::hot:
            return "hot";
        default:
            return "unknown";
        }
    }

    const HANDLE hstdout = GetStdHandle(STD_OUTPUT_HANDLE);
    void consolas(WORD colour) {
        SetConsoleTextAttribute(hstdout, colour);
    }

    std::string sin() {
        std::string s;
        std::getline(std::cin, s);
        return s;
    }

    void shout(hotel::level lvl, std::string s) {
        //set console text colour
        switch (lvl) {
        case hotel::level::stupid:
        case hotel::level::disgusting:
        case hotel::level::horrible:
        case hotel::level::awful:
            consolas(colours[0]);
            break;
        case hotel::level::meh:
        case hotel::level::decent:
            consolas(colours[1]);
            break;
        case hotel::level::good:
        case hotel::level::better:
            consolas(colours[2]);
            break;
        case hotel::level::best:
        case hotel::level::hot:
            consolas(colours[3]);
            break;
        }

        char buf[12];
        time_t globtime = time(0);
        struct tm* loctime = new tm();
        localtime_s(loctime, &globtime);
        std::strftime(buf, 12, "[%H:%M:%S]", loctime);
        delete loctime;
        std::string t = "THREAD:";
        std::string i = std::to_string(GetCurrentThreadId());
        sout(buf + t + i + "/" + getLevel(lvl) + ": " + s);
        consolas(colours[4]);
    }

    hotel::level getLevelFromSize(std::string s) {
        if (s.length() < 10) return hot;
        else if (s.length() < 20) return hotel::level::best;
        else if (s.length() < 30) return hotel::level::better;
        else if (s.length() < 40) return hotel::level::good;
        else if (s.length() < 50) return hotel::level::decent;
        else if (s.length() < 60) return hotel::level::meh;
        else if (s.length() < 70) return hotel::level::awful;
        else if (s.length() < 80) return hotel::level::horrible;
        else if (s.length() < 90) return hotel::level::disgusting;
        else if (s.length() > 90) return hotel::level::stupid;
    }
public:
    void log(hotel::level lvl, std::string message) {
        shout(lvl, message);
    }
};