#include <SDL2/SDL.h>
#include <stdio.h>
#include <time.h>
#include "util/font.h"
#include "util/audio.h"
#include "tiles/tile.h"
#include "tiles/belt.h"
#include "items/item.h"
#include "stdlib.h"
#include "player/player.h"

//Screen dimension constants
const int SCREEN_WIDTH = DISPLAY_WIDTH;
const int SCREEN_HEIGHT = DISPLAY_HEIGHT;
const int targetFPS = 60;
const int delayNeeded = 1000 / targetFPS;

//The window we'll be rendering to
SDL_Window *window = NULL;
volatile bool running = true;

//The surface contained by the window
SDL_Renderer *renderer = NULL;

#define biggerFont fonts[0]
#define smallFont fonts[1]
#define smallerFont fonts[2]

#define fontCount 3

BitmapFont fonts[fontCount];

unsigned long frames = 0;
bool cursor = true;
void msleep(unsigned int milliseconds) {
    struct timespec ts;
    ts.tv_sec = milliseconds / 1000;
    ts.tv_nsec = (milliseconds % 1000) * 1000000;
    nanosleep(&ts, NULL);
}


int init() {
    //Initialize SDL


    srand(0);

    SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, NULL);
    SDL_SetHint(SDL_HINT_VIDEO_HIGHDPI_DISABLED, "1");
    SDL_SetHint(SDL_HINT_RENDER_DRIVER, "opengl");
    if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) < 0) {
        printf("SDL could not initialize! SDL_Error: %s\n", SDL_GetError());
        return 1;
    }

    //Initialize SDL_ttf
    if (TTF_Init() == -1) {
        printf("SDL_ttf could not initialize! SDL_ttf Error: %s\n", TTF_GetError());
        return 1;
    }

    //Create window
    window = SDL_CreateWindow("Factory game", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, SCREEN_WIDTH,
                              SCREEN_HEIGHT, SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE);
    if (window == NULL) {
        printf("Window could not be created! SDL_Error: %s\n", SDL_GetError());
        return 1;
    }
    //Get window surface
    renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
    if (renderer == NULL) {
        printf("Renderer could not be created SDL_Error: %s\n", SDL_GetError());
        return 1;
    }

    loadItems(renderer);
    loadTiles(renderer);
    // Create OpenGL context
    SDL_GLContext glContext = SDL_GL_CreateContext(window);
    if (!glContext) {
        fprintf(stderr, "SDL_GL_CreateContext failed: %s\n", SDL_GetError());
        exit(1);
    }

// Use OpenGL context
    SDL_GL_MakeCurrent(window, glContext);  // Make sure OpenGL context is current before any OpenGL rendering

    SDL_AudioSpec spec = {0};
    spec.freq = SAMPLE_RATE;
    spec.format = AUDIO_F32SYS;
    spec.channels = 1;
    spec.samples = 4096;
    spec.callback = audio_callback;
    spec.userdata = &audioData;

    SDL_AudioDeviceID dev = SDL_OpenAudioDevice(NULL, 0, &spec, NULL, 0);
    if (dev == 0) {
        printf("Failed to open audio: %s\n", SDL_GetError());
        SDL_Quit();
    }

    SDL_PauseAudioDevice(dev, 0);

    SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
    SDL_RenderClear(renderer);
    SDL_SetRenderTarget(renderer, NULL);

    SDL_Rect viewport = {0, 0, SCREEN_WIDTH, SCREEN_HEIGHT};
    SDL_RenderSetViewport(renderer, &viewport);

    SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
    biggerFont = prepText(renderer, 16, "PublicPixel.ttf", 255, 255, 255, 255);
    smallFont = prepText(renderer, 12, "PublicPixel.ttf", 255, 255, 255, 255);
    smallerFont = prepText(renderer, 8, "PublicPixel.ttf", 255, 255, 255, 255);
    SDL_RenderSetLogicalSize(renderer, SCREEN_WIDTH, SCREEN_HEIGHT);

    generateTestMap();

    return 0;
}


int render() {
    SDL_SetRenderDrawColor(renderer, 32, 32, 32, 255);
    SDL_RenderClear(renderer);

    SDL_Rect rect2;
    rect2.x = 20;
    rect2.y = 20;
    rect2.w = 0;
    rect2.h = 0;

    renderAllBelts(renderer);


    SDL_RenderPresent(renderer);
    frames++;
    if (!(frames % 60)) {
        cursor = !cursor;
    }
    return 0;
}


int processEvent(SDL_Event e) {
    if (e.type == SDL_QUIT) { return 0; }
    else if (e.type == SDL_WINDOWEVENT && e.window.event == SDL_WINDOWEVENT_RESIZED) {
        int newWidth = e.window.data1;
        int newHeight = e.window.data2;

        // Adjust the viewport to match the new window size;
        SDL_Rect viewport = {0, 0, newWidth, newHeight};
        SDL_RenderSetViewport(renderer, &viewport);
    } else if (e.type == SDL_KEYDOWN) {
        int keySym = e.key.keysym.sym;
        int keyMod = e.key.keysym.mod;
        cursor = true;
        switch (keySym) {
            default:
                break;
        }
    } else if (e.type == SDL_MOUSEBUTTONDOWN) {
        SDL_Rect viewport;
        SDL_RenderGetViewport(renderer, &viewport);

        SDL_Rect mouset;
        mouset.w = 1;
        mouset.h = 1;
        SDL_GetMouseState(&mouset.x, &mouset.y);
        // Translate mouse coordinates to viewport space
        SDL_Rect mouse;
        mouse.w = 1;
        mouse.h = 1;
        mouse.x = ((mouset.x - viewport.x) * SCREEN_WIDTH) / viewport.w;
        mouse.y = (mouset.y - viewport.y) * SCREEN_HEIGHT / viewport.h;
    }
    return 1;
}

int main(__attribute__((unused)) int argc, __attribute__((unused)) char *args[]) {
    int status = init();
    if (status) {
        return status;
    }

    uint8_t type = 0;
    for (int x = 142; x < 154; x+=3) {
        for(int y = 80; y < 94; y+=3) {
            putItem(x, y, type++ % ITEMREGISTRY_SIZE, 0, 0);
        }
    }


    //Hack to get window to stay up
    SDL_Event e;
    Uint64 start;
    Uint64 end;
    while (running) {
        start = SDL_GetTicks64();

        while (SDL_PollEvent(&e)) {
            running = processEvent(e);
        }

        updateItems();
        status = render();
        if (status) {
            return status;
        }

        end = SDL_GetTicks64();
        const unsigned long timeNeeded = end - start;
        if (timeNeeded < delayNeeded) {
            SDL_Delay(delayNeeded - timeNeeded);
        }
    }

    for (uint8_t i = 0; i < fontCount; i++) {
        destroyFont(&fonts[i]);
    }
    puts(SDL_GetError());
    if (renderer) SDL_DestroyRenderer(renderer);
    if (window) SDL_DestroyWindow(window);

    SDL_Quit();

    return 0;
}