<?php
require_once 'db.php';


if(!function_exists('get_category_by_slug')) {
    function get_category_by_slug($slug) {
        // Handle category mappings
        $mappings = [
            'hugong-co2-aparati' => 'co2-aparati',
            'hugong-rel-aparati' => 'rel-aparati',
            'hugong-tig-aparati' => 'tig-aparati',
            'hugong-plazma-sekac' => 'plazma-sekaci',
            'hugong-aparati' => 'aparati'
        ];
        
        if(isset($mappings[$slug])) {
            $slug = $mappings[$slug];
        }
        
        return get_row("SELECT * FROM categories WHERE slug = ?", [$slug]);
    }
}


// Funkcija za formatiranje cene
function format_price($price) {
    return number_format($price, 2, ',', '.') . ' rsd';
}

// Kreiranje slug-a iz teksta
function create_slug($text) {
    $text = strtolower(trim($text));
    $text = preg_replace('/[^a-z0-9\s-]/', '', $text);
    $text = preg_replace('/[\s-]+/', '-', $text);
    $text = preg_replace('/^-+|-+$/', '', $text);
    return $text;
}

// Sigurno preuzimanje GET i POST parametara
function get_param($param, $default = '') {
    return isset($_GET[$param]) ? htmlspecialchars($_GET[$param]) : $default;
}

function post_param($param, $default = '') {
    return isset($_POST[$param]) ? htmlspecialchars($_POST[$param]) : $default;
}

// Paginacija
function paginate($total_items, $items_per_page = 12, $current_page = 1, $url_pattern = '?page={page}') {
    $total_pages = ceil($total_items / $items_per_page);
    
    if ($total_pages <= 1) {
        return '';
    }
    
    $html = '<div class="pagination">';
    
    // Previous button
    if ($current_page > 1) {
        $prev_url = str_replace('{page}', $current_page - 1, $url_pattern);
        $html .= '<a href="' . $prev_url . '" class="page-prev">Prethodna</a>';
    } else {
        $html .= '<span class="page-prev disabled">Prethodna</span>';
    }
    
    // Page numbers
    $start_page = max(1, $current_page - 2);
    $end_page = min($total_pages, $current_page + 2);
    
    if ($start_page > 1) {
        $html .= '<a href="' . str_replace('{page}', 1, $url_pattern) . '">1</a>';
        if ($start_page > 2) {
            $html .= '<span class="dots">...</span>';
        }
    }
    
    for ($i = $start_page; $i <= $end_page; $i++) {
        if ($i == $current_page) {
            $html .= '<span class="page-current">' . $i . '</span>';
        } else {
            $html .= '<a href="' . str_replace('{page}', $i, $url_pattern) . '">' . $i . '</a>';
        }
    }
    
    if ($end_page < $total_pages) {
        if ($end_page < $total_pages - 1) {
            $html .= '<span class="dots">...</span>';
        }
        $html .= '<a href="' . str_replace('{page}', $total_pages, $url_pattern) . '">' . $total_pages . '</a>';
    }
    
    // Next button
    if ($current_page < $total_pages) {
        $next_url = str_replace('{page}', $current_page + 1, $url_pattern);
        $html .= '<a href="' . $next_url . '" class="page-next">Sledeća</a>';
    } else {
        $html .= '<span class="page-next disabled">Sledeća</span>';
    }
    
    $html .= '</div>';
    
    return $html;
}

