// websocket
#include <boost/beast/core.hpp>
#include <boost/beast/websocket.hpp>
#include <iostream>
#include <string>
#include <thread>
#include <functional>

// json
#include <nlohmann/json.hpp>

// windows child process
#include <windows.h>
#include <stdio.h>
#include <tchar.h>

// windows terminate process
#include <tlhelp32.h>

//hash
#include <boost/functional/hash.hpp>

// time
#include <chrono>
#include <ctime>

// fixed int
#include <cstdint>

// user
#include "user.h"
#include <vector>

// session
#include "sessionManager.h"

namespace beast = boost::beast;
namespace http = beast::http;
namespace websocket = beast::websocket;
namespace net = boost::asio;
using tcp = boost::asio::ip::tcp;


void EndProc(DWORD procId)
{
    PROCESSENTRY32 pe;

    memset(&pe, 0, sizeof(PROCESSENTRY32));
    pe.dwSize = sizeof(PROCESSENTRY32);

    HANDLE hSnap = ::CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

    if (::Process32First(hSnap, &pe))
    {
        BOOL bContinue = TRUE;

        // kill child processes
        while (bContinue)
        {
            // only kill child processes
            if (pe.th32ParentProcessID == procId)
            {
                HANDLE hChildProc = ::OpenProcess(PROCESS_ALL_ACCESS, FALSE, pe.th32ProcessID);

                if (hChildProc)
                {
                    ::TerminateProcess(hChildProc, 1);
                    ::CloseHandle(hChildProc);
                }
            }

            bContinue = ::Process32Next(hSnap, &pe);
        }

        // kill the main process
        HANDLE hProc = ::OpenProcess(PROCESS_ALL_ACCESS, FALSE, procId);

        if (hProc)
        {
            ::TerminateProcess(hProc, 1);
            ::CloseHandle(hProc);
        }
    }
}

template <typename T>
uint32_t hash6(T arg)
{
    boost::hash<T> h;
    return h(arg) % 1000000;
}

LRESULT CALLBACK GLWindowProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    if (msg == WM_DESTROY) PostQuitMessage(0);
    return DefWindowProc(hWnd, msg, wParam, lParam);
}

