#include <iostream>
#include <string>
#include <unordered_map>

// 1. Function Template (Hàm tổng quát hóa)
template <typename T>
T findMax(T a, T b) {
    return (a > b) ? a : b;
}

// 2. Class Template (Lớp tổng quát hóa)
template <typename K, typename V>
class SimpleCache {
private:
    std::unordered_map<K, V> cacheMap;
public:
    void put(K key, V val) {
        cacheMap[key] = val;
    }

    V get(K key) {
        if (cacheMap.find(key) != cacheMap.end()) {
            return cacheMap[key];
        }
        return V(); // Trả về giá trị mặc định của kiểu V
    }

    bool exists(K key) {
        return cacheMap.find(key) != cacheMap.end();
    }
};

int main() {
    // Chạy thử nghiệm Function Template
    std::cout << "--- Demo Function Template ---" << std::endl;
    std::cout << "So lon hon giua 5 va 10: " << findMax(5, 10) << std::endl;
    std::cout << "So lon hon giua 3.14 va 2.71: " << findMax(3.14, 2.71) << std::endl;
    std::cout << "Chuoi lon hon: " << findMax(std::string("V8"), std::string("SpiderMonkey")) << std::endl;

    // Chạy thử nghiệm Class Template (Hệ thống Cache)
    std::cout << "\n--- Demo Class Template (Cache System) ---" << std::endl;
    SimpleCache<std::string, std::string> dnsCache;
    dnsCache.put("js-tools.org", "104.21.43.120");
    dnsCache.put("google.com", "142.250.190.46");

    std::string domain = "js-tools.org";
    if (dnsCache.exists(domain)) {
        std::cout << "IP cua " << domain << " la: " << dnsCache.get(domain) << std::endl;
    }

    return 0;
}

// Template chung (Primary Template)
template <typename T>
class Storage {
public:
    void save(T value) {
        std::cout << "Lưu trữ generic: " << value << std::endl;
    }
};

// Full Specialization cho kiểu bool
template <>
class Storage<bool> {
private:
    uint8_t bitField = 0;  // Sử dụng 8 bit để lưu tối đa 8 giá trị bool
public:
    void save(bool value) {
        std::cout << "Lưu trữ bool tối ưu hóa (bit packing): " << (value ? "true" : "false") << std::endl;
    }
};

// Full Specialization cho con trỏ
template <typename T>
class Storage<T*> {  // Đây là Partial Specialization (chuyên hóa riêng phần)
public:
    void save(T* ptr) {
        std::cout << "Lưu trữ con trỏ tới: " << typeid(T).name() << std::endl;
    }
};

int main() {
    Storage<int> intStorage;
    intStorage.save(42);  // Dùng template chung

    Storage<bool> boolStorage;
    boolStorage.save(true);  // Dùng full specialization

    Storage<double*> ptrStorage;
    ptrStorage.save(nullptr);  // Dùng partial specialization

    return 0;
}

// Template chung cho tất cả kiểu dữ liệu
template <typename T>
class PrintType {
public:
    void info() {
        std::cout << "Kiểu thường: " << typeid(T).name() << std::endl;
    }
};

// Partial Specialization cho mảng T[]
template <typename T, size_t N>
class PrintType<T[N]> {
public:
    void info() {
        std::cout << "Mảng của " << typeid(T).name() << " với " << N << " phần tử" << std::endl;
    }
};

// Partial Specialization cho hàm con trỏ
template <typename R, typename... Args>
class PrintType<R(*)(Args...)> {
public:
    void info() {
        std::cout << "Con trỏ tới hàm trả về: " << typeid(R).name() << std::endl;
    }
};

int main() {
    PrintType<int> t1;
    t1.info();  // Kiểu thường

    PrintType<float[10]> t2;
    t2.info();  // Mảng

    int (*funcPtr)(int) = nullptr;
    PrintType<decltype(funcPtr)> t3;
    t3.info();  // Con trỏ hàm

    return 0;
}

#include <iostream>
#include <type_traits>

// Phiên bản chung cho tất cả kiểu (mặc định)
template <typename T>
void process(T value, typename std::enable_if<!std::is_pointer<T>::value>::type* = nullptr) {
    std::cout << "Xử lý giá trị: " << value << std::endl;
}

// Phiên bản chuyên biệt cho con trỏ (SFINAE loại bỏ phiên bản chung)
template <typename T>
void process(T ptr, typename std::enable_if<std::is_pointer<T>::value>::type* = nullptr) {
    std::cout << "Xử lý con trỏ: " << ptr << std::endl;
}