// Generisanje meta tagova
function generate_meta_tags($title = '', $description = '', $keywords = '', $image = '') {
    $site_name = get_setting('site_name', 'Hugong Aparati');
    $default_desc = get_setting('site_description', 'Profesionalni aparati za zavarivanje');
    
    $title = !empty($title) ? $title : $site_name;
    $description = !empty($description) ? $description : $default_desc;
    
    $html = "<title>{$title}</title>\n";
    $html .= "<meta name=\"description\" content=\"{$description}\">\n";
    
    if (!empty($keywords)) {
        $html .= "<meta name=\"keywords\" content=\"{$keywords}\">\n";
    }
    
    // Open Graph meta tags
    $html .= "<meta property=\"og:title\" content=\"{$title}\">\n";
    $html .= "<meta property=\"og:description\" content=\"{$description}\">\n";
    $html .= "<meta property=\"og:type\" content=\"website\">\n";
    $html .= "<meta property=\"og:url\" content=\"" . (isset($_SERVER['HTTPS']) && $_SERVER['HTTPS'] === 'on' ? "https" : "http") . "://$_SERVER[HTTP_HOST]$_SERVER[REQUEST_URI]\">\n";
    
    if (!empty($image)) {
        $html .= "<meta property=\"og:image\" content=\"{$image}\">\n";
    }
    
    $html .= "<meta property=\"og:site_name\" content=\"{$site_name}\">\n";
    
    // Twitter Card meta tags
    $html .= "<meta name=\"twitter:card\" content=\"summary_large_image\">\n";
    $html .= "<meta name=\"twitter:title\" content=\"{$title}\">\n";
    $html .= "<meta name=\"twitter:description\" content=\"{$description}\">\n";
    
    if (!empty($image)) {
        $html .= "<meta name=\"twitter:image\" content=\"{$image}\">\n";
    }
    
    return $html;
}

// Upload slike
function upload_image($file, $destination_path, $max_size = 5242880) {
    $allowed_extensions = ['jpg', 'jpeg', 'png', 'gif', 'webp'];
    
    // Provera da li je došlo do greške pri uploadu
    if ($file['error'] !== UPLOAD_ERR_OK) {
        return ['success' => false, 'message' => 'Došlo je do greške prilikom uploada.'];
    }
    
    // Provera veličine fajla
    if ($file['size'] > $max_size) {
        return ['success' => false, 'message' => 'Fajl je prevelik. Maksimalna veličina je ' . ($max_size / 1024 / 1024) . 'MB.'];
    }
    
    // Provera ekstenzije
    $file_info = pathinfo($file['name']);
    $extension = strtolower($file_info['extension']);
    
    if (!in_array($extension, $allowed_extensions)) {
        return ['success' => false, 'message' => 'Dozvoljene ekstenzije su: ' . implode(', ', $allowed_extensions)];
    }
    
    // Kreiranje jedinstvenog imena fajla
    $new_filename = uniqid() . '.' . $extension;
    $destination = $destination_path . '/' . $new_filename;
    
    // Provera da li postoji direktorijum, ako ne, kreiraj ga
    if (!is_dir($destination_path)) {
        mkdir($destination_path, 0755, true);
    }
    
    // Upload fajla
    if (move_uploaded_file($file['tmp_name'], $destination)) {
        return ['success' => true, 'filename' => $new_filename, 'path' => $destination];
    } else {
        return ['success' => false, 'message' => 'Došlo je do greške prilikom uploada fajla.'];
    }
}

// Funkcije za korpu
function get_cart() {
    if (!isset($_SESSION['cart'])) {
        $_SESSION['cart'] = [];
    }
    return $_SESSION['cart'];
}

function add_to_cart($product_id, $quantity = 1) {
    if (!isset($_SESSION['cart'])) {
        $_SESSION['cart'] = [];
    }
    
    if (isset($_SESSION['cart'][$product_id])) {
        $_SESSION['cart'][$product_id] += $quantity;
    } else {
        $_SESSION['cart'][$product_id] = $quantity;
    }
    
    return true;
}

function update_cart_item($product_id, $quantity) {
    if (isset($_SESSION['cart'][$product_id])) {
        if ($quantity > 0) {
            $_SESSION['cart'][$product_id] = $quantity;
        } else {
            remove_from_cart($product_id);
        }
        return true;
    }
    return false;
}

function remove_from_cart($product_id) {
    if (isset($_SESSION['cart'][$product_id])) {
        unset($_SESSION['cart'][$product_id]);
        return true;
    }
    return false;
}

function clear_cart() {
    $_SESSION['cart'] = [];
}

function get_cart_total() {
    $total = 0;
    $cart = get_cart();
    
    foreach ($cart as $product_id => $quantity) {
        $product = get_product($product_id);
        if ($product) {
            $price = !empty($product['sale_price']) ? $product['sale_price'] : $product['price'];
            $total += $price * $quantity;
        }
    }
    
    return $total;
}

