```
// LuaC_Language.cpp
#include <windows.h>
#include <windowsx.h> // Для макросов GET_X_LPARAM и GET_Y_LPARAM
#include <tchar.h>
#include <vector>
#include <string>
#include <cmath> // Для функции atan2
#include "resource.h" // Добавлено для доступа к ресурсным идентификаторам

// Имя класса окна
const wchar_t g_szClassName[] = L"TaskSchedulerWindowClass";

// Структура для представления задачи
struct Task {
    RECT rect;
    std::wstring name;
    int id;
    COLORREF color;

    // Конструктор для инициализации всех членов
    Task(int x, int y, int id_)
        : name(L"Задача " + std::to_wstring(id_)), id(id_), color(RGB(173, 216, 230)) // Светло-голубой по умолчанию
    {
        rect.left = x - 50;
        rect.top = y - 25;
        rect.right = x + 50;
        rect.bottom = y + 25;
    }
};

// Структура для представления связи между задачами
struct Connection {
    int fromId;
    int toId;
};

// Класс для управления задачами и связями
class TaskManager {
public:
    TaskManager() : taskCounter(0) {}

    void AddTask(int x, int y) {
        int newId = ++taskCounter;
        tasks.emplace_back(x, y, newId);
    }

    void EditTask(int id, const std::wstring& newName) {
        for (auto& task : tasks) {
            if (task.id == id) {
                task.name = newName;
                break;
            }
        }
    }

    void ChangeTaskColor(int id, COLORREF newColor) {
        for (auto& task : tasks) {
            if (task.id == id) {
                task.color = newColor;
                break;
            }
        }
    }

    int HitTest(int x, int y) const {
        for (const auto& task : tasks) {
            if (x >= task.rect.left && x <= task.rect.right &&
                y >= task.rect.top && y <= task.rect.bottom) {
                return task.id;
            }
        }
        return -1;
    }

    Task* GetTaskById(int id) {
        for (auto& task : tasks) {
            if (task.id == id) return &task;
        }
        return nullptr;
    }

    const std::vector<Task>& GetTasks() const { return tasks; }
    const std::vector<Connection>& GetConnections() const { return connections; }

    void AddConnection(int fromId, int toId) {
        // Проверка существования связи
        for (const auto& conn : connections) {
            if (conn.fromId == fromId && conn.toId == toId)
                return; // Связь уже существует
        }
        connections.push_back(Connection{ fromId, toId });
    }

private:
    std::vector<Task> tasks;
    std::vector<Connection> connections;
    int taskCounter;
};

// Глобальный объект менеджера задач
TaskManager g_taskManager;

// Глобальные переменные для управления состоянием
bool isDragging = false;
POINT dragOffset = { 0 };
int draggedTaskId = -1;
int firstSelectedTaskId = -1;

// Прототипы функций
static LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
static INT_PTR CALLBACK EditDialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);

// Функция для рисования стрелки
static void DrawArrow(HDC hdc, POINT start, POINT end) {
    // Рисуем линию
    MoveToEx(hdc, start.x, start.y, NULL);
    LineTo(hdc, end.x, end.y);

    // Рисуем стрелку
    // Вычисляем угол
    double angle = atan2((double)(end.y - start.y), (double)(end.x - start.x));
    // Размер стрелки
    const int arrowSize = 10;
    // Вычисляем точки стрелки
    POINT p1 = {
        (int)(end.x - arrowSize * cos(angle - 0.3)),
        (int)(end.y - arrowSize * sin(angle - 0.3))
    };
    POINT p2 = {
        (int)(end.x - arrowSize * cos(angle + 0.3)),
        (int)(end.y - arrowSize * sin(angle + 0.3))
    };
    // Рисуем линии стрелки
    MoveToEx(hdc, end.x, end.y, NULL);
    LineTo(hdc, p1.x, p1.y);
    MoveToEx(hdc, end.x, end.y, NULL);
    LineTo(hdc, p2.x, p2.y);
}

// Функция для рисования всех задач и соединений
static void DrawAll(HWND hwnd, HDC hdc) {
    // Рисуем соединения
    for (const auto& conn : g_taskManager.GetConnections()) {
        // Найти задачи по id
        Task* fromTask = g_taskManager.GetTaskById(conn.fromId);
        Task* toTask = g_taskManager.GetTaskById(conn.toId);
        if (fromTask && toTask) {
            // Начальная точка (центр правой стороны fromTask)
            POINT start = { fromTask->rect.right, (fromTask->rect.top + fromTask->rect.bottom) / 2 };
            // Конечная точка (центр левой стороны toTask)
            POINT end = { toTask->rect.left, (toTask->rect.top + toTask->rect.bottom) / 2 };
            DrawArrow(hdc, start, end);
        }
    }

    // Рисуем задачи
    for (const auto& task : g_taskManager.GetTasks()) {
        // Создаем кисть для заливки
        HBRUSH hBrush = CreateSolidBrush(task.color);
        if (hBrush != NULL) {
            HBRUSH hOldBrush = (HBRUSH)SelectObject(hdc, hBrush);
            // Рисуем закрашенный прямоугольник
            Rectangle(hdc, task.rect.left, task.rect.top, task.rect.right, task.rect.bottom);
            // Восстанавливаем старую кисть
            SelectObject(hdc, hOldBrush);
            DeleteObject(hBrush);
        }

        // Рисуем границу
        Rectangle(hdc, task.rect.left, task.rect.top, task.rect.right, task.rect.bottom);

        // Рисуем текст
        DrawTextW(hdc, task.name.c_str(), -1, &task.rect, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
    }
}

// Функция для отображения инструкций по управлению
static void DrawInstructions(HWND hwnd, HDC hdc) {
    const wchar_t* instructions[] = {
        L"Инструкции по управлению:",
        L"- Правый клик: Добавить новую задачу или открыть контекстное меню задачи",
        L"- Левый клик: Выбрать задачу/создать связь",
        L"- Двойной клик: Редактировать текст задачи",
        L"- Перетащить задачу: Изменить её позицию",
        L"- Контекстное меню (правый клик на задаче): Изменить цвет"
    };

    RECT clientRect;
    GetClientRect(hwnd, &clientRect);
    int y = clientRect.bottom - 20 * 6 - 10; // Отступ снизу с учетом высоты текста

    SetBkMode(hdc, TRANSPARENT);
    for (const auto& line : instructions) {
        RECT textRect = { 10, y, clientRect.right - 10, y + 20 };
        DrawTextW(hdc, line, -1, &textRect, DT_LEFT | DT_TOP | DT_SINGLELINE);
        y += 20;
    }
}

// Функция обработки диалога редактирования задачи
static INT_PTR CALLBACK EditDialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) {
    static int editingTaskId;
    switch (uMsg) {
    case WM_INITDIALOG:
        // Получаем идентификатор задачи из lParam
        editingTaskId = (int)lParam;
        // Получаем текущее имя задачи
        {
            Task* task = g_taskManager.GetTaskById(editingTaskId);
            if (task) {
                SetDlgItemText(hwndDlg, IDC_EDIT1, task->name.c_str());
            }
        }
        return TRUE;
    case WM_COMMAND:
        if (LOWORD(wParam) == IDOK) {
            wchar_t buffer[256];
            GetDlgItemText(hwndDlg, IDC_EDIT1, buffer, 256);
            g_taskManager.EditTask(editingTaskId, buffer);
            EndDialog(hwndDlg, IDOK);
            return TRUE;
        }
        else if (LOWORD(wParam) == IDCANCEL) {
            EndDialog(hwndDlg, IDCANCEL);
            return TRUE;
        }
        break;
    }
    return FALSE;
}

// Функция обработки контекстного меню для изменения цвета задачи
static void ShowTaskContextMenu(HWND hwnd, int x, int y, int taskId) {
    HMENU hMenu = CreatePopupMenu();
    if (hMenu) {
        InsertMenu(hMenu, -1, MF_BYPOSITION, 1, L"Изменить цвет");

        // Показываем меню
        int cmd = TrackPopupMenu(hMenu, TPM_RETURNCMD | TPM_NONOTIFY, x, y, 0, hwnd, NULL);
        if (cmd == 1) {
            // Открываем диалог выбора цвета
            COLORREF color = RGB(255, 255, 255);
            CHOOSECOLOR cc = { 0 };
            static COLORREF acrCustClr[16] = { 0 };

            cc.lStructSize = sizeof(cc);
            cc.hwndOwner = hwnd;
            cc.lpCustColors = acrCustClr;
            cc.Flags = CC_FULLOPEN | CC_RGBINIT;
            cc.rgbResult = color;

            if (ChooseColor(&cc)) {
                g_taskManager.ChangeTaskColor(taskId, cc.rgbResult);
                InvalidateRect(hwnd, NULL, TRUE);
            }
        }

        DestroyMenu(hMenu);
    }
}

// Функция обработки сообщений окна
static LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) {
    switch (msg)
    {
    case WM_RBUTTONDOWN:
    {
        // Добавление новой задачи по правому клику на свободной области
        int x = GET_X_LPARAM(lParam);
        int y = GET_Y_LPARAM(lParam);
        int hitId = g_taskManager.HitTest(x, y);
        if (hitId == -1) {
            g_taskManager.AddTask(x, y);
            InvalidateRect(hwnd, NULL, TRUE);
        }
        else {
            // Если клик на задаче, показываем контекстное меню
            POINT pt = { x, y };
            ClientToScreen(hwnd, &pt);
            ShowTaskContextMenu(hwnd, pt.x, pt.y, hitId);
        }
    }
    break;

    case WM_LBUTTONDOWN:
    {
        int x = GET_X_LPARAM(lParam);
        int y = GET_Y_LPARAM(lParam);
        int hitId = g_taskManager.HitTest(x, y);
        if (hitId != -1) {
            if (firstSelectedTaskId == -1) {
                // Выбор первой задачи для соединения
                firstSelectedTaskId = hitId;
            }
            else if (firstSelectedTaskId != hitId) {
                // Создание соединения
                g_taskManager.AddConnection(firstSelectedTaskId, hitId);
                firstSelectedTaskId = -1;
                InvalidateRect(hwnd, NULL, TRUE);
            }
            // Начало перетаскивания
            isDragging = true;
            draggedTaskId = hitId;
            // Получение начального смещения
            Task* task = g_taskManager.GetTaskById(draggedTaskId);
            if (task) {
                POINT cursorPos;
                GetCursorPos(&cursorPos);
                ScreenToClient(hwnd, &cursorPos);
                dragOffset.x = cursorPos.x - task->rect.left;
                dragOffset.y = cursorPos.y - task->rect.top;
            }
        }
        SetCapture(hwnd);
    }
    break;

    case WM_MOUSEMOVE:
    {
        if (isDragging && draggedTaskId != -1) {
            int x = GET_X_LPARAM(lParam);
            int y = GET_Y_LPARAM(lParam);
            // Обновление позиции задачи
            Task* task = g_taskManager.GetTaskById(draggedTaskId);
            if (task) {
                int width = task->rect.right - task->rect.left;
                int height = task->rect.bottom - task->rect.top;
                task->rect.left = x - dragOffset.x;
                task->rect.top = y - dragOffset.y;
                task->rect.right = task->rect.left + width;
                task->rect.bottom = task->rect.top + height;
                InvalidateRect(hwnd, NULL, TRUE);
            }
        }
    }
    break;

    case WM_LBUTTONUP:
    {
        isDragging = false;
        draggedTaskId = -1;
        ReleaseCapture();
    }
    break;

    case WM_LBUTTONDBLCLK:
    {
        int x = GET_X_LPARAM(lParam);
        int y = GET_Y_LPARAM(lParam);
        int hitId = g_taskManager.HitTest(x, y);
        if (hitId != -1) {
            // Открываем диалог редактирования задачи
            DialogBoxParam(GetModuleHandle(NULL), MAKEINTRESOURCE(IDD_EDITDIALOG), hwnd, EditDialogProc, hitId);
            InvalidateRect(hwnd, NULL, TRUE);
        }
    }
    break;

    case WM_CHAR:
    {
        if (wParam == VK_ESCAPE) {
            // Сброс выбранной задачи при нажатии Escape
            firstSelectedTaskId = -1;
            InvalidateRect(hwnd, NULL, TRUE);
        }
    }
    break;

    case WM_PAINT:
    {
        PAINTSTRUCT ps;
        HDC hdc = BeginPaint(hwnd, &ps);
        // Рисуем все компоненты
        DrawAll(hwnd, hdc);
        DrawInstructions(hwnd, hdc);
        EndPaint(hwnd, &ps);
    }
    break;

    case WM_DESTROY:
        PostQuitMessage(0);
        break;

    default:
        return DefWindowProc(hwnd, msg, wParam, lParam);
    }
    return 0;
}

// Функция для запуска приложения
int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
    PWSTR lpCmdLine, int nCmdShow)
{
    // Регистрация класса окна
    WNDCLASSEX wc = { 0 };
    wc.cbSize = sizeof(WNDCLASSEX);
    wc.style = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc = WndProc;
    wc.hInstance = hInstance;
    wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    wc.lpszClassName = g_szClassName;
    wc.hIconSm = LoadIcon(NULL, IDI_APPLICATION);

    if (!RegisterClassEx(&wc))
    {
        MessageBox(NULL, L"Класс окна не зарегистрирован!", L"Ошибка",
            MB_ICONEXCLAMATION | MB_OK);
        return 0;
    }

    // Создание окна
    HWND hwnd = CreateWindowEx(
        0,
        g_szClassName,
        L"Планирование задач с графическим представлением",
        WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, CW_USEDEFAULT, 1000, 700,
        NULL, NULL, hInstance, NULL);

    if (hwnd == NULL)
    {
        MessageBox(NULL, L"Окно не создано!", L"Ошибка",
            MB_ICONEXCLAMATION | MB_OK);
        return 0;
    }

    ShowWindow(hwnd, nCmdShow);
    UpdateWindow(hwnd);

    // Цикл обработки сообщений
    MSG Msg = { 0 };
    while (GetMessage(&Msg, NULL, 0, 0) > 0)
    {
        TranslateMessage(&Msg);
        DispatchMessage(&Msg);
    }
    return static_cast<int>(Msg.wParam);
}
```
Преобразуй следующий код, чтобы он соответствовал уровню senior-разработчика: используй объектно-ориентированное программирование с инкапсуляцией, абстракцией и наследованием там, где это уместно, сделай архитектуру модульной, расширяемой и поддерживаемой, оптимизируй производительность и читаемость, улучшай именования переменных, функций и классов, устраняй дублирование кода, применяй подходящие паттерны проектирования для гибкости и масштабируемости, внедри обработку ошибок с информативными сообщениями и обеспечь логирование ключевых событий, добавь подробные комментарии и документацию к основным классам и методам, обеспечь финальный код простым для понимания, тестирования и поддержки.