int main() {
    int x = 42;
    process(x);           // Gọi phiên bản đầu tiên

    int* ptr = &x;
    process(ptr);         // Gọi phiên bản thứ hai

    return 0;
}

#include <iostream>
#include <type_traits>

// Chỉ tính tổng với kiểu số học
template <typename T>
typename std::enable_if<std::is_arithmetic<T>::value, T>::type
sum(T a, T b) {
    return a + b;
}

// Chỉ hiển thị tên kiểu cho con trỏ
template <typename T>
typename std::enable_if<std::is_pointer<T>::value>::type
printInfo(T ptr) {
    std::cout << "Con trỏ kiểu: " << typeid(T).name() << std::endl;
}

int main() {
    std::cout << sum(3, 4) << std::endl;         // OK: int là kiểu số học
    std::cout << sum(3.14, 2.71) << std::endl;   // OK: double là kiểu số học
    // sum("hello", "world");                        // Lỗi compile: string không phải số học

    int x = 10;
    printInfo(&x);                                  // OK: &x là con trỏ
    // printInfo(x);                                  // Lỗi compile: x không phải con trỏ

    return 0;
}

#include <iostream>

// Base case: không có tham số
void print() {
    std::cout << std::endl;
}

// Recursive case: tách tham số đầu tiên, xử lý nó, sau đó gọi lại với phần còn lại
template <typename T, typename... Args>
void print(T first, Args... rest) {
    std::cout << first << " ";
    print(rest...);  // Gọi đệ quy với các tham số còn lại
}

int main() {
    print(1, 2.5, "hello", true);  // In: 1 2.5 hello 1
    // (true được in thành 1 vì std::cout mặc định in bool dưới dạng số)

    return 0;
}

#include <iostream>

// Cộng tất cả tham số (fold expression với +)
template <typename... Args>
int sum(Args... args) {
    return (... + args);  // Unary left fold: 1 + 2 + 3 + 4 = 10
}

// In tất cả tham số (fold expression với dấu phẩy)
template <typename... Args>
void printAll(Args... args) {
    ((std::cout << args << " "), ...);  // Print từng phần tử
    std::cout << std::endl;
}

int main() {
    std::cout << sum(1, 2, 3, 4) << std::endl;     // In: 10
    printAll(10, 20, 30, "hello");                  // In: 10 20 30 hello

    return 0;
}

#include <iostream>
#include <concepts>

// Định nghĩa một concept: kiểu T phải có thể cộng với chính nó
template <typename T>
concept Addable = requires(T a, T b) {
    { a + b } -> std::convertible_to<T>;
};

// Hàm chỉ hoạt động với kiểu thỏa mãn concept Addable
template <Addable T>
T add(T a, T b) {
    return a + b;
}

// Concept cho các kiểu có iterator
template <typename T>
concept Iterable = requires(T t) {
    t.begin();
    t.end();
};

template <Iterable T>
void printContainer(T container) {
    for (auto element : container) {
        std::cout << element << " ";
    }
    std::cout << std::endl;
}

int main() {
    std::cout << add(5, 3) << std::endl;           // OK: 8
    std::cout << add(2.5, 3.5) << std::endl;       // OK: 6.0

    std::vector<int> vec = {1, 2, 3};
    printContainer(vec);                           // OK: 1 2 3

    // add("hello", "world");                         // Lỗi compile: string + string không trả về string
    // printContainer(42);                            // Lỗi compile: int không có begin()/end()

    return 0;
}

#include <iostream>

// Template recursion để tính Fibonacci tại compile-time
template <int N>
struct Fibonacci {
    static constexpr int value = Fibonacci<N-1>::value + Fibonacci<N-2>::value;
};

// Base cases
template <>
struct Fibonacci<0> {
    static constexpr int value = 0;
};

template <>
struct Fibonacci<1> {
    static constexpr int value = 1;
};

int main() {
    // Tất cả những tính toán này xảy ra tại compile-time, không có chi phí runtime
    std::cout << "Fibonacci(5) = " << Fibonacci<5>::value << std::endl;     // 5
    std::cout << "Fibonacci(10) = " << Fibonacci<10>::value << std::endl;   // 55
    std::cout << "Fibonacci(15) = " << Fibonacci<15>::value << std::endl;   // 610

    return 0;
}