import derelict.sdl2.sdl;
import std.stdio;
import std.string;
import std.traits;
import std.math;
import std.array;
import std.datetime;
import std.conv;
import std.algorithm;
import std.parallelism;
import std.random;
import std.file;
import core.thread;

auto mag = 1f;
auto camX = 0f;
auto camY = 0f;
const drawWidth = 1000;
const drawHeight = 1000;
const tapeLength = 100000;
Instruction[tapeLength] tape;
uint direction = 0;
auto gridPointer = Pos(0, 0);
uint tapePointer = 0;
Dir[4] dirTable = [ Dir(0, 1), Dir(-1, 0), Dir(0, -1), Dir(1, 0) ];
ulong steps = 0;
auto rng = Random();
bool[int][int] cells;

/*uint[tapeLength * 4] sig = [
13,5,1,3,
4,11,3,0,
1,6,1,2,
13,3,2,1,
11,3,0,0,
10,9,1,0,
13,3,2,3
];*/

struct Dir {
    byte x, y;
}

struct Pos {
    uint x, y;
}

struct Instruction {
    uint[2] tapeAdvance;
    uint[2] leftTurns;
}

void generateProgram() {
    static if(__traits(compiles, sig)) {
        for(int i = 0; i < tapeLength; i++) {
            tape[i] = Instruction([sig[i*4], sig[i*4+1]], [sig[i*4+2], sig[i*4+3]]);
        }
    } else {
        char[] buf;
        for(int i = 0; i < tape.length; i++) {
            tape[i] = Instruction(
                [uniform(0, tapeLength * 2), uniform(0, tapeLength * 2)],
                [uniform(0, 4), uniform(0, 4)]);
            //writefln("%s,%s,%s,%s", tape[i].tapeAdvance[0], tape[i].tapeAdvance[1], tape[i].leftTurns[0], tape[i].leftTurns[1]);
            buf ~= tape[i].tapeAdvance[0].to!string ~ "," ~ tape[i].tapeAdvance[1].to!string ~ "," ~ tape[i].leftTurns[0].to!string ~ "," ~ tape[i].leftTurns[1].to!string ~ "\n";
        }
        std.file.write("sig.txt", buf);
    }
}

int drawX = 0;
int drawY = 0;

void main() {
    DerelictSDL2.load();
    SDL_Init(SDL_INIT_VIDEO);
    SDL_DisplayMode mode;
    SDL_GetDesktopDisplayMode(0, &mode);
    SDL_Window* window = SDL_CreateWindow("Viewer", mode.w/2 - drawWidth/2, mode.h/2 - drawHeight/2, drawWidth, drawHeight, SDL_WINDOW_OPENGL|SDL_WINDOW_RESIZABLE);
    SDL_Surface* surface = SDL_GetWindowSurface(window);
    SDL_PixelFormat* format = surface.format;
    writefln("%s", format.BytesPerPixel);

    generateProgram();

    SDL_Event event;
    bool quit = false;
    bool run = true;

    while (!quit) {
        while(SDL_PollEvent(&event)) {
            if (event.type == SDL_QUIT) {
                quit = true;
            } else if(event.type == SDL_MOUSEWHEEL) {
                if(event.wheel.y > 0) {
                    mag *= 2;
                } else {
                    mag *= 0.5;
                }
            }
        }

        ubyte* state = SDL_GetKeyboardState(null);
        if (state[SDL_SCANCODE_LEFT]) {
            camX -= 10/mag;
        }
        if (state[SDL_SCANCODE_RIGHT]) {
            camX += 10/mag;
        }
        if (state[SDL_SCANCODE_UP]) {
            camY -= 10/mag;
        }
        if (state[SDL_SCANCODE_DOWN]) {
            camY += 10/mag;
        }

        Pos[] updates;
        if (run && runMachine()) {
            run = false;
            continue;
        }

        auto start = Clock.currTime;
        float time = 0;
        for(; time < 1f/60; drawY++, drawY%=drawHeight) {
            for(drawX = 0; drawX < drawWidth; drawX++) {
                auto dx = cast(int)((drawX - drawWidth/2)/mag + camX);
                auto dy = cast(int)((drawY - drawHeight/2)/mag + camY);
                auto idx = drawY * drawWidth + drawX;
                auto data = cast(ubyte*)surface.pixels;
                if(dx in cells && dy in cells[dx]) {
                    data[idx * 4 + 0] = 230;
                    data[idx * 4 + 1] = 20;
                    data[idx * 4 + 2] = 0;
                    data[idx * 4 + 3] = 255;
                } else {
                    data[idx * 4 + 0] = 0;
                    data[idx * 4 + 1] = 0;
                    data[idx * 4 + 2] = 0;
                    data[idx * 4 + 3] = 255;
                }
            }
            time = (cast(float)(Clock.currTime - start).total!"nsecs")/1e9;
        }
        SDL_UpdateWindowSurface(window);
    }
}

bool runMachine() {
    auto start = Clock.currTime;
    float time = 0;
    while(time < 1f/60) {
        //Thread.sleep(dur!("msecs")(250));
        steps++;
        bool state;
        if(gridPointer.x !in cells) {
            bool[int] map;
            cells[gridPointer.x] = map.dup;
        }
        if(gridPointer.y in cells[gridPointer.x]) {
            cells[gridPointer.x].remove(gridPointer.y);
            state = false;
        } else {
            cells[gridPointer.x][gridPointer.y] = true;
            state = true;
        }
        auto inst = tape[tapePointer++];
        auto tapeAdvance = inst.tapeAdvance[state];
        auto leftTurns = inst.leftTurns[state];
        tapePointer += tapeAdvance;
        tapePointer %= tapeLength;
        direction += leftTurns;
        direction %= 4;
        gridPointer.x += dirTable[direction].x;
        gridPointer.y += dirTable[direction].y;
        auto gpx = gridPointer.x;
        auto gpy = gridPointer.y;
        time = (cast(float)(Clock.currTime - start).total!"nsecs")/1e9;
    }
    return false;
}