#include <muduo/net/TcpServer.h>
#include <muduo/base/Logging.h>
#include <boost/bind.hpp>
#include <muduo/net/EventLoop.h>

// 使用muduo开发回显服务器
class EchoServer
{
 public:
  EchoServer(muduo::net::EventLoop* loop,
             const muduo::net::InetAddress& listenAddr);

  void start(); 

 private:
  void onConnection(const muduo::net::TcpConnectionPtr& conn);

  void onMessage(const muduo::net::TcpConnectionPtr& conn,
                 muduo::net::Buffer* buf,
                 muduo::Timestamp time);

  muduo::net::TcpServer server_;
};

EchoServer::EchoServer(muduo::net::EventLoop* loop,
                       const muduo::net::InetAddress& listenAddr)
  : server_(loop, listenAddr, "EchoServer")
{
  server_.setConnectionCallback(
      boost::bind(&EchoServer::onConnection, this, _1));
  server_.setMessageCallback(
      boost::bind(&EchoServer::onMessage, this, _1, _2, _3));
}

void EchoServer::start()
{
  server_.start();
}

void EchoServer::onConnection(const muduo::net::TcpConnectionPtr& conn)
{
  LOG_INFO << "EchoServer - " << conn->peerAddress().toIpPort() << " -> "
           << conn->localAddress().toIpPort() << " is "
           << (conn->connected() ? "UP" : "DOWN");
}

void EchoServer::onMessage(const muduo::net::TcpConnectionPtr& conn,
                           muduo::net::Buffer* buf,
                           muduo::Timestamp time)
{
  // 接收到所有的消息，然后回显
  muduo::string msg(buf->retrieveAllAsString());
  LOG_INFO << conn->name() << " echo " << msg.size() << " bytes, "
           << "data received at " << time.toString();
  conn->send(msg);
}


int main()
{
  LOG_INFO << "pid = " << getpid();
  muduo::net::EventLoop loop;
  muduo::net::InetAddress listenAddr(8888);
  EchoServer server(&loop, listenAddr);
  server.start();
  loop.loop();
}

//设置EventLoop的线程个数，底层通过EventLoopThreadPool线程池管理线程类EventLoopThread
_server.setThreadNum(10);

void setConnectionCallback(const ConnectionCallback& cb)
{
    connectionCallback_ = cb;
}
void setMessageCallback(const MessageCallback & cb)
{
    messageCallback_ = cb;
}

typedef std::function<void (const TcpConnectionPtr&)> ConnectionCallback;
typedef std::function<void (const TcpConnectionPtr&, Buffer*, Timestamp)> MessageCallback;

#include<muduo/net/TcpServer.h>
#include<muduo/net/EventLoop.h>
#include<functional>
using namespace std::placeholders;
#include<iostream>

class ChatServer
{
public:
    /* 在其中：
     * 1、类内构造TcpServer，初始化EventLoop指针
     * 2、给TcpServer注册用户连接的创建、连接的断开回调
     * 3、给TcpServer注册用户读写事件回调
     * 4、设置TcpServer的线程数量，muduo库会自己分配IO线程和工作线程
     */
    ChatServer(muduo::net::EventLoop* loop, //事件循环
               const muduo::net::InetAddress& listenAddr,   //IP+port
               const std::string& nameArg)  //服务器的名字
        : m_server(loop, listenAddr, nameArg),
          m_loop(loop)
    {
        m_server.setConnectionCallback(std::bind(&ChatServer::onConnection, this, _1));
        m_server.setMessageCallback(std::bind(&ChatServer::onMessage, this, _1, _2, _3));
        m_server.setThreadNum(4);
    }
    //开启事件循环
    void start()
    {
        m_server.start();
    }
private:
    //当发生用户的连接创建、连接断开事件后，调用函数
    void onConnection(const muduo::net::TcpConnectionPtr &conn)
    {

    }
    //读写事件发生后，调用函数
    void onMessage(const muduo::net::TcpConnectionPtr &conn,
                   muduo::net::Buffer * buffer,
                   muduo::Timestamp time)
    {

    }
private:
    muduo::net::TcpServer m_server;
    muduo::net::EventLoop * m_loop;
};

//当发生用户的连接创建、连接断开事件后，调用函数
void onConnection(const muduo::net::TcpConnectionPtr &conn)
{
    std::cout << conn->peerAddress().toIpPort() << " -> " <<
        conn->localAddress().toIpPort() << " state:";
    if(conn->connected())
    {
        std::cout << " online.";
    }
    else
    {
        std::cout << " offline."
        conn->shutdown();
        //_loop->quit();
    }
    std::cout << std::endl;
}
//读写事件发生后，调用函数
void onMessage(const muduo::net::TcpConnectionPtr &conn,
               muduo::net::Buffer * buffer,
               muduo::Timestamp time)
{
    std::string buf = buffer->retrieveAllAsString();
    std::cout << "recv data: " << buf << " time: " << time.toString() << std::endl;
    conn->send(buf);
}

