template<typename T>
T max(T a, T b) {
    return (a > b) ? a : b;
}

template<typename T, int size>
class Array {
private:
    T elements[size];
public:
    T& operator[](int index) {
        return elements[index];
    }
};

// محاسبه فاکتوریل در کامپایل زمان
template<int N>
struct Factorial {
    static const int value = N * Factorial<N-1>::value;
};

template<>
struct Factorial<0> {
    static const int value = 1;
};

class Singleton {
private:
    static Singleton* instance;
    Singleton() {} // سازنده خصوصی
    
public:
    static Singleton* getInstance() {
        if (!instance) {
            instance = new Singleton();
        }
        return instance;
    }
    
    // جلوگیری از کپی
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
};

class Product {
public:
    virtual void operation() = 0;
    virtual ~Product() {}
};

class ConcreteProductA : public Product {
public:
    void operation() override {
        // پیاده‌سازی عملیات
    }
};

class Creator {
public:
    virtual Product* createProduct() = 0;
    virtual ~Creator() {}
};

#include <memory>

class Resource {
public:
    Resource() { /* تخصیص منابع */ }
    ~Resource() { /* آزادسازی منابع */ }
};

void function() {
    std::unique_ptr<Resource> ptr(new Resource());
    // حافظه به صورت خودکار آزاد می‌شود
    std::unique_ptr<Resource[]> array(new Resource[10]);
}

#include <memory>

class Node {
public:
    std::shared_ptr<Node> next;
    std::weak_ptr<Node> previous; // برای شکستن حلقه‌های مرجع
    
    ~Node() {
        // destructor
    }
};

void sharedPointerExample() {
    std::shared_ptr<Node> node1 = std::make_shared<Node>();
    std::shared_ptr<Node> node2 = std::make_shared<Node>();
    
    node1->next = node2;
    node2->previous = node1;
}

class Vector {
private:
    int* data;
    size_t size;
    
public:
    // سازنده انتقال
    Vector(Vector&& other) noexcept 
        : data(other.data), size(other.size) {
        other.data = nullptr;
        other.size = 0;
    }
    
    // عملگر انتساب انتقال
    Vector& operator=(Vector&& other) noexcept {
        if (this != &other) {
            delete[] data;
            data = other.data;
            size = other.size;
            other.data = nullptr;
            other.size = 0;
        }
        return *this;
    }
    
    ~Vector() {
        delete[] data;
    }
};

#include <iostream>
#include <thread>
#include <vector>

void worker(int id) {
    std::cout << "Thread " << id << " is working\n";
}

int main() {
    std::vector<std::thread> threads;
    
    for (int i = 0; i < 5; ++i) {
        threads.emplace_back(worker, i);
    }
    
    for (auto& t : threads) {
        t.join();
    }
    
    return 0;
}

#include <mutex>
#include <thread>

std::mutex mtx;
int shared_data = 0;

void increment() {
    for (int i = 0; i < 100000; ++i) {
        std::lock_guard<std::mutex> lock(mtx);
        ++shared_data;
    }
}

#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>

template<typename T>
class ThreadSafeQueue {
private:
    std::queue<T> queue;
    std::mutex mtx;
    std::condition_variable cond;
    
public:
    void push(T value) {
        std::lock_guard<std::mutex> lock(mtx);
        queue.push(std::move(value));
        cond.notify_one();
    }
    
    T pop() {
        std::unique_lock<std::mutex> lock(mtx);
        cond.wait(lock, [this] { return !queue.empty(); });
        T value = std::move(queue.front());
        queue.pop();
        return value;
    }
};

struct alignas(64) CacheLineAligned {
    int data[16]; // هر cache line معمولاً 64 بایت است
};

#include <immintrin.h> // برای دستورات AVX

void vectorAdd(float* a, float* b, float* c, int n) {
    for (int i = 0; i < n; i += 8) {
        __m256 va = _mm256_load_ps(&a[i]);
        __m256 vb = _mm256_load_ps(&b[i]);
        __m256 vc = _mm256_add_ps(va, vb);
        _mm256_store_ps(&c[i], vc);
    }
}

