/* Main src */
 
#include <iostream>
#include <vector>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <list>
#include <deque>
#include <array>
#include <memory>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <functional>
#include <algorithm>
#include <tuple>
#include <string>
#include <chrono>
#include <type_traits>
#include <exception>
#include <cstdio> // For printf
 
#define MY_ASSERT(condition, message) \
    do { \
        if (!(condition)) { \
            std::cerr << "Assertion failed: " << (message) << std::endl; \
            std::exit(EXIT_FAILURE); \
        } \
    } while (false)
 
// Class template
template <typename T>
class MyClass {
public:
    explicit MyClass(T value) : value_(value) {}
    T getValue() const { return value_; }
 
private:
    T value_;
};
 
// Enum class
enum class Color { Red, Green, Blue };
 
// Struct
struct Point {
    int x;
    int y;
 
    void print() const {
        printf("Point(%d, %d)\n", x, y);
    }
};
 
// Struct with constructor and method
struct Rectangle {
    int width;
    int height;
 
    Rectangle(int w, int h) : width(w), height(h) {}
 
    int area() const {
        return width * height;
    }
};
 
// Anonymous struct
struct {
    int a;
    double b;
} anonymousStruct;
 
// Union
union Number {
    int intValue;
    float floatValue;
    double doubleValue;
};
 
// // Anonymous union
// union {
//     int intAnon;
//     float floatAnon;
// };
 
// Ordinary class
class OrdinaryClass {
public:
    // Default constructor
    OrdinaryClass() noexcept : data_(0) {
        printf("OrdinaryClass Default Constructor\n");
    }
 
    // Parameterized constructor
    OrdinaryClass(int data) noexcept : data_(data) {
        printf("OrdinaryClass Parameterized Constructor\n");
    }
 
    // Copy constructor
    OrdinaryClass(const OrdinaryClass& other) noexcept : data_(other.data_) {
        printf("OrdinaryClass Copy Constructor\n");
    }
 
    // Move constructor
    OrdinaryClass(OrdinaryClass&& other) noexcept : data_(other.data_) {
        other.data_ = 0;
        printf("OrdinaryClass Move Constructor\n");
    }
 
    // Copy assignment operator
    OrdinaryClass& operator=(const OrdinaryClass& other) noexcept {
        if (this != &other) {
            data_ = other.data_;
            printf("OrdinaryClass Copy Assignment\n");
        }
        return *this;
    }
 
    // Move assignment operator
    OrdinaryClass& operator=(OrdinaryClass&& other) noexcept {
        if (this != &other) {
            data_ = other.data_;
            other.data_ = 0;
            printf("OrdinaryClass Move Assignment\n");
        }
        return *this;
    }
 
    // Destructor
    ~OrdinaryClass() noexcept {
        printf("OrdinaryClass Destructor\n");
    }
 
    // Member function, does not throw
    void display() const noexcept {
        printf("OrdinaryClass data: %d\n", data_);
    }
 
    // Member function, may throw an exception
    void riskyOperation(bool shouldThrow) {
        if (shouldThrow) {
            throw std::runtime_error("An error occurred in riskyOperation");
        }
        printf("riskyOperation completed successfully\n");
    }
 
private:
    int data_;
};
 
class Complex {
public:
    Complex(double r, double i) : real(r), imag(i) {}
 
    // 重载 + 运算符
    Complex operator+(const Complex& other) const {
        return Complex(real + other.real, imag + other.imag);
    }
 
    void display() const {
        std::cout << real << " + " << imag << "i" << std::endl;
    }
 
private:
    double real;
    double imag;
};
 
void outer_function_with_lambda() {
    // callable lambda
    auto inner_function = []() {
        return "Hello from inner function!";
    };
 
    std::cout << inner_function() << std::endl; // call lambda
}
 
int getInteger1() {
    return 42;
}
 
int getInteger2() {
    return (int)((long)((int)42));
}
 
float getFloat() {
    return 3.14f * 2;
}
 
std::string getString() {
    return "Hello, " + std::string("World!");
}
 
typedef int (*FunctionPointer)();
 
struct OneStruct {
    int x;
    float y;
};
 
enum OneEnum {
    ENUM_VALUE_1,
    ENUM_VALUE_2
};
 
union OneUnion {
    int i;
    float f;
};
 
class OneClass {
public:
    std::string name;
    OneClass(std::string n) : name(n) {}
    void display() const {
        std::cout << "Class name: " << name << std::endl;
    }
};
 
int* getIntPointer() {
    static int value = 10;
    return &value;
}
 
int& getIntReference() {
    static int value = 20;
    return value;
}
 
int sampleFunction() {
    return 42;
}
 
FunctionPointer getFunctionPointer() {
    return &sampleFunction;
}
 