int main()
{
    muduo::net::EventLoop loop; //相当于创建了一个epoll
    muduo::net::InetAddress addr("127.0.0.1", 6000);
    ChatServer chatserver(&loop, addr, "mychat");
    chatserver.start();
    loop.loop();    //相当于调用epoll_wait，以阻塞方式等待新用户连接事件、已连接用户的读写事件
}

#include <thread>
#include <chrono>
constinit int tickets = 100;
void station(void);
void station2(void);

int main()
{
    std::thread th(&station);
    std::thread th2(&station2);
    th.detach();
    th2.detach();
    //std::this_thread::sleep_for(std::chrono::milliseconds(5000));
    std::this_thread::sleep_for(5000ms);
}
void station(void)
{
    while (true)
    {
        if (tickets > 0)
        {
            std::wcout << L"Station #1: " << tickets-- << std::endl;
        }
        else
        {
            break;
        }
    }
}
void station2(void)
{
    while (true)
    {
        if (tickets > 0)
        {
            std::wcout << L"Station #2: " << tickets-- << std::endl;
        }
        else
        {
            break;
        }
    }
}

#include <iostream>
#include <print>
#include <thread>
#include <mutex>
#include <vector>
#include <chrono>
using namespace std::literals;
void seller(std::string const& name, int& ticketsNum, std::mutex& mx);
int main()
{
    std::vector<std::jthread> vec_jthreads;
    int tickets = 1000;
    std::mutex mx;
    // start new thread
    for (int i = 0; i < 10; ++i)
    {
        std::stringstream ss;
        ss << "seller " << i;
        vec_jthreads.emplace_back(seller, ss.str(), std::ref(tickets), std::ref(mx));
    }
    
    for (auto& jth : vec_jthreads)
    {
        jth.join();
    }

    std::println("Finally, tickets remain: {}", tickets);
    return 0;
}
void seller(std::string const& name, int& tickets, std::mutex& mx)
{
    std::this_thread::sleep_for(1000ms);
    while (true)
    {
        mx.lock();
        if (tickets > 0)
        {
            std::println("{}: {}", name, tickets);
            --tickets;
            mx.unlock();
        }
        else
        {
            mx.unlock();
            break;
        }
    }
}

void station(std::mutex& mx);
int main()
{
    std::mutex mx;
    std::thread th(&station, mx); // error
    th.join();
}
void station(std::mutex& mx)
{
    // ...
}

void station(std::mutex& mx);
void station2(std::mutex& mx);
int main()
{
    std::mutex mx;
    std::thread th(&station, std::ref(mx));
    std::thread th2(&station2, std::ref(mx));
    th.join();
    th2.join();
}
void station(std::mutex& mx)
{
    // ...
}
void station2(std::mutex& mx)
{
    // ...
}

void station(std::mutex& mx);
void station2(std::mutex& mx);
int main()
{
    std::mutex mx;
    std::thread th(&station, std::ref(mx));
    std::thread th2(&station2, std::ref(mx));
    th.join();
    th2.join();
}
void station(std::mutex& mx)
{
    while (true)
    {
        std::lock_guard<std::mutex> lck{ mx };
        if (tickets > 0)
        {
            std::wcout << L"Station #1: " << tickets-- << std::endl;
        }
        else
        {
            break;
        }
    } // 退出此括号时，lck析构
}
void station2(std::mutex& mx)
{
    while (true)
    {
        std::lock_guard lck{ mx }; // 在`C++17`后，不用填写模板参数，可以自动判断程序代码大括号中的参数类型。
        if (tickets > 0)
        {
            std::wcout << L"Station #2: " << tickets-- << std::endl;
        }
        else
        {
            break;
        }
    } // 退出此括号时，lck析构
}

void station(std::mutex& mx);
void station2(std::mutex& mx);
int main()
{
    std::mutex mx;
    std::thread th(&station, std::ref(mx));
    std::thread th2(&station2, std::ref(mx));
    th.join();
    th2.join();
}
void station(std::mutex& mx)
{
    while (true)
    {
        std::unique_lock lck{ mx };
        if (tickets > 0)
        {
            std::wcout << L"Station #1: " << tickets-- << std::endl;
            std::unique_lock lck2 = std::move(lck);
        }
        else
        {
            break;
        }
    } // 退出此括号时，lck2、lck析构
}
// station2 ...