template<typename T>
class ObjectPool {
private:
    std::vector<T*> pool;
    std::vector<T*> used;
    
public:
    T* acquire() {
        if (pool.empty()) {
            pool.push_back(new T());
        }
        T* obj = pool.back();
        pool.pop_back();
        used.push_back(obj);
        return obj;
    }
    
    void release(T* obj) {
        // بازنشانی وضعیت آبجکت
        pool.push_back(obj);
    }
};

class Character {
private:
    char symbol;
    int fontSize;
    std::string fontFace;
    // سایر خصوصیات ذاتی
    
public:
    void render(int positionX, int positionY) {
        // رندر کردن کاراکتر
    }
};

class CharacterFactory {
private:
    std::map<char, Character*> characters;
    
public:
    Character* getCharacter(char c) {
        if (characters.find(c) == characters.end()) {
            characters[c] = new Character(c);
        }
        return characters[c];
    }
};

class SafeBuffer {
private:
    std::vector<char> buffer;
    
public:
    SafeBuffer(size_t size) : buffer(size) {}
    
    void copyData(const char* source, size_t length) {
        if (length > buffer.size()) {
            throw std::runtime_error("Buffer overflow prevented");
        }
        std::memcpy(buffer.data(), source, length);
    }
};

#include <string>

class SecureString {
private:
    std::string data;
    
public:
    SecureString(const std::string& str) : data(str) {}
    
    ~SecureString() {
        // پاک‌سازی حافظه
        std::fill(data.begin(), data.end(), '\0');
    }
    
    // جلوگیری از کپی‌های غیرضروری
    SecureString(const SecureString&) = delete;
    SecureString& operator=(const SecureString&) = delete;
    
    // فقط اجازه انتقال
    SecureString(SecureString&&) = default;
    SecureString& operator=(SecureString&&) = default;
};

class Component {
public:
    virtual void update(float deltaTime) = 0;
    virtual ~Component() {}
};

class GameObject {
private:
    std::vector<std::unique_ptr<Component>> components;
    
public:
    template<typename T, typename... Args>
    T* addComponent(Args&&... args) {
        auto component = std::make_unique<T>(std::forward<Args>(args)...);
        T* rawPtr = component.get();
        components.push_back(std::move(component));
        return rawPtr;
    }
    
    void update(float deltaTime) {
        for (auto& component : components) {
            component->update(deltaTime);
        }
    }
};

#include <functional>
#include <map>
#include <vector>

class EventSystem {
private:
    std::map<std::string, std::vector<std::function<void()>>> listeners;
    
public:
    void subscribe(const std::string& eventName, 
                   std::function<void()> callback) {
        listeners[eventName].push_back(callback);
    }
    
    void emit(const std::string& eventName) {
        if (listeners.find(eventName) != listeners.end()) {
            for (auto& callback : listeners[eventName]) {
                callback();
            }
        }
    }
};

cmake_minimum_required(VERSION 3.10)
project(MyProject)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# تشخیص سیستم عامل
if(WIN32)
    add_definitions(-DWINDOWS_PLATFORM)
elseif(UNIX)
    add_definitions(-DLINUX_PLATFORM)
endif()

# کتابخانه‌های وابسته
find_package(OpenGL REQUIRED)
find_package(GLFW3 REQUIRED)

# هدف اصلی
add_executable(main_app 
    src/main.cpp
    src/utils.cpp
    src/renderer.cpp
)

target_link_libraries(main_app 
    ${OPENGL_LIBRARIES}
    glfw
)

# تست‌ها
enable_testing()
add_subdirectory(tests)

// خوب
std::vector<int> processData(const std::vector<int>& input) {
    std::vector<int> result;
    result.reserve(input.size());
    
    for (const auto& value : input) {
        if (isValid(value)) {
            result.push_back(transform(value));
        }
    }
    
    return result;
}

