#ifndef DOUBLE_CHECKED_SINGLETON_H
#define DOUBLE_CHECKED_SINGLETON_H

#include <iostream>
#include <mutex>
#include <atomic>
#include <memory>

class DoubleCheckedSingleton {
public:
    // 禁用复制构造和赋值运算符
    DoubleCheckedSingleton(const DoubleCheckedSingleton&) = delete;
    DoubleCheckedSingleton& operator=(const DoubleCheckedSingleton&) = delete;

    // 获取单例实例
    static DoubleCheckedSingleton* getInstance() {
        DoubleCheckedSingleton* p = instance.load(std::memory_order_acquire);
        if (p == nullptr) { // 第一次检查（无锁）
            std::lock_guard<std::mutex> lock(mutex);
            p = instance.load(std::memory_order_relaxed);
            if (p == nullptr) { // 第二次检查（有锁）
                p = new DoubleCheckedSingleton();
                instance.store(p, std::memory_order_release);
            }
        }
        return p;
    }

    // 释放单例（在程序结束时调用）
    static void destroyInstance() {
        std::lock_guard<std::mutex> lock(mutex);
        if (instance != nullptr) {
            delete instance.load();
            instance = nullptr;
        }
    }

    // 析构函数
    ~DoubleCheckedSingleton() {
        std::cout << "双重检测锁单例被销毁" << std::endl;
    }

private:
    // 私有构造函数，防止外部实例化
    DoubleCheckedSingleton() = default;

    static std::atomic<DoubleCheckedSingleton*> instance;
    static std::mutex mutex;
};

// 静态成员变量初始化
std::atomic<DoubleCheckedSingleton*> DoubleCheckedSingleton::instance{nullptr};
std::mutex DoubleCheckedSingleton::mutex;

#endif // DOUBLE_CHECKED_SINGLETON_H

#ifndef STATIC_LOCAL_SINGLETON_H
#define STATIC_LOCAL_SINGLETON_H

#include <iostream>

class StaticLocalSingleton {
public:
    // 禁用复制构造和赋值运算符
    StaticLocalSingleton(const StaticLocalSingleton&) = delete;
    StaticLocalSingleton& operator=(const StaticLocalSingleton&) = delete;
    
    // 获取单例实例
    static StaticLocalSingleton& getInstance() {
        // C++11保证静态局部变量的初始化是线程安全的
        static StaticLocalSingleton instance;
        return instance;
    }
    
    // 析构函数
    ~StaticLocalSingleton() {
        std::cout << "静态局部变量单例被销毁" << std::endl;
    }

private:
    // 私有构造函数
    StaticLocalSingleton() = default;
};

#endif // STATIC_LOCAL_SINGLETON_H

#ifndef EAGER_SINGLETON_H
#define EAGER_SINGLETON_H

#include <iostream>

class EagerSingleton {
public:
    // 禁用复制构造和赋值运算符
    EagerSingleton(const EagerSingleton&) = delete;
    EagerSingleton& operator=(const EagerSingleton&) = delete;
    
    // 获取单例实例
    static EagerSingleton& getInstance() {
        return instance;
    }
    
    // 析构函数
    ~EagerSingleton() {
        std::cout << "饿汉单例被销毁" << std::endl;
    }

private:
    // 私有构造函数
    EagerSingleton() = default;
    
    // 静态实例（在程序加载时就创建）先创建对象，不管用与不用
    static EagerSingleton instance;
};

// 静态成员变量初始化
EagerSingleton EagerSingleton::instance;

#endif // EAGER_SINGLETON_H

#ifndef EAGER_SINGLETON_PTR_H
#define EAGER_SINGLETON_PTR_H

#include <iostream>

class EagerSingletonPtr {
public:
    // 禁用复制构造和赋值运算符
    EagerSingletonPtr(const EagerSingletonPtr&) = delete;
    EagerSingletonPtr& operator=(const EagerSingletonPtr&) = delete;
    
    // 获取单例实例
    static EagerSingletonPtr* getInstance() {
        return instance;
    }
    