#include <shared_mutex>
#include <iostream>
#include <thread>
#include <chrono>
#include <mutex>
constinit int tickets{ 0 };
void station(std::shared_mutex& mx);
void station2(std::shared_mutex& mx);
void produce(std::shared_mutex& mx);
using namespace std::chrono_literals;

int main()
{
    std::shared_mutex mx;
    std::thread consumer(&station, std::ref(mx));
    std::thread consumer2(&station2, std::ref(mx));
    std::thread producer(&produce, std::ref(mx));

    consumer.join();
    consumer2.join();
    producer.join();
}
void produce(std::shared_mutex& mx)
{
    while (true)
    {
        mx.lock();
        std::wcout << L"Producer: " << ++tickets << std::endl;
        std::this_thread::sleep_for(500ms);
        mx.unlock();

    }
}
void station(std::shared_mutex& mx)
{
    while (true)
    {
        mx.lock_shared();
        if (tickets > 0)
        {
            std::wcout << L"Station #1: " << tickets-- << std::endl;
            mx.unlock_shared();
        }
        else
        {
            mx.unlock_shared();
        }
    }
}
void station2(std::shared_mutex& mx)
{
    while (true)
    {
        mx.lock_shared();
        if (tickets > 0)
        {
            std::wcout << L"Station #2: " << tickets-- << std::endl;
            mx.unlock_shared();
        }
        else
        {
            mx.unlock_shared();
        }
    }
}

#include <shared_mutex>
#include <iostream>
#include <thread>
#include <chrono>
#include <mutex>
constinit int tickets{ 0 };
void station(std::shared_mutex& mx);
void station2(std::shared_mutex& mx);
void produce(std::shared_mutex& mx);
using namespace std::chrono_literals;

int main()
{
    std::shared_mutex mx;
    std::thread consumer(&station, std::ref(mx));
    std::thread consumer2(&station2, std::ref(mx));
    std::thread producer(&produce, std::ref(mx));

    consumer.join();
    consumer2.join();
    producer.join();
}
void produce(std::shared_mutex& mx)
{
    while (true)
    {
        std::unique_lock lck{ mx };
        std::wcout << L"Producer: " << ++tickets << std::endl;
        std::this_thread::sleep_for(500ms);
    }
}
void station(std::shared_mutex& mx)
{
    while (true)
    {
        std::shared_lock lck{ mx };
        if (tickets > 0)
        {
            std::wcout << L"Station #1: " << tickets-- << std::endl;
        }
        else
        {
        }
    }
}
void station2(std::shared_mutex& mx)
{
    while (true)
    {
        std::shared_lock lck{ mx };
        if (tickets > 0)
        {
            std::wcout << L"Station #2: " << tickets-- << std::endl;
        }
        else
        {
        }
    }
}

#include <iostream>
#Include <thread>
#include <chrono>

using namespace std::chrono_literals;
int main()
{
    std::thread t1([]() -> void
    {
        for (int i = 0; i <= 100; ++i)
        {
            std::cout << i << std::endl;
            std::this_thread::sleep_for(100ms);
        }
    });
    t1.join();
}

#include <iostream>
#Include <thread>
#include <chrono>

using namespace std::chrono_literals;
int main()
{
    auto nums{ 100 };
    std::thread t1([](auto nu) -> void
        {
            for (int i = 0; i <= nu; ++i)
            {
                std::cout << i << std::endl;
                std::this_thread::sleep_for(100ms);
            }
            nu = 50; // 带不回去
        }, nums);
    std::thread t2([](int& nu) -> void
        {
            for (int i = 0; i <= nu; ++i)
            {
                std::cout << i << std::endl;
                std::this_thread::sleep_for(100ms);
            }
            nu = 50;  // 带回去修改了nums的值
        }, std::ref(nums));
    t1.join();
    t2.join();
}

#include <iostream>
#include <thread>

using namespace std::chrono_literals;
int main()
{
    std::jthread t1([](std::stop_token tok) -> void
        {
            for (int i = 0; i <= 100; ++i)
            {
                std::cout << i << std::endl;
                if (tok.stop_requested())
                {
                    break;
                }
                std::this_thread::sleep_for(100ms);
            }
        });
        
    std::this_thread::sleep_for(3s);
    t1.request_stop();
    
    t1.join();
    return 0;
}

#include <iostream>
#include <thread>
#include<stop_token>
using namespace std::chrono_literals;
int main()
{
    std::jthread t1([](std::stop_token tok) -> void
        {
            for (int i = 0; i <= 100; ++i)
            {
                std::cout << i << std::endl;
                if (tok.stop_requested())
                {
                    break;
                }
                std::this_thread::sleep_for(100ms);
            }
        });
    
    auto source = t1.get_stop_source();
    std::this_thread::sleep_for(3s);
    source.request_stop();
}

