Изучи : 
bool requiresCaptcha = false;
std::string captchaKey;
std::string captchaSid;

void saveToken(const std::string& token) {
    std::ofstream file("token.txt");
    if (file.is_open()) {
        file << token;
        file.close();
        std::cout << "Токен сохранен в файле token.txt." << std::endl;
    }
    else {
        std::cerr << "Не удалось открыть файл для сохранения токена." << std::endl;
    }
}

std::string readToken() {
    std::ifstream file("token.txt");
    std::string token;
    if (file.is_open()) {
        std::getline(file, token);
        file.close();
        std::cout << "Токен успешно прочитан из файла token.txt." << std::endl;
    }
    else {
        std::cerr << "Файл token.txt не найден." << std::endl;
    }
    return token;
}

std::string urlEncode(const std::string& value) {
    std::ostringstream escaped;
    escaped.fill('0');
    escaped << std::hex;

    for (std::string::const_iterator i = value.begin(), n = value.end(); i != n; ++i) {
        std::string::value_type c = (*i);

        if (std::isalnum(c) || c == '-' || c == '_' || c == '.' || c == '~') {
            escaped << c;
            continue;
        }

        escaped << '%' << std::setw(2) << int((unsigned char)c);
    }

    return escaped.str();
}

static size_t WriteCallback(void* contents, size_t size, size_t nmemb, std::string* output) {
    size_t totalSize = size * nmemb;
    output->append((char*)contents, totalSize);
    return totalSize;
}

std::string getCurrentStatus(const std::string& token) {
    std::string url = "https://api.vk.com/method/status.get?access_token=" + token + "&v=5.131";

    CURL* curl = curl_easy_init();
    if (curl) {
        curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);

        std::string response;
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);

        CURLcode res = curl_easy_perform(curl);
        if (res == CURLE_OK) {
            rapidjson::Document document;
            document.Parse(response.c_str());

            if (document.HasMember("error") && document["error"].IsObject()) {
                int errorCode = document["error"]["error_code"].GetInt();
                if (errorCode == 14) {  // Код ошибки 14 означает, что требуется капча
                    requiresCaptcha = true;
                    captchaSid = document["error"]["captcha_sid"].GetString();
                    std::cerr << "Требуется капча. Откройте ссылку и введите код: "
                        << "https://vk.com/captcha.php?sid=" << captchaSid << std::endl;
                    return "";
                }
            }

            if (document.HasMember("response") &&
                document["response"].IsObject() &&
                document["response"].HasMember("text") &&
                document["response"]["text"].IsString()) {

                std::string currentStatus = document["response"]["text"].GetString();
                curl_easy_cleanup(curl);
                return currentStatus;
            }
        }

        curl_easy_cleanup(curl);
    }
    else {
        std::cerr << "Не удалось инициализировать libcurl." << std::endl;
    }

    return "";
}

std::string getNextStatus(const std::vector<std::string>& statuses, int& currentStatusIndex) {
    if (statuses.empty()) {
        std::cerr << "Не заданы статусы." << std::endl;
        return "";
    }

    std::string nextStatus = statuses[currentStatusIndex];
    currentStatusIndex = (currentStatusIndex + 1) % statuses.size();
    return nextStatus;
}

void inputCaptcha() {
    std::cout << "Введите код с капчи: ";
    std::cin >> captchaKey;
    requiresCaptcha = false;
}

void changeStatus(const std::string& token, const std::vector<std::string>& statuses, int interval) {

    static int currentStatusIndex = 0;

    std::string currentStatus = getCurrentStatus(token);

    while (requiresCaptcha) {
        std::cout << "Ожидание решения капчи..." << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(10));  // Пауза для ожидания решения капчи
        currentStatus = getCurrentStatus(token);  // Повторная проверка после ожидания
    }

    std::string nextStatus = getNextStatus(statuses, currentStatusIndex);

    if (nextStatus.empty()) {
        std::cerr << "Ошибка: не удалось выбрать новый статус." << std::endl;
        return;
    }

    nextStatus = urlEncode(nextStatus);

    std::string url = "https://api.vk.com/method/status.set?text=" + nextStatus + "&access_token=" + token + "&v=5.131";

    CURL* curl = curl_easy_init();
    if (curl) {
        curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);

        std::string response;
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);

        CURLcode res = curl_easy_perform(curl);

           std::cout << "Статус успешно изменен." << std::endl;
           std::cout << "Ответ от VK API: " << response << std::endl;
           if (requiresCaptcha) {
               inputCaptcha();
           }
        

        curl_easy_cleanup(curl);
    }
    else {
        std::cerr << "Не удалось инициализировать libcurl." << std::endl;
    }

    currentStatusIndex = (currentStatusIndex + 1) % statuses.size();
    std::cout << "Следующая смена статуса через " << interval << " секунд." << std::endl;
}




void loadSettings(int& interval, std::vector<std::string>& statuses) {
    std::ifstream file("settings.txt");
    if (file.is_open()) {
        std::string line;
        std::getline(file, line);
        interval = std::stoi(line);

        while (std::getline(file, line)) {
            statuses.push_back(line);
        }

        file.close();
        std::cout << "Настройки загружены из settings.txt" << std::endl;
    }
    else {
        std::cerr << "Не удалось открыть файл settings.txt" << std::endl;
    }
}

bool validateToken(const std::string& token) {
    std::string url = "https://api.vk.com/method/users.get?access_token=" + token + "&v=5.131";

    CURL* curl = curl_easy_init();
    if (curl) {
        curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);

        std::string response;
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);

        CURLcode res = curl_easy_perform(curl);
        if (res == CURLE_OK) {
            rapidjson::Document document;
            document.Parse(response.c_str());

            if (document.HasMember("response") &&
                document["response"].IsArray() &&
                document["response"].Size() > 0) {

                curl_easy_cleanup(curl);
                return true;
            }
        }

        curl_easy_cleanup(curl);
    }
    else {
        std::cerr << "Не удалось инициализировать libcurl." << std::endl;
    }

    return false;
}

int main() {

    std::string token;
    std::vector<std::string> statuses;
    int interval;

    setlocale(LC_ALL, "Russian");


    token = readToken();
    if (token.empty()) {
        std::cout << "Введите токен ВКонтакте: ";
        std::cin >> token;
        saveToken(token);
    }

    if (!validateToken(token)) {
        std::cerr << "Недействительный токен!" << std::endl;
        return 1;
    }

    loadSettings(interval, statuses);

    if (statuses.empty()) {
        std::cerr << "Не заданы статусы" << std::endl;
        return 1;
    }

    int currentStatusIndex = 0;

    while (true) {
        changeStatus(token, statuses, interval);
        if (requiresCaptcha) {
            inputCaptcha();
        }
        std::this_thread::sleep_for(std::chrono::seconds(interval));
    }

    return 0;
}