// بد
int* processData(int* input, int size) {
    int* result = new int[size];
    for (int i = 0; i < size; i++) {
        if (isValid(input[i])) {
            result[i] = transform(input[i]);
        }
    }
    return result; // مسئولیت آزادسازی بر عهده caller
}

template<typename T>
concept Arithmetic = std::is_arithmetic_v<T>;

template<Arithmetic T>
T square(T x) {
    return x * x;
}

// فقط برای انواع عددی کار می‌کند
auto result1 = square(5);      // OK
auto result2 = square(3.14);   // OK
// auto result3 = square("text"); // خطای کامپایل

#include <cstdlib>
#include <new>
#include <iostream>

class CustomAllocator {
private:
    static const size_t POOL_SIZE = 1024 * 1024; // 1MB
    char memoryPool[POOL_SIZE];
    size_t currentOffset;
    
public:
    CustomAllocator() : currentOffset(0) {}
    
    void* allocate(size_t size, size_t alignment = alignof(std::max_align_t)) {
        // محاسبه آدرس هم‌تراز شده
        uintptr_t ptr = reinterpret_cast<uintptr_t>(memoryPool + currentOffset);
        size_t space = POOL_SIZE - currentOffset;
        
        if (std::align(alignment, size, reinterpret_cast<void*&>(ptr), space)) {
            currentOffset = (ptr - reinterpret_cast<uintptr_t>(memoryPool)) + size;
            return reinterpret_cast<void*>(ptr);
        }
        
        throw std::bad_alloc();
    }
    
    void deallocate(void* ptr) {
        // در این پیاده‌سازی ساده، آزادسازی انجام نمی‌شود
        // (allocator خطی)
    }
};

#include <sys/mman.h>
#include <unistd.h>

class MemoryPageManager {
private:
    static const size_t PAGE_SIZE = 4096;
    
public:
    void* allocatePage() {
        void* page = mmap(nullptr, PAGE_SIZE, 
                         PROT_READ | PROT_WRITE,
                         MAP_PRIVATE | MAP_ANONYMOUS, 
                         -1, 0);
        
        if (page == MAP_FAILED) {
            throw std::bad_alloc();
        }
        
        return page;
    }
    
    void freePage(void* page) {
        munmap(page, PAGE_SIZE);
    }
};

#include <cstdint>

class DeviceController {
private:
    volatile uint32_t* const deviceRegister;
    
public:
    DeviceController(uintptr_t baseAddress) 
        : deviceRegister(reinterpret_cast<uint32_t*>(baseAddress)) {}
    
    void writeRegister(uint32_t offset, uint32_t value) {
        // ممانعت از بهینه‌سازی توسط کامپایلر
        volatile uint32_t* reg = deviceRegister + offset;
        *reg = value;
        
        // Memory barrier برای اطمینان از نوشتن
        asm volatile("" ::: "memory");
    }
    
    uint32_t readRegister(uint32_t offset) {
        volatile uint32_t* reg = deviceRegister + offset;
        uint32_t value = *reg;
        
        // Memory barrier برای اطمینان از خواندن
        asm volatile("" ::: "memory");
        return value;
    }
};

// محاسبه توان در کامپایل زمان
template<int Base, int Exp>
struct Power {
    static const long long value = Base * Power<Base, Exp-1>::value;
};

template<int Base>
struct Power<Base, 0> {
    static const long long value = 1;
};

// استفاده
constexpr long long result = Power<2, 10>::value; // 1024

template<bool Condition, typename TrueType, typename FalseType>
struct Conditional {
    using type = TrueType;
};

template<typename TrueType, typename FalseType>
struct Conditional<false, TrueType, FalseType> {
    using type = FalseType;
};

// مثال استفاده
template<typename T>
struct TypeInfo {
    using SignedType = typename Conditional<
        std::is_signed<T>::value,
        T,
        typename std::make_signed<T>::type
    >::type;
};

constexpr int fibonacci(int n) {
    if (n <= 1) return n;
    return fibonacci(n-1) + fibonacci(n-2);
}

// محاسبه در کامپایل زمان
constexpr int fib10 = fibonacci(10);