// Funkcija za dobijanje proizvoda
function get_product($product_id) {
    return get_row("SELECT * FROM products WHERE id = ?", [$product_id]);
}

// Funkcija za dobijanje proizvoda preko sluga
function get_product_by_slug($slug) {
    return get_row("SELECT * FROM products WHERE slug = ?", [$slug]);
}

// Funkcija za dobijanje kategorije
function get_category($category_id) {
    return get_row("SELECT * FROM categories WHERE id = ?", [$category_id]);
}

// Funkcija za dobijanje kategorije preko sluga
function get_category_by_slug($slug) {
    return get_row("SELECT * FROM categories WHERE slug = ?", [$slug]);
}

// Autentifikacija korisnika
function login_user($email, $password) {
    $user = get_row("SELECT * FROM users WHERE email = ? AND status = 'active'", [$email]);
    
    if ($user && password_verify($password, $user['password'])) {
        $_SESSION['user_id'] = $user['id'];
        $_SESSION['user_name'] = $user['name'];
        $_SESSION['user_email'] = $user['email'];
        $_SESSION['user_role'] = $user['role'];
        return true;
    }
    
    return false;
}

function logout_user() {
    unset($_SESSION['user_id']);
    unset($_SESSION['user_name']);
    unset($_SESSION['user_email']);
    unset($_SESSION['user_role']);
    
    session_destroy();
}

function is_logged_in() {
    return isset($_SESSION['user_id']);
}

function is_admin() {
    return isset($_SESSION['user_role']) && $_SESSION['user_role'] === 'admin';
}

// Funkcija za generisanje broja porudžbine
function generate_order_number() {
    $prefix = 'HG';
    $date = date('ymd');
    $random = strtoupper(substr(md5(uniqid(mt_rand(), true)), 0, 4));
    
    return $prefix . $date . $random;
}






/**
 * Dohvata preporučene proizvode za određeni proizvod
 * 
 * @param int $product_id ID proizvoda
 * @param int $limit Maksimalan broj preporučenih proizvoda
 * @return array Niz preporučenih proizvoda
 */