#include <iostream>
#include <thread>
#include <stop_token>
using namespace std::chrono_literals;
int main()
{
    std::jthread t1([](std::stop_token tok) -> void
        {
            for (int i = 0; i <= 100; ++i)
            {
                std::cout << i << std::endl;
                if (tok.stop_requested())
                {
                    break;
                }
                std::this_thread::sleep_for(100ms);
            }
        });

    std::stop_callback cb{ t1.get_stop_token(), []() -> void
        {
            std::wcout << L"Stopped!" << std::endl;
        } };

    std::this_thread::sleep_for(3s);
    t1.request_stop();
}

#include <condition_variable>
#include <mutex>
std::mutex mx;
std::condition_variable cv;
using namespace std::chrono_literals;
int main()
{
    std::jthread t1([]() -> void
    {
        std::unique_lock lck{ mx };
        cv.wait(lck);
        for (int i = 0; i <= 100; ++i)
        {
            std::cout << i << std::endl;
            
            std::this_thread::sleep_for(100ms);
        }
    });
    std::this_thread::sleep_for(3s);
    cv.notify_one();
}

int main()
{
    // t1 ...

    std::this_thread::sleep_for(3s);
    
    std::unique_lock lck{ mx };    // add
    cv.notify_one();
    lck.unlock();                  // add
    
}

template <class Rep, class Period>
cv_status wait_for (unique_lock<mutex>& lck, const chrono::duration<Rep,Period>& rel_time);

#include <condition_variable>
#include <mutex>
#include <iostream>
std::mutex mx, mx2;
std::condition_variable cv, cv2;
using namespace std::chrono_literals;
int main()
{
    std::jthread t1([]() -> void
    {
        std::unique_lock lck{ mx };
        cv.wait(lck);
        std::cout << "Got the Notify to Start!" << std::endl;

        for (int i = 0; i <= 1000; ++i)
        {
            std::cout << i << std::endl;

            std::unique_lock lck2{ mx2 };
            if (auto status = cv2.wait_for(lck2, 50ms);
                status == std::cv_status::no_timeout)
            {
                std::cout << "Got the Notify to Out!" << std::endl;
                break;
            }
            else
            {
                std::cout << "Timeout: No Notify" << std::endl;
            }
        }
    });
    std::this_thread::sleep_for(1s);
    std::unique_lock lck{ mx };
    cv.notify_one();
    lck.unlock();
    std::this_thread::sleep_for(3s);
    std::unique_lock lck2{ mx2 };
    cv2.notify_one();
    lck2.unlock();
}

int main()
{
    // ...
    std::this_thread::sleep_for(1s);
    std::wcout << L"After Sleep 1s..." << std::endl;
    
    std::unique_lock lck{ mx };
    cv.notify_one();
    lck.unlock();
    
    std::wcout << L"Before Sleep 8s..." << std::endl;
    std::this_thread::sleep_for(8s);
    std::wcout << L"After Sleep 8s..." << std::endl;
    std::unique_lock lck2{ mx2 };
    cv2.notify_one();
    lck2.unlock();
}

#include <condition_variable>
#include <mutex>
#include <iostream>
std::mutex mx, mx2;
std::condition_variable cv, cv2;
bool stop_requested = false;
using namespace std::chrono_literals;
int main()
{
    std::jthread t1([]() -> void
    {
        std::unique_lock lck{ mx };
        cv.wait(lck);
        std::cout << "Got the Notify to Start!" << std::endl;

        for (int i = 0; i <= 1000; ++i)
        {
            std::cout << i << std::endl;

            std::unique_lock lck2{ mx2 };
            if (auto status = cv2.wait_for(lck2, 50ms);
                status == std::cv_status::no_timeout && stop_requested == true)
            {
                std::cout << "Got the Notify to Out!" << std::endl;
                break;
            }
            else
            {
                std::cout << "Timeout: No Notify" << std::endl;
            }
        }
    });
    std::this_thread::sleep_for(1s);
    std::wcout << L"After Sleep 1s..." << std::endl;

    std::unique_lock lck{ mx };
    cv.notify_one();
    lck.unlock();

    std::wcout << L"Before Sleep 8s..." << std::endl;
    std::this_thread::sleep_for(8s);
    std::wcout << L"After Sleep 8s..." << std::endl;
    
    std::unique_lock lck2{ mx2 };
    stop_requested = true;
    cv2.notify_one();
    lck2.unlock();
}

wait(lck, [&stop_requested]() -> bool { return stop_requested; });