#pragma once
#include <iostream>
#include <vector>
#include <cstring>
#define _WINSOCK_DEPRECATED_NO_WARNINGS
#include <WinSock2.h>
#include <thread>
#include <format>
#include <atomic>
#include "io.hpp" // если используете C++23 то отключите просто у меня свой print
#include <mutex>
#include <chrono>
#include "hostname.hpp"
#pragma comment(lib,"ws2_32.lib")
std::mutex net_mt;
struct net {
    const char* target_ip = "142.251.1.102";
    int target_port = 443;                   
    size_t PACKET_SIZE = 64;
    SOCKET sock = INVALID_SOCKET;          
    sockaddr_in addr;
    int64_t max_iteration = 10;
    int success = 0, fall = 0, max_packets = 0;
    bool bMultiThread = false;
    std::string out_ping_str = "";
    int64_t i64MaxThreads = std::jthread::hardware_concurrency();
    net() {
        WSADATA wsaData;
        if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
            print(" WSAStartup failed\n");
        }
    }

    void sendDeep() {
        setlocale(LC_ALL, "rus");
        success = 0; fall = 0;
        sock = socket(AF_INET, SOCK_STREAM, 0);
        if (sock == INVALID_SOCKET) {
            print(" Socket creation failed\n");
            return;
        }
        else {
            print(" socket created\n");
        }

        addr.sin_family = AF_INET;
        addr.sin_port = htons(target_port);
        addr.sin_addr.s_addr = inet_addr(target_ip);

        print(" Connecting to [{}]...\n", target_ip);

        
        if (connect(sock, (struct sockaddr*)&addr, sizeof(addr)) == 0) {
            std::vector<char> buf(PACKET_SIZE, 'X');
            for (int64_t count = 0; count < max_iteration; count++) {
                SOCKET s = socket(AF_INET, SOCK_STREAM, 0);
                auto in_ping = std::chrono::high_resolution_clock::now();
                if (connect(s, (struct sockaddr*)&addr, sizeof(addr)) == 0) {
                    int sentBytes = send(s, buf.data(), (int)buf.size(), 0);

                    auto out_ping = std::chrono::high_resolution_clock::now();
                    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(out_ping - in_ping).count();
                    print(" {} [{}] Отправлен пакет: {} ms\n", count, target_ip, duration);
                    success++;
                    closesocket(s);
                }
                else {
                    print(" {} [{}] Ошибка подключения\n", count, target_ip);
                    fall++;
                    closesocket(s);
                }
            }
            print(" [{}] Сводка: Отправлено {}/{} ping : {}\n", target_ip, success, max_iteration, out_ping_str);
            closesocket(sock);
        }
        else {
            int err = WSAGetLastError();
            print(" [{}:{}] Connection Error! Code: {}\n", target_ip, target_port, err);
            std::cout << " Пока не поддерживаем пинг по URL но вот айпи вот айпи ниже";
            print("({}) ->( {} )", target_ip, getIPFromUrl(target_ip));
        }

    }
    ~net() {
        WSACleanup();
        print(" WSACleanup()\n");
    }
};

#include "ping.hpp"
struct PING_DATA {
  std::string usage_string = R"(
    Ошибка команды!
    Использование:
    ping.exe <флаг> <ip или url> <порт> <размер пакета> <количество пакетов>
    -----------------------------------------------------------------
    