// استفاده در آرایه با اندازه ثابت
std::array<int, fibonacci(10)> fibArray;

#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <stdexcept>

class TCPSocket {
private:
    int socketFd;
    
public:
    TCPSocket() : socketFd(-1) {}
    
    void connect(const std::string& host, uint16_t port) {
        socketFd = socket(AF_INET, SOCK_STREAM, 0);
        if (socketFd < 0) {
            throw std::runtime_error("Socket creation failed");
        }
        
        sockaddr_in serverAddr{};
        serverAddr.sin_family = AF_INET;
        serverAddr.sin_port = htons(port);
        
        // تبدیل آدرس
        if (inet_pton(AF_INET, host.c_str(), &serverAddr.sin_addr) <= 0) {
            close(socketFd);
            throw std::runtime_error("Invalid address");
        }
        
        if (::connect(socketFd, 
                     reinterpret_cast<sockaddr*>(&serverAddr), 
                     sizeof(serverAddr)) < 0) {
            close(socketFd);
            throw std::runtime_error("Connection failed");
        }
    }
    
    ssize_t send(const void* data, size_t length) {
        return ::send(socketFd, data, length, 0);
    }
    
    ssize_t receive(void* buffer, size_t length) {
        return ::recv(socketFd, buffer, length, 0);
    }
    
    ~TCPSocket() {
        if (socketFd >= 0) {
            close(socketFd);
        }
    }
};

#include <string>
#include <map>

class HTTPRequest {
private:
    std::string method;
    std::string uri;
    std::string version;
    std::map<std::string, std::string> headers;
    std::string body;
    
public:
    std::string serialize() const {
        std::string request = method + " " + uri + " " + version + "\r\n";
        
        for (const auto& [key, value] : headers) {
            request += key + ": " + value + "\r\n";
        }
        
        request += "\r\n";
        request += body;
        
        return request;
    }
    
    void setMethod(const std::string& m) { method = m; }
    void setURI(const std::string& u) { uri = u; }
    void addHeader(const std::string& key, const std::string& value) {
        headers[key] = value;
    }
    void setBody(const std::string& b) { body = b; }
};

#include <vector>
#include <thread>
#include <future>
#include <algorithm>

template<typename T, typename MapFunc, typename ReduceFunc>
T parallelMapReduce(const std::vector<T>& data,
                    MapFunc mapFunction,
                    ReduceFunc reduceFunction,
                    T initialValue,
                    size_t numThreads = std::thread::hardware_concurrency()) {
    
    size_t chunkSize = data.size() / numThreads;
    std::vector<std::future<T>> futures;
    
    // توزیع کار بین threadها
    for (size_t i = 0; i < numThreads; ++i) {
        size_t start = i * chunkSize;
        size_t end = (i == numThreads - 1) ? data.size() : start + chunkSize;
        
        futures.push_back(std::async(std::launch::async, 
            [&data, start, end, &mapFunction]() {
                T result{};
                for (size_t j = start; j < end; ++j) {
                    result += mapFunction(data[j]);
                }
                return result;
            }
        ));
    }
    
    // جمع‌آوری نتایج
    T finalResult = initialValue;
    for (auto& future : futures) {
        finalResult = reduceFunction(finalResult, future.get());
    }
    
    return finalResult;
}

#include <omp.h>
#include <vector>
#include <iostream>

void parallelProcessing() {
    const int N = 1000000;
    std::vector<double> data(N);
    
    // مقداردهی اولیه موازی
    #pragma omp parallel for
    for (int i = 0; i < N; ++i) {
        data[i] = i * 0.5;
    }
    
    // محاسبات موازی
    double sum = 0.0;
    #pragma omp parallel for reduction(+:sum)
    for (int i = 0; i < N; ++i) {
        sum += data[i] * data[i];
    }
    
    std::cout << "Sum: " << sum << std::endl;
}

// کرنل CUDA برای جمع دو وکتور
__global__ void vectorAdd(const float* A, const float* B, float* C, int numElements) {
    int i = blockDim.x * blockIdx.x + threadIdx.x;
    
    if (i < numElements) {
        C[i] = A[i] + B[i];
    }
}

