#include <string></string>

#include <iostream></iostream>

#include <gl gl.h=""></gl>

#include <sdl2 sdl.h=""></sdl2>

#include "geometry.h"

#include "scene.h"

#include "simulator.h"

#include "tool.h"

#include "loader.h"

#include "collider.h"

#include "generator.h"

#include "generatorradial.h"

class Main {

public:

    bool sdl_initialized;

    SDL_Window *mainWindow;

    SDL_GLContext mainContext;

    Scene *scene;

    Main():

        sdl_initialized(),

        mainWindow(),

        mainContext(),

        scene()

    { }

    ~Main() { deinit(); }

    bool init() {

        if (SDL_Init(SDL_INIT_VIDEO) < 0) {

            std::cerr << "SDL_Init failed" << std::endl;

            deinit();

            return false;

        }

        sdl_initialized = true;

        mainWindow = SDL_CreateWindow(

            "simu",

            SDL_WINDOWPOS_CENTERED,

            SDL_WINDOWPOS_CENTERED,

            512,

            512,

            SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE );

        if (!mainWindow)

        {

            std::cerr << "cannot create window" << std::endl;

            std::cerr << SDL_GetError() << std::endl;

            SDL_ClearError();

            deinit();

            return false;

        }

        mainContext = SDL_GL_CreateContext(mainWindow);

        SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);

        SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);

        SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);

        SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);

        // vsync

        SDL_GL_SetSwapInterval(1);

        scene = new Scene();

        glClearColor(0.0, 0.0, 0.0, 0.0);

        glEnable(GL_LINE_SMOOTH);

        glEnable(GL_POINT_SMOOTH);

        glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);

        glHint(GL_POINT_SMOOTH_HINT, GL_NICEST);

        glEnable(GL_NORMALIZE);

        glDisable(GL_DEPTH_TEST);

        glEnable(GL_LIGHT0);

        float light0[] = {1, 1, 1, 0};

        glLightfv(GL_LIGHT0, GL_POSITION, light0);

        glEnable(GL_LIGHT1);

        float light1[] = {-1, -1, -1, 0};

        float color[] = {1, 1, 1, 1};

        glLightfv(GL_LIGHT1, GL_POSITION, light1);

        glLightfv(GL_LIGHT1, GL_DIFFUSE, color);

        glLightfv(GL_LIGHT1, GL_SPECULAR, color);

        glEnable(GL_COLOR_MATERIAL);

        resize(512, 512);

        return true;

    }

    void deinit() {

        if (scene) { delete scene; scene = 0; }

        if (mainContext) { SDL_GL_DeleteContext(mainContext); mainContext = 0; }

        if (mainWindow) { SDL_DestroyWindow(mainWindow); mainWindow = 0; }

        if (sdl_initialized) { SDL_Quit(); sdl_initialized = false; }

    }

    void resize(int width, int height) {

        glViewport(0, 0, width, height);

        glMatrixMode(GL_PROJECTION);

        glLoadMatrixd( Matrix4::perspective(90.0, (Real)width/height, 1, 1000).a );

        glMatrixMode(GL_MODELVIEW);

    }

    void update_collider() {

        if (scene->collider) {

            Real l = scene->collider->distance_to_model(scene->tool_pos, scene->tool_dir);

            if (!isinf(l))

                scene->tool_pos = scene->tool_pos + scene->tool_dir*l;

        }

    }

    void loop() {

        update_collider();

        bool quit = false;

        Uint32 prev_time = SDL_GetTicks();

        while(!quit) {

            SDL_Event event;

            while (SDL_PollEvent(&event)) {

                if (event.type == SDL_QUIT)

                    quit = true;

                if (event.type == SDL_WINDOWEVENT) {

                    if (event.window.event == SDL_WINDOWEVENT_RESIZED) {

                        resize(event.window.data1, event.window.data2);

                    }

                }

                if (event.type == SDL_KEYDOWN) {

                    switch (event.key.keysym.sym) {

                    case SDLK_ESCAPE:

                        quit = true;

                        break;

                    case SDLK_w:

                        scene->tool_pos.y += 0.5;

                        update_collider();

                        break;

                    case SDLK_s:

                        scene->tool_pos.y -= 0.5;

                        update_collider();

                        break;

                    case SDLK_a:

                        scene->tool_pos.x -= 0.5;

                        update_collider();

                        break;

                    case SDLK_d:

                        scene->tool_pos.x += 0.5;

                        update_collider();

                        break;

                    default:

                        break;

                    }

                }

                if (event.type == SDL_MOUSEMOTION) {

                    if (event.motion.state & SDL_BUTTON_LMASK) {

                        scene->angles.z += event.motion.xrel;

                        scene->angles.x += event.motion.yrel;

                    }

                    if (event.motion.state & SDL_BUTTON_RMASK) {

                        scene->offset.z *= pow(2, event.motion.yrel/100.0);

                    }

                    if (event.motion.state & SDL_BUTTON_MMASK) {

                        scene->offset.x += 0.1*event.motion.xrel;

                        scene->offset.y -= 0.1*event.motion.yrel;

                    }

                }

            }

            Uint32 curr_time = SDL_GetTicks();

            double dt = (curr_time - prev_time)/1000.0;

            prev_time = curr_time;

            scene->update(dt);

            glClear(GL_COLOR_BUFFER_BIT);

            scene->draw();

            SDL_GL_SwapWindow(mainWindow);

        }

    }

};