    Пример:
    ping.exe -host "http://google.com" 80 64 4
            | 0   ||        1        || 2| 3|4|
    0 - Флаг (-ip - для теста по IP , -host - для теста по url
    1 - Адрес
    2 - Порт
    3 - размер пакета
    4 - количество пакетов
    -------------------------------------------------------------------
    created by HCPP20334 | Writtein C++20 Win10SDK
    )";
};
std::unique_ptr<PING_DATA> ping = std::make_unique<PING_DATA>();
std::unique_ptr<net>net_ptr = std::make_unique<net>();
std::string hostname_and_ip_str,flag_ping_to;
int main(int argc, char** argv) {
    setlocale(LC_ALL, "rus");
  if (argc < 2) {
    std::cout << ping->usage_string;
    }
    else {
        
       // flag_ping_to = std::string(reinterpret_cast<const char*>((argv[2])));
        print("ping by HCPP20334 | Writtein to C++20\n----------------------\n IP:{} | PORT:{} | MAX_ITERATION:{} | PACKET_SIZE:{}\n", (const char*)argv[1], std::stoi(argv[2]), std::stoi(argv[4]), std::stoll(argv[3]));
        hostname_and_ip_str = std::string(reinterpret_cast<const char*>((argv[1])));
        net_ptr->target_ip = hostname_and_ip_str.c_str();
        net_ptr->target_port = (std::stoi(argv[2]));
        net_ptr->PACKET_SIZE = (std::stoll(argv[3]));
        net_ptr->max_iteration = (std::stoi(argv[4]));
        net_ptr->sendDeep();
    }
}

#pragma once
#include <iostream>
#include <string>
#include <stdint.h>
#include <memory>
#include "net.hpp"

ВОТ свой принт

std::mutex deepPayloadMt;
std::string print_data;
template <class... Tm>
void print(const std::format_string<Tm...> _Fmt, Tm&&... _Args) {
    std::lock_guard<std::mutex> lock(deepPayloadMt);
    std::string_view out_buffer = _STD vformat(_Fmt.get(), _STD make_format_args(_Args...));
    std::cout << out_buffer.data();
}

// default string
std::string raw_string = R"( 
Hello World
Hello World
string
 )";
// wide string
std::wstring raw_wstring = LR"( 
Hello World
Hello World
wstring
 )";

std::wstring wdata = std::wstring(sdata.begin(),sdata.end());

const std::string_view tx = "0. Text\n"
                                                    "1. Text\n"
                                                    "2. Text\n"
                                                    "3. Text\n"
                                                    "4. Text\n";
int count = 0;
for(auto c : tx){
if(c == '\n'){count++;}
}
std::print("tx-size:{}, new_line:{}",tx.size(),count);

//auto как универсальный нож для все типов
//просто копирование типа 
std::vector<int> offsets = {4,3,6};
auto offset_0 = offsets[0];
offset_0 = 55;
//копирование с сохранение ссылки на объект
std::vector<int> offsets = {4,3,6};
auto& offset_0 = offsets[0];
offset_0 = 55;
//ссылка без копии
int64_t i64Data = 512LL;
const auto& data_const = i64Data;
//и кстати так можно защитить от изменении или использовать для перебора циклом
//вывод типа как у выражение с помощью decltype(auto)
int64_t a64 = 8;
int64_t &b64 = a64;
decltype(auto) c = r;
//почти "auto" но для шаблонов
using ty0 = int64_t&;
using ty1 = std::decay_t<ty0>;
if(std::is_same_v<ty1,int64_t>){
// этоn тип является int64_t
}
//можно проверить тип в auto c помощью std::is_same_v
int64_t data_i64 = 43;
auto &x = data_i64;
if(std::is_same_v<x,int64_t>){
// этоn тип является int64_t
}

std::string_view это красивый нож но хрупкий при неправильном обращении 


//это тот же стринг но без std::allocator Но не выделяет память под себя и живет пока данные живы в нем

//лучше использовать как константные массивы или строки

const std::string_view strv = "hello";
//передавать данные в него лучше через std::string 
//использовать std::format  с осторожностью так как если данных в std::format не будет то он передаст нулевой //указатель и это UB поэтому есть термин висячий указатель

std::jthread thread_0;
thread_0 = std::jthread([&]{
//твой код
});
std::jthread::hardware_concurrency() //получает количество потоков в процессоре
thread_0.joinable()// возвращает true если поток активен , false если не активен

#include <print>
#include <atomic>
#include <stdint.h>
#include <chrono>
#include <thread>

std::atomic<int64_t> counter_big = 0;
std::jthread thread;
int main(){
thread = std::jthread([&]{
while(true){
std::this_thread::sleep_for(std::chrono::milliseconds(1));
counter_big.fetch_add(1);
if(counter_big.load() >= 100){counter_big = 100;break;}
std::print("counter: {}",counter_big.load());
}
});
return 0;
}