function get_recommended_products($product_id, $limit = 4) {
    global $conn;
    
    // Prvo proveri da li proizvod ima specifično konfigurisane preporuke
    $custom_recommendations = get_rows("
        SELECT p.*, 
        (SELECT image FROM product_images pi WHERE pi.product_id = p.id ORDER BY pi.sort_order ASC LIMIT 1) as image,
        pr.sort_order
        FROM product_recommendations pr
        JOIN products p ON pr.recommended_product_id = p.id
        WHERE pr.product_id = ? AND p.status = 'active'
        ORDER BY pr.sort_order ASC
        LIMIT ?
    ", [$product_id, $limit]);
    
    // Ako ima preporuka, vrati ih
    if (!empty($custom_recommendations)) {
        return $custom_recommendations;
    }
    
    // Ako nema specifičnih preporuka, dohvati najpopularnije proizvode iz iste kategorije
    $category_ids = get_rows("
        SELECT category_id FROM product_categories
        WHERE product_id = ?
    ", [$product_id]);
    
    if (!empty($category_ids)) {
        $category_id_array = array_column($category_ids, 'category_id');
        $placeholders = implode(',', array_fill(0, count($category_id_array), '?'));
        
        // Dohvati proizvode iz istih kategorija
        $category_recommendations = get_rows("
            SELECT DISTINCT p.*, 
            (SELECT image FROM product_images pi WHERE pi.product_id = p.id ORDER BY pi.sort_order ASC LIMIT 1) as image,
            (p.rating_count * p.rating_sum) as popularity
            FROM products p
            JOIN product_categories pc ON p.id = pc.product_id
            WHERE pc.category_id IN ($placeholders)
            AND p.id != ?
            AND p.status = 'active'
            ORDER BY popularity DESC, p.rating_count DESC
            LIMIT ?
        ", array_merge($category_id_array, [$product_id, $limit]));
        
        if (!empty($category_recommendations)) {
            return $category_recommendations;
        }
    }
    
    // Ako ni to nije uspelo, vrati najpopularnije proizvode generalno
    return get_popular_products($limit, $product_id);
}

/**
 * Dohvata najpopularnije proizvode (koristi se kao fallback)
 * 
 * @param int $limit Maksimalan broj proizvoda
 * @param int $exclude_id Proizvod koji treba isključiti iz rezultata
 * @return array Niz popularnih proizvoda
 */
function get_popular_products($limit = 4, $exclude_id = null) {
    $exclude_condition = $exclude_id ? "AND id != ?" : "";
    $params = $exclude_id ? [$exclude_id, $limit] : [$limit];
    
    return get_rows("
        SELECT *, 
        (SELECT image FROM product_images pi WHERE pi.product_id = products.id ORDER BY pi.sort_order ASC LIMIT 1) as image,
        (rating_count * rating_sum) as popularity
        FROM products
        WHERE status = 'active' $exclude_condition
        ORDER BY popularity DESC, rating_count DESC, id DESC
        LIMIT ?
    ", $params);
}

/**
 * Ažurira preporučene proizvode za određeni proizvod
 * 
 * @param int $product_id ID proizvoda
 * @param array $recommended_products Niz ID-jeva preporučenih proizvoda
 * @return bool Uspeh operacije
 */
function update_product_recommendations($product_id, $recommended_products) {
    global $conn;
    
    try {
        // Briši postojeće preporuke
        $conn->prepare("DELETE FROM product_recommendations WHERE product_id = ?")->execute([$product_id]);
        
        // Nema novih preporuka za dodavanje
        if (empty($recommended_products)) {
            return true;
        }
        
        // Dodaj nove preporuke
        $stmt = $conn->prepare("INSERT INTO product_recommendations (product_id, recommended_product_id, sort_order) VALUES (?, ?, ?)");
        
        foreach ($recommended_products as $index => $rec_product_id) {
            $stmt->execute([$product_id, $rec_product_id, $index]);
        }
        
        return true;
    } catch (Exception $e) {
        error_log("Error updating product recommendations: " . $e->getMessage());
        return false;
    }
}


/**
 * Pretvara ime iz nominativa u vokativ
 * 
 * @param string $full_name Puno ime i prezime
 * @return string Samo ime u vokativu
 */
function to_vocative($full_name) {
    if (empty($full_name)) {
        return '';
    }
    
    // Konvertujemo u mala slova i delimo na reči
    $name_parts = explode(' ', mb_strtolower(trim($full_name), 'UTF-8'));
    if (count($name_parts) < 2) {
        // Ako je samo jedna reč, pretpostavljamo da je ime
        $first_name = $name_parts[0];
    } else {
        // Lista čestih srpskih imena (proširena)
        $common_names = [
            'aleksandar', 'aleksa', 'andrej', 'andrija', 'anton', 'branko', 'bojan', 'bogdan', 
            'boris', 'boško', 'vanja', 'veljko', 'vladimir', 'vojin', 'goran', 'grigorije', 
            'damjan', 'danilo', 'darko', 'dejan', 'dimitrije', 'dragan', 'dušan', 'đorđe', 
            'emil', 'filip', 'gavrilo', 'igor', 'ilija', 'ivan', 'jakov', 'janko', 'jovan', 
            'kosta', 'kristijan', 'lazar', 'luka', 'ljubomir', 'marko', 'mateja', 'mihajlo', 
            'milan', 'miljan', 'miloš', 'mirko', 'miroslav', 'mladen', 'nemanja', 'nenad', 
            'nikola', 'novak', 'ognjen', 'pavle', 'petar', 'predrag', 'rastko', 'relja', 
            'stefan', 'strahinja', 'tadija', 'teodor', 'uroš', 'vasilije', 'viktor', 'vuk',
            'zoran', 'željko', 'žarko',
            'ana', 'aleksandra', 'anđela', 'andrea', 'anja', 'bojana', 'branka', 'valentina', 
            'vanja', 'vera', 'vesna', 'vidosava', 'violeta', 'vukosava', 'gordana', 'danica', 
            'dara', 'darija', 'dejana', 'dragana', 'dunja', 'đurđa', 'elena', 'eleonora', 
            'željka', 'zorana', 'zorka', 'ivana', 'iva', 'irina', 'isidora', 'jana', 'jelena', 
            'jovana', 'katarina', 'kristina', 'ljubica', 'magdalena', 'maja', 'marica', 'marija', 
            'marina', 'marta', 'milena', 'milica', 'miona', 'mirjana', 'nada', 'nadežda', 
            'natalija', 'nataša', 'nevena', 'nikolina', 'nina', 'olivera', 'olgica', 'petra', 
            'sanja', 'sara', 'slavica', 'slađana', 'snežana', 'sofija', 'staša', 'tamara', 
            'tanja', 'tijana', 'una', 'hana'
        ];
        
        // Lista sufiksa tipičnih za srpska prezimena
        $surname_suffixes = ['ić', 'vić', 'ović', 'ević', 'ski', 'čki', 'ški', 'ov', 'ev', 'in', 'ac', 'ek', 'ar'];
        
        // Provera da li su delovi imena i prezime
        $detected_name = null;
        
        // Prvo pokušavamo da pronađemo ime u delovima
        foreach ($name_parts as $part) {
            if (in_array($part, $common_names)) {
                $detected_name = $part;
                break;
            }
        }
        
        // Ako nismo pronašli ime u listi čestih imena, probajmo prepoznati prezime po sufiksu
        if ($detected_name === null) {
            $surname_found = false;
            
            foreach ($name_parts as $i => $part) {
                foreach ($surname_suffixes as $suffix) {
                    if (mb_substr($part, -mb_strlen($suffix, 'UTF-8'), null, 'UTF-8') === $suffix) {
                        $surname_found = true;
                        
                        // Ako je prezime nađeno, pretpostavljamo da je ime u drugom delu
                        if (count($name_parts) == 2) {
                            $detected_name = ($i == 0) ? $name_parts[1] : $name_parts[0];
                        } else {
                            // Ako ima više od 2 dela, uzimamo prvi deo koji nije prezime
                            foreach ($name_parts as $j => $other_part) {
                                if ($j != $i) {
                                    $detected_name = $other_part;
                                    break;
                                }
                            }
                        }
                        break 2; // Izlaz iz obe petlje
                    }
                }
            }
            
            // Ako nismo uspeli da prepoznamo prezime, uzimamo poslednju reč kao ime
            // jer je to češći slučaj u srpskom (prvo prezime, pa ime)
            if (!$surname_found) {
                $detected_name = $name_parts[count($name_parts) - 1];
            }
        }
        
        $first_name = $detected_name;
    }
    
    // Definišemo izuzetke (specifična imena koja imaju posebna pravila)
    $exceptions = [
        'miloš' => 'Milošu',
        'ljubiša' => 'Ljubiša',
        'saša' => 'Saša',
        'nikola' => 'Nikola',
        'luka' => 'Luka',
        'nemanja' => 'Nemanja',
        'ilija' => 'Ilija',
        'mateja' => 'Mateja',
        'andrija' => 'Andrija',
        'vanja' => 'Vanja',
        'sava' => 'Sava',
        'nenad' => 'Nenade',
        'slobodan' => 'Slobodane',
        'dragan' => 'Dragane',
        'zoran' => 'Zorane',
        'goran' => 'Gorane',
        'milan' => 'Milane',
        'ivan' => 'Ivane',
        'dušan' => 'Dušane',
        'jovan' => 'Jovane',
        'dejan' => 'Dejane',
        'veljko' => 'Veljko',
        'marko' => 'Marko',
        'predrag' => 'Predraže',
        'aleksandar' => 'Aleksandre',
        'vladimir' => 'Vladimire',
        'vuk' => 'Vuče',
        'radovan' => 'Radovane',
        'miodrag' => 'Miodraže',
        'mihajlo' => 'Mihajlo',
        'đorđe' => 'Đorđe',
        'petar' => 'Petre',
        'branimir' => 'Branimire',
        'stefan' => 'Stefane',
        'branko' => 'Branko',
        'mirko' => 'Mirko',
        'boško' => 'Boško',
        'draško' => 'Draško',
        'darko' => 'Darko',
        'marko' => 'Marko',
        'željko' => 'Željko',
        'stanko' => 'Stanko',
        'vlado' => 'Vlado',
        'vojislav' => 'Vojislave',
        'ana' => 'Ana',
        'marina' => 'Marina',
        'marija' => 'Marija',
        'milica' => 'Milice',
        'jelena' => 'Jelena',
        'ivana' => 'Ivana',
        'tijana' => 'Tijana',
        'dragana' => 'Dragana',
        'tamara' => 'Tamara',
        'teodora' => 'Teodora',
        'nevena' => 'Nevena',
        'maja' => 'Maja',
        'jovana' => 'Jovana',
        'katarina' => 'Katarina',
        'aleksandra' => 'Aleksandra',
        'bojana' => 'Bojana',
        'vesna' => 'Vesna',
        'snežana' => 'Snežana',
        'ljiljana' => 'Ljiljana',
        'mirjana' => 'Mirjana',
        'dušica' => 'Dušice',
        'nataša' => 'Nataša'
    ];
    
    // Ako imamo ime u izuzecima, koristimo ga
    if (isset($exceptions[$first_name])) {
        return $exceptions[$first_name];
    }
    
    // Osnovna pravila za muška imena
    $length = mb_strlen($first_name, 'UTF-8');
    $last_char = mb_substr($first_name, -1, 1, 'UTF-8');
    $last_two_chars = mb_substr($first_name, -2, 2, 'UTF-8');
    
    // Primenjujemo pravila za vokativ
    $vocative_first_name = $first_name;
    
    // Ako se završava na konsonant, dodajemo -e (osim za -j, -ć, -đ, -č, -dž, -š, -ž)
    if (in_array($last_char, ['b', 'c', 'd', 'f', 'g', 'h', 'k', 'l', 'm', 'n', 'p', 'r', 's', 't', 'v', 'z'])) {
        $vocative_first_name = mb_substr($first_name, 0, $length - 1, 'UTF-8') . 'e';
    } 
    // Ako se završava na -k, -g, -h, menjamo u -če, -že, -še
    else if ($last_char === 'k') {
        $vocative_first_name = mb_substr($first_name, 0, $length - 1, 'UTF-8') . 'če';
    } 
    else if ($last_char === 'g') {
        $vocative_first_name = mb_substr($first_name, 0, $length - 1, 'UTF-8') . 'že';
    }
    else if ($last_char === 'h') {
        $vocative_first_name = mb_substr($first_name, 0, $length - 1, 'UTF-8') . 'še';
    }
    // Ako se završava na -ca (ženska imena), menjamo u -ce
    else if ($last_two_chars === 'ca') {
        $vocative_first_name = mb_substr($first_name, 0, $length - 1, 'UTF-8') . 'e';
    }
    // Ženska imena na -a, uglavnom ostaju ista ili dobijaju -o
    else if ($last_char === 'a') {
        // Većina ženskih imena na -a ostaje ista u vokativu u savremenom jeziku
        $vocative_first_name = $first_name;
    }
    
    // Vraćamo ime sa velikim prvim slovom
    return mb_strtoupper(mb_substr($vocative_first_name, 0, 1, 'UTF-8'), 'UTF-8') . 
           mb_substr($vocative_first_name, 1, null, 'UTF-8');
}







// DODATI FUNKCIJE ZA PRODUCT
/**
 * Dohvata povezane proizvode iz iste kategorije
 * 
 * @param int $product_id ID proizvoda
 * @param int $limit Maksimalan broj povezanih proizvoda
 * @return array Niz povezanih proizvoda
 */
function get_related_products($product_id, $limit = 4) {
    global $conn;
    
    // Prvo pronađi kategorije ovog proizvoda
    $category_ids = get_rows("
        SELECT category_id FROM product_categories
        WHERE product_id = ?
    ", [$product_id]);
    
    if (empty($category_ids)) {
        return [];
    }
    
    $category_id_array = array_column($category_ids, 'category_id');
    $placeholders = implode(',', array_fill(0, count($category_id_array), '?'));
    
    // Dohvati proizvode iz istih kategorija koji nisu trenutni proizvod
    $related_products = get_rows("
        SELECT DISTINCT p.*, 
        (SELECT image FROM product_images pi WHERE pi.product_id = p.id ORDER BY pi.sort_order ASC LIMIT 1) as image
        FROM products p
        JOIN product_categories pc ON p.id = pc.product_id
        WHERE pc.category_id IN ($placeholders)
        AND p.id != ?
        AND p.status = 'active'
        ORDER BY p.id DESC
        LIMIT ?
    ", array_merge($category_id_array, [$product_id, $limit]));
    
    return $related_products;
}

/**
 * Generiše ključne reči za proizvod
 * 
 * @param array $product Proizvod
 * @param array $product_categories Kategorije proizvoda
 * @return string Ključne reči za proizvod
 */
function generate_product_keywords($product, $product_categories) {
    $keywords = [];
    
    // Dodaj naziv proizvoda kao ključnu reč
    $keywords[] = $product['name'];
    
    // Dodaj kategorije
    foreach ($product_categories as $category) {
        $keywords[] = $category['name'];
    }
    
    // Dodaj brendove
    $keywords[] = "Hugong";
    
    // Dodaj specifične ključne reči za aparate za varenje
    if (strpos(strtolower($product['name']), 'tig') !== false) {
        $keywords[] = "TIG aparat za varenje";
        $keywords[] = "TIG zavarivanje";
    }
    
    if (strpos(strtolower($product['name']), 'co2') !== false || 
        strpos(strtolower($product['name']), 'mig') !== false ||
        strpos(strtolower($product['name']), 'mag') !== false) {
        $keywords[] = "MIG/MAG aparat";
        $keywords[] = "CO2 zavarivanje";
    }
    
    if (strpos(strtolower($product['name']), 'rel') !== false ||
        strpos(strtolower($product['name']), 'estick') !== false ||
        strpos(strtolower($product['name']), 'mma') !== false) {
        $keywords[] = "REL aparat za varenje";
        $keywords[] = "MMA zavarivanje";
    }
    
    if (strpos(strtolower($product['name']), 'plazma') !== false) {
        $keywords[] = "Plazma sekač";
        $keywords[] = "Plazma rezanje";
    }
    
    // Ukloni duplikate i spoji u string
    return implode(', ', array_unique($keywords));
}

/**
 * Postavlja meta podatke za stranicu
 * 
 * @param string $title Naslov stranice
 * @param string $description Opis stranice
 * @param string $keywords Ključne reči
 * @param string $image Slika
 */
function set_page_meta($title, $description, $keywords, $image) {
    // Ova funkcija se može preskočiti ako već imate sistem za meta tagove
    // U tom slučaju samo preformatirati postojeće meta tagove
    global $meta_title, $meta_description, $meta_keywords, $meta_image;
    
    $meta_title = $title;
    $meta_description = $description;
    $meta_keywords = $keywords;
    $meta_image = $image;
}

/**
 * Dohvata često postavljena pitanja (FAQ) za proizvod
 * 
 * @param int $product_id ID proizvoda
 * @return array Niz FAQ-ova
 */
function get_product_faqs($product_id) {
    // Implementirati u skladu sa strukturom baze podataka
    // Ako ne postoji tabela za FAQ, vratiti prazno polje
    
    // Primer implementacije:
    // return get_rows("SELECT * FROM product_faqs WHERE product_id = ? ORDER BY sort_order ASC", [$product_id]);
    
    // Privremeno vraćam prazan niz
    return [];
}

/**
 * Dohvata varijante proizvoda (npr. različite snage, boje itd.)
 * 
 * @param int $product_id ID proizvoda
 * @return array Niz varijanti proizvoda
 */
function get_product_variants($product_id) {
    // Implementirati u skladu sa strukturom baze podataka
    // Ako ne postoji tabela za varijante, vratiti prazno polje
    
    // Primer implementacije:
    // return get_rows("SELECT * FROM product_variants WHERE parent_id = ? OR id = ? ORDER BY sort_order ASC", [$product_id, $product_id]);
    
    // Privremeno vraćam prazan niz
    return [];
}

/**
 * Vraća gramatički pravilnu verziju teksta o recenzijama
 * 
 * @param int $count Broj recenzija
 * @return string Tekst o recenzijama
 */
function get_review_text($count) {
    if ($count % 10 == 1 && $count % 100 != 11) {
        return 'ocena';
    } elseif (($count % 10 >= 2 && $count % 10 <= 4) && 
              ($count % 100 < 12 || $count % 100 > 14)) {
        return 'ocene';
    } else {
        return 'ocena';
    }
}




/**
 * Generiše različite veličine slika proizvoda
 *
 * @param string $filename Naziv fajla slike
 * @param string $source_path Putanja do originalne slike
 * @return bool Uspeh operacije
 */
function generate_product_image_sizes($filename, $source_path) {
    // Definisanje direktorijuma
    $uploads_path = UPLOADS_PATH . '/products';
    $thumbs_dir = $uploads_path . '/thumbs';
    $large_dir = $uploads_path . '/large';
    
    // Kreiraj direktorijume ako ne postoje
    if (!is_dir($thumbs_dir)) {
        mkdir($thumbs_dir, 0755, true);
    }
    
    if (!is_dir($large_dir)) {
        mkdir($large_dir, 0755, true);
    }
    
    // Kopiraj originalnu sliku u large folder (možemo kasnije dodati resize)
    copy($source_path, $large_dir . '/' . $filename);
    
    // Kreiraj thumbnail
    $image_info = getimagesize($source_path);
    if (!$image_info) {
        return false;
    }
    
    $width = $image_info[0];
    $height = $image_info[1];
    $mime = $image_info['mime'];
    
    // Maksimalne dimenzije za thumbnail
    $max_width = 150;
    $max_height = 150;
    
    // Izračunaj nove dimenzije uz održavanje odnosa
    if ($width > $height) {
        $new_width = $max_width;
        $new_height = intval($height * $max_width / $width);
    } else {
        $new_height = $max_height;
        $new_width = intval($width * $max_height / $height);
    }
    
    // Kreiraj thumbnail na osnovu tipa slike
    $src_image = null;
    switch ($mime) {
        case 'image/jpeg':
            $src_image = imagecreatefromjpeg($source_path);
            break;
        case 'image/png':
            $src_image = imagecreatefrompng($source_path);
            break;
        case 'image/gif':
            $src_image = imagecreatefromgif($source_path);
            break;
        default:
            // Ako ne možemo obraditi tip slike, samo je kopiraj
            copy($source_path, $thumbs_dir . '/' . $filename);
            return true;
    }
    
    if ($src_image) {
        $dst_image = imagecreatetruecolor($new_width, $new_height);
        
        // Očuvaj transparentnost za PNG
        if ($mime == 'image/png') {
            imagealphablending($dst_image, false);
            imagesavealpha($dst_image, true);
            $transparent = imagecolorallocatealpha($dst_image, 255, 255, 255, 127);
            imagefilledrectangle($dst_image, 0, 0, $new_width, $new_height, $transparent);
        }
        
        // Resize sliku
        imagecopyresampled($dst_image, $src_image, 0, 0, 0, 0, $new_width, $new_height, $width, $height);
        
        // Sačuvaj thumbnail
        switch ($mime) {
            case 'image/jpeg':
                imagejpeg($dst_image, $thumbs_dir . '/' . $filename, 85);
                break;
            case 'image/png':
                imagepng($dst_image, $thumbs_dir . '/' . $filename, 8);
                break;
            case 'image/gif':
                imagegif($dst_image, $thumbs_dir . '/' . $filename);
                break;
        }
        
        // Oslobodi memoriju
        imagedestroy($src_image);
        imagedestroy($dst_image);
    }
    
    return true;
}