FunctionPointer& getFunctionPointerReference() {
    static FunctionPointer fp = &sampleFunction;
    return fp;
}
 
OneStruct getStruct() {
    return {5, 3.14f};
}
 
OneStruct& getStructReference() {
    static OneStruct s = {7, 2.71f};
    return s;
}
 
OneStruct* getStructPointer() {
    static OneStruct s = {7, 2.71f};
    return &s;
}
 
OneEnum getEnum() {
    return ENUM_VALUE_1;
}
 
OneEnum& getEnumReference() {
    static OneEnum e = ENUM_VALUE_2;
    return e;
}
 
OneEnum* getEnumPointer() {
    static OneEnum e = ENUM_VALUE_2;
    return &e;
}
 
OneUnion getUnion() {
    OneUnion u;
    u.i = 100;
    return u;
}
 
OneUnion& getUnionReference() {
    static OneUnion u;
    u.f = 1.23f;
    return u;
}
 
OneUnion* getUnionPointer() {
    static OneUnion u;
    u.f = 1.23f;
    return &u;
}
 
OneClass getClassObject() {
    return OneClass("OneClassInstance");
}
 
OneClass& getClassObjectReference() {
    static OneClass obj("OneClassReferenceInstance");
    return obj;
}
 
OneClass* getClassObjectPointer() {
    static OneClass obj("OneClassPointerInstance");
    return &obj;
}
 
class AnotherClass {
public:
    AnotherClass(int value) : data(value) {
        std::cout << "AnotherClass constructor called with value: " << data << std::endl;
    }
 
    ~AnotherClass() {
        std::cout << "AnotherClass destructor called for value: " << data << std::endl;
    }
 
    void display() const {
        std::cout << "AnotherClass object value: " << data << std::endl;
    }
 
private:
    int data;
};
 
std::unique_ptr<AnotherClass> createUniquePtr(int value) {
    return std::make_unique<AnotherClass>(value);
}
 
std::unique_ptr<AnotherClass> createUniquePtrWithNew(int value) {
    return std::unique_ptr<AnotherClass>(new AnotherClass(value));
}
 
