#include <iostream>
#include <thread>
#include <SDL2/SDL.h>
#include <SDL2/SDL_image.h>
#include <filesystem>

#include "util.h"
#include "decoder.h"
#include "shaderService.h"
#include "shader.h"
using std::cout, std::endl;

struct OpenglVideoParam
{
    SDL_GLContext glContext;
    unsigned int VAO, VBO, EBO;
    unsigned int texs[3];
};

int InitVideo(SDL_Window *&window, const char *targetFilepath, DecoderParam &decoderParam, OpenglVideoParam &openglVideoParam, ShaderService *&shaderService)
{
    InitDecoder(targetFilepath, decoderParam);
    int client_width = decoderParam.width / 2;
    int client_height = decoderParam.height / 2;
    window = SDL_CreateWindow(
        "MP",
        SDL_WINDOWPOS_UNDEFINED,
        SDL_WINDOWPOS_UNDEFINED,
        client_width,
        client_height,
        SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL);
    if (!window)
    {
        cout << SDL_GetError() << "\n";
        return -1;
    }
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);

    openglVideoParam.glContext = SDL_GL_CreateContext(window);
    if (!openglVideoParam.glContext)
    {
        cout << SDL_GetError() << "\n";
        return -1;
    }

    if (!gladLoadGLLoader((GLADloadproc)SDL_GL_GetProcAddress))
    {
        auto error = glad_glGetError();
        return static_cast<int>(error);
    }

    float vertices[] = {
        1.f, 1.f, 0.0, 1.0, 0.0,
        1.f, -1.f, 0.0, 1.0, 1.0,
        -1.f, -1.f, 0.0, 0.0, 1.0,
        -1.f, 1.f, 0.0, 0.0, 0.0};
    unsigned int indices[]{
        0,
        1,
        3,
        1,
        2,
        3,
    };

    glGenVertexArrays(1, &openglVideoParam.VAO);
    glGenBuffers(1, &openglVideoParam.VBO);
    glGenBuffers(1, &openglVideoParam.EBO);
    glBindVertexArray(openglVideoParam.VAO);
    glBindBuffer(GL_ARRAY_BUFFER, openglVideoParam.VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, openglVideoParam.EBO);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), 0);
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void *)(3 * sizeof(float)));
    glEnableVertexAttribArray(1);
    glGenTextures(3, openglVideoParam.texs);
    for (int i = 0; i < 3; i++)
    {
        glBindTexture(GL_TEXTURE_2D, openglVideoParam.texs[i]);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    }

    shaderService = new ShaderService{vSource.data(), fSource.data()};
    shaderService->Use();
    shaderService->SetUniform<int>("textureY", 0);
    shaderService->SetUniform<int>("textureU", 1);
    shaderService->SetUniform<int>("textureV", 2);
    return 0;
}
void OpenglRender(DecoderParam &decoderParam, OpenglVideoParam &openglVideoParam, ShaderService *shaderService)
{
    auto frame = RequestFrame(decoderParam);
    if(frame == nullptr)
        return;
    int64_t pts = frame->pts;
    static bool first_frame = true;
    // TODO: TIMER
    glBindTexture(GL_TEXTURE_2D, openglVideoParam.texs[0]);
    glPixelStoref(GL_UNPACK_ROW_LENGTH, frame->linesize[0]);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, frame->width, frame->height, 0, GL_RED, GL_UNSIGNED_BYTE, frame->data[0]);

    glActiveTexture(GL_TEXTURE1);
    glBindTexture(GL_TEXTURE_2D, openglVideoParam.texs[1]);
    glPixelStoref(GL_UNPACK_ROW_LENGTH, frame->linesize[1]);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, frame->width / 2, frame->height / 2, 0, GL_RED, GL_UNSIGNED_BYTE, frame->data[1]);

    glActiveTexture(GL_TEXTURE2);
    glBindTexture(GL_TEXTURE_2D, openglVideoParam.texs[2]);
    glPixelStoref(GL_UNPACK_ROW_LENGTH, frame->linesize[2]);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, frame->width / 2, frame->height / 2, 0, GL_RED, GL_UNSIGNED_BYTE, frame->data[2]);

    glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);

    shaderService->Use();
    glBindVertexArray(openglVideoParam.VAO);
    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
    av_frame_free(&frame);
}

int main(int argc, char **const argv)
{
    // Check File
    const char *targetFilepath = argv[1];
    if (targetFilepath == nullptr || !std::filesystem::exists(targetFilepath))
    {
        cout << "File Not Exist\n";
        return 0;
    }
    const FileType fileType = Util::GetFileType(targetFilepath);
    if (fileType == FileType::ERRORTYPE)
    {
        cout << "unsupport file type\n";
        return 0;
    }

    // INIT

    int client_width, client_height;
    SDL_Window *window = nullptr;
    DecoderParam decoderParam{};
    OpenglVideoParam openglVideoParam{};
    ShaderService *shaderService = nullptr;
    double framerate = .0f;
    if (SDL_Init(SDL_INIT_EVERYTHING) < 0)
    {
        cout << SDL_GetError() << "\n";
        return -1;
    }
    switch (fileType)
    {
    case FileType::VIDEO:
    {
        InitVideo(window, targetFilepath, decoderParam, openglVideoParam, shaderService);
        auto& time_base = decoderParam.fmtCtx->streams[decoderParam.videoStreamIndex]->time_base;
        framerate = (double)time_base.num / time_base.den;
        break;
    }
    case FileType::IMG:
    {
        break;
    }
    case FileType::MUSIC:
    {
        break;
    }
    default:
        return -1;
    }

    bool quit = false;
    auto current_time = std::chrono::system_clock::now();
    SDL_Event event;
    while (!quit)
    {
        while (SDL_PollEvent(&event))
        {
            switch (event.type)
            {
            case SDL_KEYDOWN:
                switch (event.key.keysym.scancode)
                {
                case SDL_SCANCODE_ESCAPE:
                    return -1;
                default:
                    break;
                }
                break;
            case SDL_QUIT:
                return -1;
            default:
                break;
            }
        }

        // Render
        switch (fileType)
        {
        case FileType::VIDEO:
            OpenglRender(decoderParam, openglVideoParam, shaderService);
            SDL_GL_SwapWindow(window);
            std::this_thread::sleep_until(current_time + std::chrono::milliseconds((int)(framerate * 1000)));
            current_time = std::chrono::system_clock::now();
            break;

        default:
            break;
        }
    }

    avcodec_close(decoderParam.codecCtx);
    avformat_close_input(&(decoderParam.fmtCtx));
    SDL_GL_DeleteContext(openglVideoParam.glContext);
    SDL_DestroyWindow(window);
    SDL_Quit();
    return 0;
}