#include <iostream>
#include <fstream>
#include <string>
#include <chrono>
#include <thread>
#include <vector>
#include <map>

using namespace std;

#ifdef __APPLE__
#include <Carbon/Carbon.h>
#include <ncurses.h>
#include <streambuf>

class ncursesbuf: public std::streambuf {
public:
    ncursesbuf() {}
    virtual int overflow(int c) {
        printw("%c", c);
        return 0;
    }
};

class ncurses_stream : public std::ostream {
public:
    ncursesbuf tbuf_;
    std::ostream &src_;
    std::streambuf * const srcbuf_;

    ncurses_stream(std::ostream &o) : src_(o), srcbuf_(o.rdbuf()), std::ostream(&tbuf_) {
        o.rdbuf(rdbuf());
    }

    ~ncurses_stream() {
        src_.rdbuf(srcbuf_);
    }
};

bool isPressedKeyCode(uint16_t vKey) {
    uint8_t index = (vKey) / 32;
    uint8_t shift = ((vKey) % 32);
    KeyMap keyStates;
    GetKeys(keyStates);
    return (keyStates[index].bigEndianValue & (1 << shift));
}

bool isTabPressed() {
    return isPressedKeyCode(kVK_Tab);
}

bool isEnterPressed() {
    return isPressedKeyCode(kVK_Return);
}

bool isSpacePressed() {
    return isPressedKeyCode(kVK_Space);
}

bool isEscapePressed() {
    return isPressedKeyCode(kVK_Escape);
}
#else
#include <Windows.h>

bool isPressed(char key) {
    return GetAsyncKeyState(key) < 0;
}

bool isTabPressed() {
    return isPressed(VK_TAB);
}

bool isEnterPressed() {
    return isPressed(VK_RETURN);
}

bool isSpacePressed() {
    return isPressed(VK_SPACE);
}

bool isSpacePressed() {
    return isPressed(VK_ESCAPE);
}
#endif

struct SequenceInfo {
    std::string scene;
    int seconds;
};

int main() {
#ifdef __APPLE__
    initscr();
    scrollok(stdscr,TRUE);
    ncurses_stream foo(std::cout);
    noecho();
#endif
    std::cout << "Initializing!" << std::endl;
    std::ifstream config("sceneconfig.txt");
    std::vector<SequenceInfo> scenes;
    if (config) {
        while (!config.eof()) {
            SequenceInfo sequence;
            config >> sequence.scene >> sequence.seconds;
            scenes.push_back(sequence);
        }
    } else {
        scenes.push_back({ "DervView", 30 });
        scenes.push_back({ "JaiView", 30 });
    }
    bool keyPressed = false;
    int currentIndex = 0;
    int previousSeconds = -1;
    while (true) {
        {
            std::ofstream outfile("sceneswapin.txt");
            std::cout << "Swapping to: " << scenes[currentIndex].scene << " Next Up: " << scenes[currentIndex].seconds << "s\n";
#ifdef __APPLE__
            refresh();
#endif
            outfile << scenes[currentIndex].scene;
        }

        // (1 / tickDivider) where 1 is a second. Or sleepTicks * tickDivider to get seconds.
        int tickDivider = 8;
        int pausedAt = 0;
        for (int sleepTicks = scenes[currentIndex].seconds * tickDivider; sleepTicks != 0; --sleepTicks) {
            std::this_thread::sleep_for(std::chrono::milliseconds(static_cast<int>((1.0 / static_cast<double>(tickDivider)) * 1000.0)));

            if(isEscapePressed()){
                std::cout << "\nGoodbye!\n";
#ifdef __APPLE__
                std::cout << std::flush;
                refresh();
                endwin();
#endif
                return 0;
            }
            bool tabPressed = isTabPressed();
            bool enterPressed = isEnterPressed();
            bool spacePressed = isSpacePressed();

            bool wasKeyPressed = keyPressed;
            keyPressed = tabPressed || enterPressed || spacePressed;

            if (!wasKeyPressed && tabPressed){
                std::cout << "\nSkipping to next scene!";
                break;
            } else if (!wasKeyPressed && enterPressed) {
                if(sleepTicks >= 0){
                    sleepTicks += scenes[currentIndex].seconds * tickDivider;
                    std::cout << "[" << (sleepTicks / tickDivider) << "]";
                }else{
                    pausedAt += scenes[currentIndex].seconds * tickDivider;
                    std::cout << "[" << (pausedAt / tickDivider) << "]";
                }
            } else if (!wasKeyPressed && spacePressed) {
                if (sleepTicks < 0) {
                    std::cout << "~";
                    sleepTicks = pausedAt;
                } else {
                    std::cout << "!";
                    pausedAt = sleepTicks;
                    sleepTicks = -1;
                }
            } else {
                int seconds = (sleepTicks / tickDivider);
                if (seconds != previousSeconds) {
                    previousSeconds = seconds;
                    if (sleepTicks > 0 && (seconds % 5 == 0)) {
                        std::cout << "." << (sleepTicks / tickDivider);
                    } else if (sleepTicks > 0) {
                        std::cout << ".";
                    }
                }
            }
#ifdef __APPLE__
            std::cout << std::flush;
            refresh();
#endif
        }
        std::cout << "\n";
#ifdef __APPLE__
        std::cout << std::flush;
        refresh();
#endif
        currentIndex++;
        if (currentIndex >= scenes.size()) {
            currentIndex = 0;
        }
    }
}