int main() {
    std::unique_ptr<AnotherClass> ptr = createUniquePtr(100);
 
    ptr->display();
 
    std::unique_ptr<AnotherClass> ptr2 = createUniquePtrWithNew(200);
 
    ptr2->display();
 
    int* intPtr = getIntPointer();
    std::cout << "Integer pointer value: " << *intPtr << std::endl;
 
    int& intRef = getIntReference();
    std::cout << "Integer reference value: " << intRef << std::endl;
 
    FunctionPointer funcPtr = getFunctionPointer();
    std::cout << "Function pointer result: " << funcPtr() << std::endl;
 
    FunctionPointer& funcPtrRef = getFunctionPointerReference();
    std::cout << "Function pointer reference result: " << funcPtrRef() << std::endl;
 
    OneStruct s = getStruct();
    std::cout << "Struct values: x = " << s.x << ", y = " << s.y << std::endl;
 
    OneStruct& sRef = getStructReference();
    std::cout << "Struct reference values: x = " << sRef.x << ", y = " << sRef.y << std::endl;
 
    OneStruct* sPtr = getStructPointer();
    std::cout << "Struct pointer values: x = " << sPtr->x << ", y = " << sPtr->y << std::endl;
 
    OneEnum e = getEnum();
    std::cout << "Enum value: " << e << std::endl;
 
    OneEnum& eRef = getEnumReference();
    std::cout << "Enum reference value: " << eRef << std::endl;
 
    OneEnum* ePtr = getEnumPointer();
    std::cout << "Enum pointer value: " << *ePtr << std::endl;
 
    OneUnion u = getUnion();
    std::cout << "Union value (int): " << u.i << std::endl;
 
    OneUnion& uRef = getUnionReference();
    std::cout << "Union reference value (float): " << uRef.f << std::endl;
 
    OneUnion* uPtr = getUnionPointer();
    std::cout << "Union pointer value (float): " << uPtr->f << std::endl;
 
    OneClass obj = getClassObject();
    obj.display();
 
    OneClass& objRef = getClassObjectReference();
    objRef.display();
 
    OneClass* objPtr = getClassObjectPointer();
    objPtr->display();
 
    // Basic data types
    int noInit;
    int a = 10;
    double b = 5.5;
    char c = 'c';
    bool flag = true;
    std::string str = "Hello, C++11!";
 
    // Printing basic data types
    printf("int: %d\n", noInit); // The value of noInit is ramdom
    printf("int: %d\n", a);
    printf("double: %.2f\n", b);
    printf("char: %c\n", c);
    printf("bool: %s\n", flag ? "true" : "false");
    printf("string: %s\n", str.c_str());
 
    int choice = 2;
    int count = 0;
 
    // do-while
    do {
        // std::cout << "Enter a number between 1 and 3 (0 to exit): ";
        // std::cin >> choice;
 
        // switch
        switch (choice) {
            case 1:
                std::cout << "You chose option 1.\n";
                break;
            case 2:
                std::cout << "You chose option 2.\n";
                break;
            case 3:
                std::cout << "You chose option 3.\n";
                break;
            case 0:
                std::cout << "Exiting...\n";
                break;
            default:
                std::cout << "Invalid choice, please try again.\n";
                break;
        }
 
        count++;
 
    } while (choice != 2);
 
    std::cout << "\nYou made " << count << " choices.\n";
 
    while (count < 5) {
        std::cout << "Count is less than 5, current count: " << count << std::endl;
        count++;
    }
 
    std::cout << "Final count is " << count << ".\n";
 
    int x = 2;
    MY_ASSERT(x == 2, "x should be 2");
    std::unordered_map<int, int> switchMap = {
        {1, 10},
        {2, 20},
        {3, 30}
    };
 
    int result = switchMap.count(x) ? switchMap[x] : -1;
    std::cout << "Result: " << result << std::endl;
 
    bool go = false;
    while (go) {
        throw "An Exception won't be thrown:)";
    }
 
    while (go)
        while (go)
            while (go)
                throw "An Exception won't be thrown:)";
 
    do {
        std::cout << "in block of do while" << count << std::endl;
    } while (1 == 2);
 
    do
        do
            do
                std::cout << "in do while without block" << count << std::endl;
            while (1 == 2);
        while (1 == 2);
    while (1 == 2);
 
    if (go) {
        throw "An Exception won't be thrown:)";
    }
 
    if (go)
        if (go)
            if (go)
                throw "An Exception won't be thrown:)";
            else if (1 == 3)
                std::cout << "it is else if branch" << std::endl;
            else
                if (2 == 2)
                    std::cout << "it is anothre if in else branch" << std::endl;
                else
                    std::cout << "it is else branch" << std::endl;
 
    for (int i = 1; i < 5; i++) {
        if (i == 3) {
            break;
        } else if (i == 2){
            continue;
        }
 
        std::cout << "in for, i:" << i << std::endl;
    }
 
    for (int i = 1; i < 3; i++)
        for (int j = 1; j < 2; j++)
            for (int k = 1; k < 2; k++)
                std::cout << "in for, i:" << i << ", j:" << j << ", k:" << k << std::endl;
 
    // ----- again
 
    while (go) {
        throw "An Exception won't be thrown:)";
    }
 
    while (go)
        while (go)
            while (go)
                throw "An Exception won't be thrown:)";
 
    do {
        std::cout << "in block of do while" << count << std::endl;
    } while (1 == 2);
 
    do
        do
            do
                std::cout << "in do while without block" << count << std::endl;
            while (1 == 2);
        while (1 == 2);
    while (1 == 2);
 
    if (go) {
        throw "An Exception won't be thrown:)";
    }
 
    if (go)
        if (go)
            if (go)
                throw "An Exception won't be thrown:)";
            else if (1 == 3)
                std::cout << "it is else if branch" << std::endl;
            else
                if (2 == 2)
                    std::cout << "it is anothre if in else branch" << std::endl;
                else
                    std::cout << "it is else branch" << std::endl;
 
    for (int i = 1; i < 5; i++) {
        if (i == 3) {
            break;
        } else if (i == 2){
            continue;
        }
 
        std::cout << "in for, i:" << i << std::endl;
    }
 
    for (int i = 1; i < 3; i++)
        for (int j = 1; j < 2; j++)
            for (int k = 1; k < 2; k++)
                std::cout << "in for, i:" << i << ", j:" << j << ", k:" << k << std::endl;
 
    // STL containers
    std::vector<int> vec = {1, 2, 3, 4, 5};
    std::map<int, std::string> map = {{1, "one"}, {2, "two"}};
    std::set<int> set = {1, 2, 3};
    std::unordered_map<int, std::string> umap = {{1, "one"}, {2, "two"}};
    std::unordered_set<int> uset = {1, 2, 3};
    std::list<int> lst = {1, 2, 3};
    std::deque<int> deq = {1, 2, 3};
    std::array<int, 3> arr = {1, 2, 3};
    std::tuple<int, double, std::string> tup = std::make_tuple(1, 2.0, "tuple");
 
    // print("msg from print\n"); // print is not a valid function here
    printf("msg from printf\n");
    std::cout << "msg from std::cout" << std::endl;
    std::cerr << "msg from std::cerr" << std::endl;
    std::clog << "msg from std::clog" << std::endl;
 
    // Printing STL containers
    printf("vector: ");
    for (int i : vec) printf("%d ", i);
    printf("\n");
 
    printf("map: ");
    for (const auto& [key, value] : map) printf("{%d: %s} ", key, value.c_str());
    printf("\n");
 
    printf("set: ");
    for (int i : set) printf("%d ", i);
    printf("\n");
 
    printf("unordered_map: ");
    for (const auto& [key, value] : umap) printf("{%d: %s} ", key, value.c_str());
    printf("\n");
 
    printf("unordered_set: ");
    for (int i : uset) printf("%d ", i);
    printf("\n");
 
    printf("list: ");
    for (int i : lst) printf("%d ", i);
    printf("\n");
 
    printf("deque: ");
    for (int i : deq) printf("%d ", i);
    printf("\n");
 
    printf("array: ");
    for (int i : arr) printf("%d ", i);
    printf("\n");
 
    printf("tuple: { %d, %.2f, %s }\n", std::get<0>(tup), std::get<1>(tup), std::get<2>(tup).c_str());
 
    // Smart pointers
    std::unique_ptr<int> uptr = std::make_unique<int>(10);
    std::shared_ptr<int> sptr = std::make_shared<int>(20);
 
    // Printing smart pointers
    printf("unique_ptr: %d\n", *uptr);
    printf("shared_ptr: %d\n", *sptr);
 
    // Condition variable and mutex
    std::mutex mtx;
    std::condition_variable cv;
    int ready = 0;
 
    std::thread t1([&]() {
        std::lock_guard<std::mutex> lock(mtx);
        ready = 1;
        cv.notify_one();
    });
 
    std::thread t2([&]() {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, [&] { return ready == 1; });
        printf("Thread 2 is running\n");
    });
 
    t1.join();
    t2.join();
 
    // Using enum class
    Color color = Color::Red;
    if (color == Color::Red) {
        printf("Color is red\n");
    }
 
    // Using lambda expression
    outer_function_with_lambda();
 
    auto add_lambda = [](int a, int b) { return a + b; };
    int res = add_lambda(3, 4);
    printf("Lambda result: %d\n", res);
 
    auto lambdaWithError = []() {
        throw std::runtime_error("An error occurred in lambda!");
    };
 
    try {
        lambdaWithError();
    } catch (const std::exception& e) {
        std::cout << "Caught exception: " << e.what() << std::endl;
    }
 
    // Using function template
    auto add = [](auto a, auto b) -> decltype(a + b) { return a + b; };
    printf("Template add result: %.2f\n", add(1.5, 2.5));
 
    // Static assertion
    static_assert(sizeof(int) >= 4, "int is too small!");
 
    // Using custom template class
    MyClass<int> myClass(100);
    printf("MyClass value: %d\n", myClass.getValue());
 
    // Using struct
    Point p = {3, 4};
    p.print();
 
    Rectangle rect(10, 5);
    printf("Rectangle area: %d\n", rect.area());
 
    // Using anonymous struct
    anonymousStruct.a = 5;
    anonymousStruct.b = 10.5;
    printf("AnonymousStruct a: %d, b: %.2f\n", anonymousStruct.a, anonymousStruct.b);
 
    // Using union
    Number num;
    num.intValue = 10;
    printf("Union intValue: %d\n", num.intValue);
 
    num.floatValue = 3.14f;
    printf("Union floatValue: %.2f\n", num.floatValue);
 
    // // Using anonymous union
    // intAnon = 42;
    // printf("AnonymousUnion intAnon: %d\n", intAnon);
 
    // floatAnon = 2.71f;
    // printf("AnonymousUnion floatAnon: %.2f\n", floatAnon);
 
    printf("----------------------------------------\n");
 
    // Using ordinary class
    printf("Creating OrdinaryClass instances...\n");
 
    // Default constructor
    OrdinaryClass obj1;
    obj1.display();
 
    // Parameterized constructor
    OrdinaryClass obj2(50);
    obj2.display();
 
    // Copy constructor
    OrdinaryClass obj3 = obj2;
    obj3.display();
 
    // Move constructor
    OrdinaryClass obj4 = std::move(obj3);
    obj4.display();
    obj3.display(); // obj3 data has been moved
 
    // Copy assignment
    obj1 = obj2;
    obj1.display();
 
    // Move assignment
    obj1 = std::move(obj4);
    obj1.display();
    obj4.display(); // obj4 data has been moved
 
    // user class Complex
    Complex c1(3.0, 4.0);
    Complex c2(1.0, 2.0);
    Complex c3 = c1 + c2;
    c3.display();  // Output: 4 + 6i
 
    // Exception handling with the riskyOperation method
    try {
        obj2.riskyOperation(false); // This should not throw
        obj2.riskyOperation(true);  // This should throw
    } catch (const std::exception& e) {
        printf("Caught exception: %s\n", e.what());
    }
 
    printf("Exiting main...\n");
    return 0;
}