    // 释放单例资源（解决内存泄漏问题）
    static void destroyInstance() {
        if (instance != nullptr) {
            delete instance;
            instance = nullptr;
        }
    }
    
    // 析构函数
    ~EagerSingletonPtr() {
        std::cout << "饿汉单例被销毁" << std::endl;
    }

private:
    // 私有构造函数
    EagerSingletonPtr() = default;
    
    // 静态实例（在程序加载时就创建）先创建对象，不管用与不用
    static EagerSingletonPtr* instance;
};

// 静态成员变量初始化
EagerSingletonPtr* EagerSingletonPtr::instance = new EagerSingletonPtr();

#endif // EAGER_SINGLETON_PTR_H

char buffer[256];
char* val = getcwd(buffer, sizeof(buffer));
if (val)
{
    std::cout << buffer << std::endl;
}

/mnt/d/a-mycode/C++/DDZ-NET/server-ddz/tcp/include/TcpConnection.h:31:5: error: ‘Communication’ does not name a type
   31 |     Communication* m_reply = nullptr;
      |     ^~~~~~~~~~~~~

// 创建MD5哈希对象
CryptographicHash hash(CryptographicHash::HashType::Md5);

// 添加数据
hash.addData("Hello World");

// 获取十六进制结果
std::string hexResult = hash.result();
// 获取二进制结果
std::string binResult = hash.result(CryptographicHash::Type::Binary);

#include <openssl/evp.h>
#include <openssl/md5.h>
#include <openssl/sha.h>
#include <map>

enum class HashType : char {
    Md5,
    Sha1,
    Sha224,
    Sha256,
    Sha384,
    Sha512,
    Sha3_224,
    Sha3_256,
    Sha3_384,
    Sha3_512,
};

using hashFunc = const EVP_MD* (*)();
const std::map<HashType, hashFunc> HashMethods = {
    {HashType::Md5, EVP_md5},
    {HashType::Sha1, EVP_sha1},
    {HashType::Sha224, EVP_sha224},
    {HashType::Sha256, EVP_sha256},
    {HashType::Sha384, EVP_sha384},
    {HashType::Sha512, EVP_sha512},
    {HashType::Sha3_224, EVP_sha3_224},
    {HashType::Sha3_256, EVP_sha3_256},
    {HashType::Sha3_384, EVP_sha3_384},
    {HashType::Sha3_512, EVP_sha3_512},
};

const std::map<HashType, int> HashLength
{
    {HashType::Md5,MD5_DIGEST_LENGTH},
    {HashType::Sha1,SHA_DIGEST_LENGTH},
    {HashType::Sha224,SHA224_DIGEST_LENGTH},
    {HashType::Sha256,SHA256_DIGEST_LENGTH},
    {HashType::Sha384,SHA384_DIGEST_LENGTH},
    {HashType::Sha512,SHA512_DIGEST_LENGTH},
    {HashType::Sha3_224,SHA224_DIGEST_LENGTH},
    {HashType::Sha3_256,SHA256_DIGEST_LENGTH},
    {HashType::Sha3_384,SHA384_DIGEST_LENGTH},
    {HashType::Sha3_512,SHA512_DIGEST_LENGTH},
};

EVP_MD_CTX *EVP_MD_CTX_new(void);

m_ctx = EVP_MD_CTX_new();
assert(m_ctx);

int EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl);

int ret = EVP_DigestInit_ex(m_ctx, HashMethods.at(hashType)(),NULL);
assert(ret == 1);

int EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *data, size_t count);

const int ret = EVP_DigestUpdate(m_ctx, data, length);

int EVP_DigestFinal_ex(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *s);

unsigned int len = 0;
unsigned char md[HashLength.at(m_hashType)];
const int ret = EVP_DigestFinal_ex(m_ctx, md, &len);

void EVP_MD_CTX_free(EVP_MD_CTX *ctx);

CryptographicHash::~CryptographicHash() {
    if (m_ctx) {
        EVP_MD_CTX_free(m_ctx);
    }
}

#ifndef CRYPTOGRAPHICHASH_H
#define CRYPTOGRAPHICHASH_H

