#define _USE_MATH_DEFINES
#define NOMINMAX 
#include <windows.h>

// Решение проблемы с конфликтом min/max в GDI+
#include <algorithm>
using std::min;
using std::max;

#include <gdiplus.h> 
#include <cmath>
#include <vector>
#include <map>
#include <random>
#include <chrono>

// Линковка библиотеки GDI+
#pragma comment (lib, "Gdiplus.lib")

// Константы
const int WIDTH = 800;
const int HEIGHT = 600;
const int HALF_HEIGHT = HEIGHT / 2;
const int TILE_SIZE = 64;
const float fov = static_cast<float>(M_PI) / 3.0f;
const int NUM_RAYS = 160;
const int SCALE = WIDTH / NUM_RAYS;
const int MAP_SIZE = 32;

struct Color {
    unsigned char b, g, r, a;
    Color() : r(0), g(0), b(0), a(255) {}
    Color(unsigned char r, unsigned char g, unsigned char b) : r(r), g(g), b(b), a(255) {}
};

std::vector<Color> frame_buffer(WIDTH* HEIGHT);

float player_x = 2.0f * TILE_SIZE + 32.0f;
float player_y = 2.0f * TILE_SIZE + 32.0f;
int cell_x = 2;
int cell_y = 2;
float player_angle = 0.0f;
const float player_speed = 100.0f;
const float rotation_speed = 2.0f;

bool demo_mode = true;
bool day_mode = false;
int current_dir_index = 0;
const std::vector<float> DIRECTIONS = { 0.0f, static_cast<float>(M_PI) / 2.0f, static_cast<float>(M_PI), -static_cast<float>(M_PI) / 2.0f };

enum class AIState { MOVE, TURN };
AIState ai_state = AIState::MOVE;
float target_angle = 0.0f;

std::map<std::pair<int, int>, int> world_map;

std::mt19937 rng(std::random_device{}());
float random_float() {
    std::uniform_real_distribution<float> dist(0.0f, 1.0f);
    return dist(rng);
}

void generate_maze(int size) {
    for (int row = 0; row < size; ++row) {
        for (int col = 0; col < size; ++col) {
            if (col == 0 || col == size - 1 || row == 0 || row == size - 1) {
                world_map[{col, row}] = 1;
            }
            else if (col >= 1 && col <= 3 && row >= 1 && row <= 3) {
                world_map[{col, row}] = 0;
            }
            else {
                world_map[{col, row}] = (random_float() < 0.30f) ? 1 : 0;
            }
        }
    }
}

int get_wall_type(int col, int row) {
    auto it = world_map.find({ col, row });
    if (it != world_map.end()) return it->second;
    return 1;
}

std::vector<Color> tex_wall(TILE_SIZE* TILE_SIZE);
std::vector<Color> tex_ceil(TILE_SIZE* TILE_SIZE);
std::vector<Color> tex_floor(TILE_SIZE* TILE_SIZE);

bool load_png_texture(const wchar_t* filename, std::vector<Color>& buffer) {
    Gdiplus::Bitmap bitmap(filename);
    if (bitmap.GetLastStatus() != Gdiplus::Ok) {
        return false;
    }

    Gdiplus::BitmapData bitmapData;
    Gdiplus::Rect rect(0, 0, bitmap.GetWidth(), bitmap.GetHeight());

    if (bitmap.LockBits(&rect, Gdiplus::ImageLockModeRead, PixelFormat32bppARGB, &bitmapData) == Gdiplus::Ok) {
        UINT* pixels = (UINT*)bitmapData.Scan0;
        int stride = bitmapData.Stride / 4;

        for (int y = 0; y < TILE_SIZE; ++y) {
            for (int x = 0; x < TILE_SIZE; ++x) {
                int src_x = (x * bitmap.GetWidth()) / TILE_SIZE;
                int src_y = (y * bitmap.GetHeight()) / TILE_SIZE;
                UINT p = pixels[src_y * stride + src_x];

                Color c;
                c.a = (p >> 24) & 0xFF;
                c.r = (p >> 16) & 0xFF;
                c.g = (p >> 8) & 0xFF;
                c.b = p & 0xFF;
                buffer[y * TILE_SIZE + x] = c;
            }
        }
        bitmap.UnlockBits(&bitmapData);
        return true;
    }
    return false;
}