// فراخوانی از host
void launchVectorAdd() {
    int numElements = 50000;
    size_t size = numElements * sizeof(float);
    
    // تخصیص حافظه در host
    float* h_A = new float[numElements];
    float* h_B = new float[numElements];
    float* h_C = new float[numElements];
    
    // مقداردهی
    for (int i = 0; i < numElements; ++i) {
        h_A[i] = rand() / (float)RAND_MAX;
        h_B[i] = rand() / (float)RAND_MAX;
    }
    
    // تخصیص حافظه در device
    float *d_A, *d_B, *d_C;
    cudaMalloc(&d_A, size);
    cudaMalloc(&d_B, size);
    cudaMalloc(&d_C, size);
    
    // کپی داده به device
    cudaMemcpy(d_A, h_A, size, cudaMemcpyHostToDevice);
    cudaMemcpy(d_B, h_B, size, cudaMemcpyHostToDevice);
    
    // اجرای کرنل
    int threadsPerBlock = 256;
    int blocksPerGrid = (numElements + threadsPerBlock - 1) / threadsPerBlock;
    
    vectorAdd<<<blocksPerGrid, threadsPerBlock>>>(d_A, d_B, d_C, numElements);
    
    // کپی نتایج به host
    cudaMemcpy(h_C, d_C, size, cudaMemcpyDeviceToHost);
    
    // پاک‌سازی
    cudaFree(d_A);
    cudaFree(d_B);
    cudaFree(d_C);
    delete[] h_A;
    delete[] h_B;
    delete[] h_C;
}

#include <openssl/aes.h>
#include <vector>
#include <stdexcept>

class AESEncryptor {
private:
    AES_KEY encryptKey;
    AES_KEY decryptKey;
    
public:
    AESEncryptor(const std::vector<unsigned char>& key) {
        if (key.size() != 16 && key.size() != 24 && key.size() != 32) {
            throw std::invalid_argument("Key must be 16, 24, or 32 bytes");
        }
        
        AES_set_encrypt_key(key.data(), key.size() * 8, &encryptKey);
        AES_set_decrypt_key(key.data(), key.size() * 8, &decryptKey);
    }
    
    std::vector<unsigned char> encrypt(const std::vector<unsigned char>& plaintext) {
        if (plaintext.empty()) {
            return {};
        }
        
        // PKCS7 padding
        size_t paddedSize = ((plaintext.size() + AES_BLOCK_SIZE - 1) / AES_BLOCK_SIZE) * AES_BLOCK_SIZE;
        std::vector<unsigned char> padded(paddedSize);
        std::copy(plaintext.begin(), plaintext.end(), padded.begin());
        
        unsigned char paddingValue = paddedSize - plaintext.size();
        for (size_t i = plaintext.size(); i < paddedSize; ++i) {
            padded[i] = paddingValue;
        }
        
        // Encryption
        std::vector<unsigned char> ciphertext(paddedSize);
        for (size_t i = 0; i < paddedSize; i += AES_BLOCK_SIZE) {
            AES_encrypt(&padded[i], &ciphertext[i], &encryptKey);
        }
        
        return ciphertext;
    }
    
    std::vector<unsigned char> decrypt(const std::vector<unsigned char>& ciphertext) {
        if (ciphertext.empty() || ciphertext.size() % AES_BLOCK_SIZE != 0) {
            throw std::invalid_argument("Invalid ciphertext size");
        }
        
        std::vector<unsigned char> plaintext(ciphertext.size());
        
        for (size_t i = 0; i < ciphertext.size(); i += AES_BLOCK_SIZE) {
            AES_decrypt(&ciphertext[i], &plaintext[i], &decryptKey);
        }
        
        // Remove padding
        unsigned char paddingValue = plaintext.back();
        if (paddingValue > AES_BLOCK_SIZE) {
            throw std::runtime_error("Invalid padding");
        }
        
        plaintext.resize(plaintext.size() - paddingValue);
        return plaintext;
    }
};