int main(int argc, char **argv)

{

    Main app;

    if (!app.init()) return -1;

    bool load_track = false;

    bool load_model = false;

    Model model;

    SimulatorXYZA simulator_xyza(400, 360);

    SimulatorXYZ simulator_xyz(400, 400);

    FlatTool tool(1.5);// + 0.5);

    //ConeTool tool(1.25, 10, 0.75);

    Collider collider(model, tool);

    Vector3 dir(1, 3, -3);

    dir = dir*(1/dir.len());

    if (argc > 1 && std::string(argv[1]) != ".") {

        Loader::load(app.scene->track, argv[1]);

        //app.scene->simulator = &simulator_xyza;

        app.scene->simulator = &simulator_xyz;

        app.scene->simulator->simulate(app.scene->track, tool);

        load_track = true;

    }

    if (argc > 2 && std::string(argv[2]) != ".") {

        Loader::load(model, argv[2]);

        //Loader::save(app.scene->track, "output/tmp.tap");

        app.scene->model = &model;

        load_model = true;

    }

    if (argc > 3 && std::string(argv[3]) != ".") {

        if (!load_track && load_model) {

            if (0) {

                GeneratorRowsZAX generator;

                generator.max_z = 26;

                generator.min_z = -10;

                //generator.step_z = 2.0;

                generator.step_z = 5.0;

                //generator.step_z = 0;

                //generator.step_a = 2*(tool.radius - 0.6);

                generator.step_a = 0.75;

                generator.step_x = 0.5;

                generator.skip_middle_layers = true;

                generator.feed_speed = 150;

                generator.generate(collider, app.scene->track);

                app.scene->simulator = &simulator_xyza;

            } else {

                GeneratorRadialXYZ generator;

                generator.max_z = 26;

                generator.min_z = 0;

                //generator.min_r = 6.5 - tool.radius - 0.1;

                generator.max_r = 17.45 + tool.radius - 0.1;

                //generator.full_radius = true;

                generator.step_z = 2.0;

                generator.step_a = 2*tool.radius - 0.5;

                generator.step_r = 0.1;

                //generator.skip_middle_layers = true;

                generator.feed_speed = 150;

                generator.generate(collider, app.scene->track);

                app.scene->simulator = &simulator_xyz;

            }

            app.scene->simulator->simulate(app.scene->track, tool);

            Loader::save(app.scene->track, argv[3]);

        }

    }

    app.scene->tool = &tool;

    app.scene->tool_dir = dir;

    app.scene->collider = &collider;

    app.loop();

    return 0;

}