void create_textures() {
    if (!load_png_texture(L"wall.png", tex_wall)) {
        std::fill(tex_wall.begin(), tex_wall.end(), Color(125, 45, 30));
        for (int y : {0, 16, 32, 48, 63})
            for (int x = 0; x < 64; ++x) tex_wall[y * TILE_SIZE + x] = Color(110, 105, 100);
        for (int x : {0, 32, 64}) {
            if (x < 64) {
                for (int y = 0; y < 16; ++y) tex_wall[y * TILE_SIZE + x] = Color(110, 105, 100);
                for (int y = 32; y < 48; ++y) tex_wall[y * TILE_SIZE + x] = Color(110, 105, 100);
            }
        }
        for (int x : {16, 48}) {
            for (int y = 16; y < 32; ++y) tex_wall[y * TILE_SIZE + x] = Color(110, 105, 100);
            for (int y = 48; y < 64; ++y) tex_wall[y * TILE_SIZE + x] = Color(110, 105, 100);
        }
    }

    if (!load_png_texture(L"top.png", tex_ceil)) {
        std::fill(tex_ceil.begin(), tex_ceil.end(), Color(75, 75, 75));
    }

    if (!load_png_texture(L"floor.png", tex_floor)) {
        std::fill(tex_floor.begin(), tex_floor.end(), Color(45, 45, 50));
        for (int i = 0; i < TILE_SIZE; i += 16) {
            for (int y = 0; y < TILE_SIZE; ++y) tex_floor[y * TILE_SIZE + i] = Color(25, 25, 28);
            for (int x = 0; x < TILE_SIZE; ++x) tex_floor[i * TILE_SIZE + x] = Color(25, 25, 28);
        }
    }
}

LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
    switch (uMsg) {
    case WM_DESTROY: PostQuitMessage(0); return 0;
    case WM_KEYDOWN:
        if (wParam == 'Y') { demo_mode = !demo_mode; ai_state = AIState::MOVE; }
        if (wParam == 'L') { day_mode = !day_mode; }
        if (wParam == VK_ESCAPE) PostQuitMessage(0);
        return 0;
    }
    return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
    Gdiplus::GdiplusStartupInput gdiplusStartupInput;
    ULONG_PTR gdiplusToken;
    Gdiplus::GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);

    const wchar_t CLASS_NAME[] = L"MazeWindowClass";
    WNDCLASS wc = {};
    wc.lpfnWndProc = WindowProc;
    wc.hInstance = hInstance;
    wc.lpszClassName = CLASS_NAME;
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    RegisterClass(&wc);

    RECT rect = { 0, 0, WIDTH, HEIGHT };
    AdjustWindowRect(&rect, WS_OVERLAPPEDWINDOW & ~WS_THICKFRAME & ~WS_MAXIMIZEBOX, FALSE);

    HWND hwnd = CreateWindowEx(0, CLASS_NAME, L"3DMAZE",
        WS_OVERLAPPEDWINDOW & ~WS_THICKFRAME & ~WS_MAXIMIZEBOX,
        CW_USEDEFAULT, CW_USEDEFAULT, rect.right - rect.left, rect.bottom - rect.top,
        NULL, NULL, hInstance, NULL);

    if (hwnd == NULL) {
        Gdiplus::GdiplusShutdown(gdiplusToken);
        return 0;
    }
    ShowWindow(hwnd, nCmdShow);

    generate_maze(MAP_SIZE);
    create_textures();

    BITMAPINFO bmi = {};
    bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    bmi.bmiHeader.biWidth = WIDTH;
    bmi.bmiHeader.biHeight = -HEIGHT;
    bmi.bmiHeader.biPlanes = 1;
    bmi.bmiHeader.biBitCount = 32;
    bmi.bmiHeader.biCompression = BI_RGB;

    auto last_time = std::chrono::high_resolution_clock::now();
    bool running = true;

    while (running) {
        MSG msg;
        while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
            if (msg.message == WM_QUIT) running = false;
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }

        auto current_time = std::chrono::high_resolution_clock::now();
        float dt = std::chrono::duration<float>(current_time - last_time).count();
        last_time = current_time;

        if (demo_mode) {
            if (ai_state == AIState::MOVE) {
                float target_x = static_cast<float>(cell_x * TILE_SIZE + 32);
                float target_y = static_cast<float>(cell_y * TILE_SIZE + 32);
                float move_cos = std::round(std::cos(DIRECTIONS[current_dir_index]));
                float move_sin = std::round(std::sin(DIRECTIONS[current_dir_index]));
                float dist = std::hypot(target_x - player_x, target_y - player_y);

                if (dist > 1.0f) {
                    float step = player_speed * dt;
                    if (step > dist) step = dist;
                    player_x += move_cos * step;
                    player_y += move_sin * step;
                }
                else {
                    player_x = target_x; player_y = target_y;
                    std::vector<int> available_dirs;
                    for (size_t i = 0; i < DIRECTIONS.size(); ++i) {
                        int t_cos = static_cast<int>(std::round(std::cos(DIRECTIONS[i])));
                        int t_sin = static_cast<int>(std::round(std::sin(DIRECTIONS[i])));
                        if (get_wall_type(cell_x + t_cos, cell_y + t_sin) == 0) available_dirs.push_back(static_cast<int>(i));
                    }

                    int backward_dir_index = (current_dir_index + 2) % 4;
                    std::vector<int> forward_and_sides;
                    for (int d : available_dirs) if (d != backward_dir_index) forward_and_sides.push_back(d);

                    int next_dir = current_dir_index;
                    if (!forward_and_sides.empty()) {
                        if (std::find(forward_and_sides.begin(), forward_and_sides.end(), current_dir_index) != forward_and_sides.end() && random_float() < 0.75f) {
                            next_dir = current_dir_index;
                        }
                        else {
                            std::uniform_int_distribution<int> dist_dir(0, static_cast<int>(forward_and_sides.size() - 1));
                            next_dir = forward_and_sides[dist_dir(rng)];
                        }
                    }
                    else if (std::find(available_dirs.begin(), available_dirs.end(), backward_dir_index) != available_dirs.end()) {
                        next_dir = backward_dir_index;
                    }

                    if (next_dir != current_dir_index) {
                        current_dir_index = next_dir; target_angle = DIRECTIONS[current_dir_index]; ai_state = AIState::TURN;
                    }
                    else {
                        cell_x += static_cast<int>(move_cos); cell_y += static_cast<int>(move_sin);
                    }
                }
            }
            else if (ai_state == AIState::TURN) {
                float angle_diff = std::fmod(target_angle - player_angle + static_cast<float>(M_PI), 2.0f * static_cast<float>(M_PI));
                if (angle_diff < 0) angle_diff += 2.0f * static_cast<float>(M_PI);
                angle_diff -= static_cast<float>(M_PI);

                if (std::abs(angle_diff) > 0.01f) {
                    float step = rotation_speed * dt;
                    if (step > std::abs(angle_diff)) step = std::abs(angle_diff);
                    player_angle += (angle_diff > 0 ? 1.0f : -1.0f) * step;
                }
                else {
                    player_angle = target_angle;
                    float move_cos = std::round(std::cos(DIRECTIONS[current_dir_index]));
                    float move_sin = std::round(std::sin(DIRECTIONS[current_dir_index]));
                    cell_x += static_cast<int>(move_cos); cell_y += static_cast<int>(move_sin); ai_state = AIState::MOVE;
                }
            }
        }
        else {
            if (GetAsyncKeyState('A') || GetAsyncKeyState(VK_LEFT)) player_angle -= 3.0f * dt;
            if (GetAsyncKeyState('D') || GetAsyncKeyState(VK_RIGHT)) player_angle += 3.0f * dt;

            float cos_a = std::cos(player_angle), sin_a = std::sin(player_angle);
            float mx = 0, my = 0;
            if (GetAsyncKeyState('W') || GetAsyncKeyState(VK_UP)) { mx = player_speed * cos_a * dt; my = player_speed * sin_a * dt; }
            else if (GetAsyncKeyState('S') || GetAsyncKeyState(VK_DOWN)) { mx = -player_speed * cos_a * dt; my = -player_speed * sin_a * dt; }

            float r = 12.0f;
            float sign_x = (mx > 0) ? r : (mx < 0 ? -r : 0);
            float sign_y = (my > 0) ? r : (my < 0 ? -r : 0);

            if (get_wall_type(static_cast<int>((player_x + mx + sign_x) / TILE_SIZE), static_cast<int>(player_y / TILE_SIZE)) == 0) player_x += mx;
            if (get_wall_type(static_cast<int>(player_x / TILE_SIZE), static_cast<int>((player_y + my + sign_y) / TILE_SIZE)) == 0) player_y += my;

            cell_x = static_cast<int>(player_x / TILE_SIZE); cell_y = static_cast<int>(player_y / TILE_SIZE);
        }

        Color bg_color = day_mode ? Color(140, 140, 145) : Color(15, 15, 15);
        std::fill(frame_buffer.begin(), frame_buffer.end(), bg_color);

        float start_angle = player_angle - fov / 2.0f;

        for (int ray = 0; ray < NUM_RAYS; ++ray) {
            float angle = start_angle + ray * (fov / NUM_RAYS);
            float r_cos = (std::cos(angle) != 0) ? std::cos(angle) : 0.00001f;
            float r_sin = (std::sin(angle) != 0) ? std::sin(angle) : 0.00001f;

            float x_depth = 9999.0f; int x_texture = 0;
            float x_step = TILE_SIZE / r_cos;
            float first_x = (r_cos > 0) ? static_cast<float>((static_cast<int>(player_x / TILE_SIZE) + 1) * TILE_SIZE) : static_cast<float>(static_cast<int>(player_x / TILE_SIZE) * TILE_SIZE);
            float current_depth_x = (first_x - player_x) / r_cos;

            for (int i = 0; i < 30; ++i) {
                float tx = player_x + current_depth_x * r_cos;
                float ty = player_y + current_depth_x * r_sin;
                int col = static_cast<int>((tx + (r_cos > 0 ? 1.0f : -1.0f)) / TILE_SIZE);
                int row = static_cast<int>(ty / TILE_SIZE);
                if (get_wall_type(col, row) > 0) {
                    x_depth = current_depth_x;
                    x_texture = static_cast<int>(std::fmod(ty, static_cast<float>(TILE_SIZE)));
                    if (x_texture < 0) x_texture += TILE_SIZE;
                    break;
                }
                current_depth_x += std::abs(x_step);
            }

            float y_depth = 9999.0f; int y_texture = 0;
            float y_step = TILE_SIZE / r_sin;
            float first_y = (r_sin > 0) ? static_cast<float>((static_cast<int>(player_y / TILE_SIZE) + 1) * TILE_SIZE) : static_cast<float>(static_cast<int>(player_y / TILE_SIZE) * TILE_SIZE);
            float current_depth_y = (first_y - player_y) / r_sin;

            for (int i = 0; i < 30; ++i) {
                float tx = player_x + current_depth_y * r_cos;
                float ty = player_y + current_depth_y * r_sin;
                int col = static_cast<int>(tx / TILE_SIZE);
                int row = static_cast<int>((ty + (r_sin > 0 ? 1.0f : -1.0f)) / TILE_SIZE);
                if (get_wall_type(col, row) > 0) {
                    y_depth = current_depth_y;
                    y_texture = static_cast<int>(std::fmod(tx, static_cast<float>(TILE_SIZE)));
                    if (y_texture < 0) y_texture += TILE_SIZE;
                    break;
                }
                current_depth_y += std::abs(y_step);
            }

            float depth = 0; int x_tex_coord = 0; bool is_vertical_wall = false;
            if (x_depth < y_depth) { depth = x_depth; x_tex_coord = x_texture; is_vertical_wall = true; }
            else { depth = y_depth; x_tex_coord = y_texture; is_vertical_wall = false; }

            int wall_y_pos = HALF_HEIGHT;

            if (depth < 9999.0f) {
                float fixed_depth = depth * std::cos(player_angle - angle);
                if (fixed_depth < 1.0f) fixed_depth = 1.0f;
                int proj_height = static_cast<int>((TILE_SIZE / fixed_depth) * 600.0f);
                if (proj_height > HEIGHT * 2) proj_height = HEIGHT * 2;

                wall_y_pos = HALF_HEIGHT - proj_height / 2;

                int shadow = 0;
                if (day_mode) {
                    shadow = is_vertical_wall ? 15 : 0;
                }
                else {
                    int base_shadow = static_cast<int>(fixed_depth * 0.75f);
                    if (is_vertical_wall) base_shadow += 20;
                    shadow = std::clamp(base_shadow, 0, 255);
                }

                int start_screen_y = std::max(0, wall_y_pos);
                int end_screen_y = std::min(HEIGHT, wall_y_pos + proj_height);

                for (int screen_y = start_screen_y; screen_y < end_screen_y; ++screen_y) {
                    int tex_y = ((screen_y - wall_y_pos) * TILE_SIZE) / proj_height;
                    tex_y = std::clamp(tex_y, 0, TILE_SIZE - 1);

                    Color pixel_color = tex_wall[tex_y * TILE_SIZE + std::clamp(x_tex_coord, 0, TILE_SIZE - 1)];
                    pixel_color.r = static_cast<unsigned char>(std::max(0, pixel_color.r - shadow));
                    pixel_color.g = static_cast<unsigned char>(std::max(0, pixel_color.g - shadow));
                    pixel_color.b = static_cast<unsigned char>(std::max(0, pixel_color.b - shadow));

                    for (int s = 0; s < SCALE; ++s) {
                        int pixel_x = ray * SCALE + s;
                        if (pixel_x < WIDTH) frame_buffer[screen_y * WIDTH + pixel_x] = pixel_color;
                    }
                }

                float cos_tilt = std::cos(player_angle - angle);
                for (int screen_y = 0; screen_y < wall_y_pos; screen_y += 4) {
                    if (screen_y >= HALF_HEIGHT) break;

                    float current_dist = (static_cast<float>(TILE_SIZE * HEIGHT)) / (2.0f * static_cast<float>(HALF_HEIGHT - screen_y) * cos_tilt);

                    int tex_x = static_cast<int>(player_x + r_cos * current_dist) % TILE_SIZE;
                    int tex_y_floor = static_cast<int>(player_y + r_sin * current_dist) % TILE_SIZE;
                    if (tex_x < 0) tex_x += TILE_SIZE;
                    if (tex_y_floor < 0) tex_y_floor += TILE_SIZE;

                    int f_shadow = day_mode ? 0 : std::clamp(static_cast<int>(current_dist * 0.75f), 0, 255);

                    Color c_color = tex_ceil[tex_y_floor * TILE_SIZE + tex_x];
                    c_color.r = static_cast<unsigned char>(std::max(0, c_color.r - f_shadow));
                    c_color.g = static_cast<unsigned char>(std::max(0, c_color.g - f_shadow));
                    c_color.b = static_cast<unsigned char>(std::max(0, c_color.b - f_shadow));

                    Color fl_color = tex_floor[tex_y_floor * TILE_SIZE + tex_x];
                    fl_color.r = static_cast<unsigned char>(std::max(0, fl_color.r - f_shadow));
                    fl_color.g = static_cast<unsigned char>(std::max(0, fl_color.g - f_shadow));
                    fl_color.b = static_cast<unsigned char>(std::max(0, fl_color.b - f_shadow));

                    for (int h = 0; h < 4; ++h) {
                        int curr_y = screen_y + h;
                        int floor_y = HEIGHT - curr_y - 1;

                        if (curr_y < wall_y_pos) {
                            for (int s = 0; s < SCALE; ++s) {
                                int pixel_x = ray * SCALE + s;
                                if (pixel_x < WIDTH) {
                                    frame_buffer[curr_y * WIDTH + pixel_x] = c_color;
                                    frame_buffer[floor_y * WIDTH + pixel_x] = fl_color;
                                }
                            }
                        }
                    }
                }
            }
        }

        HDC hdc = GetDC(hwnd);
        StretchDIBits(hdc, 0, 0, WIDTH, HEIGHT, 0, 0, WIDTH, HEIGHT, frame_buffer.data(), &bmi, DIB_RGB_COLORS, SRCCOPY);
        ReleaseDC(hwnd, hdc);
    }

    Gdiplus::GdiplusShutdown(gdiplusToken);
    return 0;
}