#include <map>
#include <string>
#include <openssl/evp.h>
#include <openssl/sha.h>
#include <openssl/md5.h>

enum class HashType : char {
    Md5,
    Sha1,
    Sha224,
    Sha256,
    Sha384,
    Sha512,
    Sha3_224,
    Sha3_256,
    Sha3_384,
    Sha3_512,
};

using hashFunc = const EVP_MD* (*)();
const std::map<HashType, hashFunc> HashMethods = {
    {HashType::Md5, EVP_md5},
    {HashType::Sha1, EVP_sha1},
    {HashType::Sha224, EVP_sha224},
    {HashType::Sha256, EVP_sha256},
    {HashType::Sha384, EVP_sha384},
    {HashType::Sha512, EVP_sha512},
    {HashType::Sha3_224, EVP_sha3_224},
    {HashType::Sha3_256, EVP_sha3_256},
    {HashType::Sha3_384, EVP_sha3_384},
    {HashType::Sha3_512, EVP_sha3_512},
};

const std::map<HashType, int> HashLength
{
    {HashType::Md5,MD5_DIGEST_LENGTH},
    {HashType::Sha1,SHA_DIGEST_LENGTH},
    {HashType::Sha224,SHA224_DIGEST_LENGTH},
    {HashType::Sha256,SHA256_DIGEST_LENGTH},
    {HashType::Sha384,SHA384_DIGEST_LENGTH},
    {HashType::Sha512,SHA512_DIGEST_LENGTH},
    {HashType::Sha3_224,SHA224_DIGEST_LENGTH},
    {HashType::Sha3_256,SHA256_DIGEST_LENGTH},
    {HashType::Sha3_384,SHA384_DIGEST_LENGTH},
    {HashType::Sha3_512,SHA512_DIGEST_LENGTH},
};

class CryptographicHash {
public:
    enum class Type : char { Binary, Hex };

    explicit CryptographicHash(HashType hashType);

    ~CryptographicHash();

    //添加数据
    void addData(const std::string &data) const;

    void addData(const char *data, int length) const;

    std::string result(Type type = Type::Hex) const;

private:
    EVP_MD_CTX *m_ctx;
    HashType m_hashType;
};


#endif //CRYPTOGRAPHICHASH_H

#include "CryptographicHash.h"

#include <cassert>

CryptographicHash::CryptographicHash(const HashType hashType) {
    m_hashType = hashType;
    m_ctx = EVP_MD_CTX_new();
    assert(m_ctx);

    int ret = EVP_DigestInit_ex(m_ctx, HashMethods.at(hashType)(),NULL);
    assert(ret == 1);
}

CryptographicHash::~CryptographicHash() {
    if (m_ctx) {
        EVP_MD_CTX_free(m_ctx);
    }
}

void CryptographicHash::addData(const std::string &data) const {
    addData(data.data(), data.size());
}

void CryptographicHash::addData(const char *data, const int length) const {
    const int ret = EVP_DigestUpdate(m_ctx, data, length);
    assert(ret == 1);
}

std::string CryptographicHash::result(const Type type) const {
    unsigned int len = 0;
    unsigned char md[HashLength.at(m_hashType)];
    const int ret = EVP_DigestFinal_ex(m_ctx, md, &len);
    assert(ret == 1);
    
    //在将二进制哈希值转换为十六进制字符串时，二进制数据的每个字节（8 位）都会扩展为 2 个十六进制字符（每个字符 4 位）。
    //md 是包含原始二进制摘要数据的数组，长度为 len 字节。将其转换为十六进制字符串时：
    //md 中每个字节的范围是 0 到 255（0x00 到 0xFF），用十六进制表示时，每个字节正好需要2个字符：
    //因此: 一个字节的最大值是 255，即十六进制的 FF，占两个字符。因此，它是 res[len*2]
    if (type == Type::Hex) {
        char res[len * 2];
        for (int i = 0; i < len; ++i) {
            sprintf(&res[i * 2], "%02x", md[i]);
        }
        return std::string(res, len * 2);
    }
    return std::string(reinterpret_cast<char *>(md), len);
}