int main(int argc, char* argv[])
{
    // disable console input
    HANDLE hInput = GetStdHandle(STD_INPUT_HANDLE);
    DWORD prev_mode;
    GetConsoleMode(hInput, &prev_mode);
    SetConsoleMode(hInput, ENABLE_EXTENDED_FLAGS |
        (prev_mode & ~ENABLE_QUICK_EDIT_MODE));

    // ip and socket init
    std::string ip("192.168.1.115");
    uint16_t sess_port = 13001;
    auto const address = net::ip::make_address(ip);
    auto const port = static_cast<unsigned short>(std::atoi("8083"));

    net::io_context ioc{ 1 };

    tcp::acceptor acceptor{ ioc, {address, port} };

    // sessions
    sessionManager sessManager;
    sessManager.setlimit(10);

    // stats count
    uint64_t user_n = 0;

    while (true)
    {
        tcp::socket socket(ioc);
        acceptor.accept(socket);

        std::thread([sock = std::move(socket), &sessManager, &ip, &sess_port, &user_n]() mutable 
        {
            std::string user_ip = sock.remote_endpoint().address().to_string();
            uint64_t user_id = std::chrono::system_clock::now().time_since_epoch().count();
            user_id = hash6(user_ip + std::to_string(user_id));

            uint64_t thisUserNum = ++user_n;

            std::cout << "user(" << thisUserNum << ") connected (ip: " << user_ip << "), (id: " << user_id << ")" << std::endl;
            websocket::stream<tcp::socket> ws(std::move(const_cast<tcp::socket&>(sock)));
            ws.accept();
            // Set a decorator to change the Server of the 
            /*ws.set_option(websocket::stream_base::decorator(
                [](websocket::response_type& res)
                {
                    res.set(http::field::server, std::string(BOOST_BEAST_VERSION_STRING) + " websocket-server-sync");
                }));*/

            //session sessTmp;
            session* sessCur = nullptr;
            uint32_t sessId = 0;

            nlohmann::json jsonData;
            std::string message;
            std::string content;

            while (true)
            {
                try
                {
                    // This buffer will hold the incoming message
                    // buffer types https://www.boost.org/doc/libs/1_75_0/libs/beast/doc/html/beast/using_io/buffer_types.html
                    // check for the best one
                    // beast::multi_buffer buffer;
                    beast::flat_buffer buffer;

                    // Read a message
                    ws.read(buffer);

                    // cout buffer to string
                    //std::cout << beast::buffers_to_string(buffer.data()) << std::endl;
                    
                    // validate errors
                    try
                    {
                        jsonData = nlohmann::json::parse(beast::buffers_to_string(buffer.data()));
                        message = jsonData.at("message");
                    }
                    catch (nlohmann::json::parse_error& e)
                    {
                        std::cout << "Parse error:" << e.what() << std::endl;
                    }
                    catch (nlohmann::json::out_of_range& e)
                    {
                        std::cout << "Out of range:" << e.what() << std::endl;
                    }
                    catch (nlohmann::json::exception& e)
                    {
                        std::cout << "JSON exception: " << e.what() << std::endl;
                    }
                    catch (std::exception& e)
                    {
                        std::cout << "Unknown exception" << e.what() << std::endl;
                    }

                    

                    
                    // validate message
                    if (message == "NEW_USER")
                    {
                        buffer.clear();
                        boost::beast::ostream(buffer) << "connected";
                        ws.write(buffer.data());
                        
                    }
                    else if (message == "NEW_SESS")
                    {
                        buffer.clear();

                        if (sessManager.isLimitReached())
                        {
                            boost::beast::ostream(buffer)
                                << std::string("{\"message\" : \"SESS_LIMIT\"}").c_str();
                            ws.write(buffer.data());
                            continue;
                        }
                        if (sessManager.existsOwnerIp(user_ip))
                        {
                            boost::beast::ostream(buffer)
                                << std::string("{\"message\" : \"PERSON_LIMIT\"}").c_str();
                            ws.write(buffer.data());
                            continue;
                        }

                        //sessManager
                        
                        boost::beast::ostream(buffer) 
                            << std::string("{\"message\" : \"CREATING_SESSION\", \"content\" : \"true\"}").c_str();
                        ws.write(buffer.data());

                        std::string path = "D:\\Builds\\Fortis_UnStable_57\\FORTIS_Taktika.exe";
                        std::wstring path_ws = std::wstring(path.begin(), path.end());
                        const wchar_t* path_cw = path_ws.c_str();

                        std::string cmd = "-PixelStreamingIP=localhost -PixelStreamingPort=12005 -RenderOffScreen -PixelStreamingEncoderMaxBitrate=15000000 -ResX 1280 -ResY 720 -PixelStreamingEncoderMinQP=25 -PixelStreamingEncoderMultipass=QUARTER -PixelStreamingWebRTCMaxFps=60";
                        std::wstring cmd_ws = std::wstring(cmd.begin(), cmd.end());
                        wchar_t* cmd_w = const_cast<wchar_t*>(cmd_ws.c_str());


                        // creating process
                        STARTUPINFO startupInfo = { sizeof(startupInfo) };
                        PROCESS_INFORMATION processInfo;

                        if (CreateProcess(path_cw, cmd_w, NULL, NULL, TRUE, 0, NULL, NULL, &startupInfo, &processInfo))
                        {
                            // bind process close listen
                            std::thread([processInfo]()
                                {
                                    WaitForSingleObject(processInfo.hProcess, INFINITE);
                                    CloseHandle(processInfo.hProcess);
                                    CloseHandle(processInfo.hThread);
                                }).detach();


                            sessId = hash6(user_id);

                            // create session
                            sessManager.add(
                                session(
                                GetProcessId(processInfo.hProcess),
                                sessId,
                                ip + std::to_string(sess_port),
                                user_ip
                            ));

                            std::cout << "user(" << thisUserNum << ") created session (id: " << sessId << ")" << std::endl;

                            if (sessManager.getById(sessId, &sessCur))
                            {
                                sessCur->addUser(user(user_id));
                            }

                            buffer.clear();
                            boost::beast::ostream(buffer)
                                << (std::string("{\"message\" : \"NEW_SESS\", \"content\" : \"") + std::to_string(sessId) + "\"}");
                            ws.write(buffer.data());
                        }
                        else
                        {
                            std::cout << "CreateProcess failed (" << GetLastError() << ")." << std::endl;
                        }

                    }
                    else if (message == "EXIS_SESS")
                    {
                        // read session id
                        try
                        {
                            jsonData = nlohmann::json::parse(beast::buffers_to_string(buffer.data()));
                            content = jsonData.at("content");
                        }
                        catch (nlohmann::json::parse_error& e)
                        {
                            std::cout << "Parse error:" << e.what() << std::endl;
                        }
                        catch (nlohmann::json::out_of_range& e)
                        {
                            std::cout << "Out of range:" << e.what() << std::endl;
                        }
                        catch (nlohmann::json::exception& e)
                        {
                            std::cout << "JSON exception: " << e.what() << std::endl;
                        }
                        catch (std::exception& e)
                        {
                            std::cout << "Unknown exception" << e.what() << std::endl;
                        }

                        // connect to session
                        if (sessManager.getById(atoi(content.c_str()), &sessCur))
                        {
                            sessCur->addUser(user(user_id));
                            std::cout << "user(" << thisUserNum << ") connected to session (id: " << sessCur->getId()
                                << "), (users: " << sessCur->getUsersCount() << ")" << std::endl;

                            buffer.clear();
                            boost::beast::ostream(buffer)
                                << (std::string("{\"message\" : \"EXIS_SESS\", \"content\" : \"") + std::to_string(sessCur->getId()) + "\"}");
                            ws.write(buffer.data());
                        }
                        else
                        {
                            std::cout << "no session (id: " << content << ")" << std::endl;
                        }
                    }



                    // Echo the message back
                    // ws.text(ws.got_text());
                    // boost::beast::ostream(buffer) << "something";
                    // ws.write(buffer.data());
                    
                }
                catch (beast::system_error const& se)
                {
                    std::cout << "user(" << thisUserNum << ") disconnected" << std::endl;
                    if (sessCur)
                    {
                        sessCur->removeUserById(user_id);

                        if (!sessCur->getUsersCount())
                        {
                            std::cout << "destroy session (id: " << sessCur->getId() << ")" << std::endl;
                            EndProc(sessCur->getProcId());
                            sessManager.remove(sessId);
                        }
                    }
                    break;

                    

                   /* if (se.code() != websocket::error::closed)
                    {
                        std::cerr << "Error: " << se.code().message() << std::endl;
                        break;
                    }*/
                }
            }
        }).detach();
    }
    return 0;
}