#!/usr/bin/env python3

import os
import sys
import re
import argparse
import requests
import json
from datetime import datetime
import random
import html

def get_first_todo_article(progress_file, blog_dir):
    """Pobiera pierwszy nieukończony artykuł z pliku progress.md.
    Jeśli nie ma nieukończonych artykułów, dodaje nowe na podstawie istniejących katalogów."""
    with open(progress_file, 'r') as f:
        content = f.read()
    
    pattern = r'- \[ \] (\d+\.[^\n]+)'  # Nieukończone artykuły
    matches = re.findall(pattern, content)
    
    if matches:
        return matches[0]
    else:
        print("Nie znaleziono żadnych nieukończonych artykułów w pliku progress.md")
        print("Dodaję nowe artykuły na podstawie istniejących katalogów...")
        
        # Lista wszystkich katalogów w blog_dir
        subdirs = [d for d in os.listdir(blog_dir) if os.path.isdir(os.path.join(blog_dir, d))]
        
        # Sortowanie katalogów numerycznie
        def extract_number(dirname):
            try:
                return int(dirname.split('.')[0])
            except (ValueError, IndexError):
                return 999999  # Dla katalogów bez numeru
        
        subdirs.sort(key=extract_number)
        
        if not subdirs:
            print("Nie znaleziono żadnych katalogów artykułów!")
            sys.exit(1)
            
        # Znajdź najwyższy numer artykułu
        last_num = extract_number(subdirs[-1])
        
        # Dodaj 10 nowych artykułów do progress.md
        with open(progress_file, 'a') as f:
            f.write("\n# Nowe artykuły dodane automatycznie\n\n")
            for i in range(1, 11):  # Dodaj 10 nowych artykułów
                new_num = last_num + i
                new_article = f"{new_num}.nowy-artykul-{i}"
                f.write(f"- [ ] {new_article}\n")
        
        print(f"Dodano 10 nowych artykułów do pliku progress.md")
        
        # Po dodaniu, ponownie spróbuj znaleźć pierwszy nieukończony artykuł
        with open(progress_file, 'r') as f:
            content = f.read()
        
        matches = re.findall(pattern, content)
        if matches:
            return matches[0]
        else:
            print("Nie udało się dodać nowych artykułów do pliku progress.md")
            sys.exit(1)

def get_article_title(article_input, progress_file):
    """Pobiera tytuł artykułu na podstawie numeru lub pełnej nazwy z pliku progress.md."""
    with open(progress_file, 'r') as f:
        content = f.read()
    
    # Sprawdź, czy podano pełny tytuł artykułu czy tylko numer
    if '.' in article_input:
        # Podano pełny tytuł, sprawdź czy istnieje w pliku
        
        # Najpierw sprawdź, czy artykuł nie został już oznaczony jako ukończony
        pattern_completed = r"- \[x\] " + re.escape(article_input)
        if re.search(pattern_completed, content):
            print(f"Artykuł '{article_input}' jest już oznaczony jako ukończony w pliku progress.md")
            # Zwracamy tytuł mimo to, aby można było nadpisać artykuł
            return article_input
        
        # Sprawdź czy artykuł jest do zrobienia
        pattern = r"- \[ \] " + re.escape(article_input)
        if re.search(pattern, content):
            return article_input
        else:
            # Wypisz kilka linii pliku progress.md dla debugowania
            print(f"Nie znaleziono artykułu '{article_input}' w pliku progress.md")
            print("Kilka linii z pliku progress.md:")
            lines = content.split('\n')
            # Wypisz pierwsze 10 linii
            for i in range(min(10, len(lines))):
                print(lines[i])
            print("...")
            sys.exit(1)
    else:
        # Podano tylko numer, szukamy artykułu z tym numerem
        pattern = r'- \[ \] (\d+\.[^\ \n]+)'
        matches = re.findall(pattern, content)
        
        for match in matches:
            if match.startswith(str(article_input) + '.'):
                return match
        
        print(f"Nie znaleziono artykułu o numerze {article_input} w pliku progress.md")
        sys.exit(1)

def create_article_directory(blog_dir, article_title):
    """Tworzy katalog dla artykułu."""
    article_dir = os.path.join(blog_dir, article_title)
    os.makedirs(article_dir, exist_ok=True)
    return article_dir

def get_emoji_for_topic(topic):
    """Zwraca odpowiednie emoji dla danego tematu artykułu."""
    # Słownik popularnych tematów i odpowiadających im emoji
    topic_emoji = {
        "wordpress": "🔌",
        "bezpieczeństwo": "🔒",
        "bezpieczenstwo": "🔒",
        "hosting": "🖥️",
        "domena": "🌐",
        "email": "📧",
        "mail": "📧",
        "poczta": "📧",
        "serwer": "🏢",
        "baza danych": "💾",
        "błąd": "⚠️",
        "blad": "⚠️",
        "error": "⚠️",
        "backup": "💾",
        "kopie zapasowe": "💾",
        "dns": "🌐",
        "ssl": "🔐",
        "certyfikat": "🔐",
        "http": "🌎",
        "ftp": "📤",
        "php": "🐘",
        "javascript": "📱",
        "css": "🎨",
        "nginx": "🚀",
        "apache": "🦅",
        "linux": "🐧",
        "ubuntu": "🐧",
        "centos": "🐧",
        "konfiguracja": "⚙️",
        "optymalizacja": "⚡",
        "seo": "🔍",
        "cloudflare": "☁️"
    }
    
    # Domyślne emoji, jeśli nie znaleziono dopasowania
    default_emoji = ["🏆", "🚀", "💡", "⭐", "🔥", "✨", "🌟", "🎯", "📈", "🛠️"]
    
    topic_lower = topic.lower()
    for key, emoji in topic_emoji.items():
        if key in topic_lower:
            return emoji
            
    # Jeśli nie znaleziono pasującego emoji, zwróć losowe z domyślnych
    return random.choice(default_emoji)

def prepare_article_sections(readable_title):
    """Przygotowuje propozycje sekcji na podstawie tytułu artykułu."""
    title_lower = readable_title.lower()
    
    # Podstawowe sekcje dla wszystkich artykułów
    common_sections = [
        "Wprowadzenie do tematu i kontekst",
        "Najważniejsze elementy i koncepcje",
        "Praktyczne zastosowania",
        "Najlepsze praktyki i rekomendacje",
        "Typowe problemy i ich rozwiązania",
        "FAQ - Najczęściej zadawane pytania"
    ]
    
    # Słownik zawierający specyficzne sekcje dla różnych typów artykułów
    specific_sections = {
        # WordPress
        "wordpress": [
            "Instalacja i konfiguracja WordPressa",
            "Optymalizacja wydajności WordPress",
            "Zabezpieczanie instalacji WordPress",
            "Najlepsze wtyczki i motywy dla WordPress",
            "Rozwiązywanie typowych problemów z WordPress"
        ],
        
        # Bezpieczeństwo
        "bezpieczeństwo": [
            "Najczęstsze zagrożenia bezpieczeństwa",
            "Implementacja zabezpieczeń na poziomie serwera",
            "Monitorowanie i reakcja na incydenty",
            "Szyfrowanie i ochrona danych",
            "Polityki bezpieczeństwa i zgodność z przepisami"
        ],
        "bezpieczenstwo": [
            "Najczęstsze zagrożenia bezpieczeństwa",
            "Implementacja zabezpieczeń na poziomie serwera",
            "Monitorowanie i reakcja na incydenty",
            "Szyfrowanie i ochrona danych",
            "Polityki bezpieczeństwa i zgodność z przepisami"
        ],
        
        # Hosting
        "hosting": [
            "Rodzaje usług hostingowych",
            "Wybór odpowiedniego pakietu hostingowego",
            "Konfiguracja i zarządzanie hostingiem",
            "Migracja między dostawcami hostingu",
            "Optymalizacja wydajności hostingu"
        ],
        
        # Domeny
        "domena": [
            "Proces rejestracji i zarządzania domeną",
            "Konfiguracja DNS i rekordy domenowe",
            "Transfery domen między rejestratorami",
            "Zabezpieczanie domeny przed przejęciem",
            "SEO a nazwy domen"
        ],
        
        # Email
        "email": [
            "Konfiguracja kont pocztowych",
            "Zarządzanie skrzynkami pocztowymi",
            "Zabezpieczanie poczty przed spamem",
            "Protokoły pocztowe (IMAP, POP3, SMTP)",
            "Rozwiązywanie problemów z dostarczalnością"
        ],
        "mail": [
            "Konfiguracja kont pocztowych",
            "Zarządzanie skrzynkami pocztowymi",
            "Zabezpieczanie poczty przed spamem",
            "Protokoły pocztowe (IMAP, POP3, SMTP)",
            "Rozwiązywanie problemów z dostarczalnością"
        ],
        "poczta": [
            "Konfiguracja kont pocztowych",
            "Zarządzanie skrzynkami pocztowymi",
            "Zabezpieczanie poczty przed spamem",
            "Protokoły pocztowe (IMAP, POP3, SMTP)",
            "Rozwiązywanie problemów z dostarczalnością"
        ],
        
        # Serwery
        "serwer": [
            "Architektura i komponenty serwera",
            "Monitorowanie i zarządzanie zasobami",
            "Optymalizacja wydajności serwera",
            "Konfiguracja zapory sieciowej",
            "Aktualizacje i konserwacja serwera"
        ],
        
        # Błędy
        "błąd": [
            "Przyczyny i diagnoza problemu",
            "Kroki do rozwiązania błędu",
            "Zapobieganie podobnym błędom w przyszłości",
            "Narzędzia diagnostyczne",
            "Alternatywne rozwiązania i obejścia"
        ],
        "blad": [
            "Przyczyny i diagnoza problemu",
            "Kroki do rozwiązania błędu",
            "Zapobieganie podobnym błędom w przyszłości",
            "Narzędzia diagnostyczne",
            "Alternatywne rozwiązania i obejścia"
        ],
        "error": [
            "Przyczyny i diagnoza problemu",
            "Kroki do rozwiązania błędu",
            "Zapobieganie podobnym błędom w przyszłości",
            "Narzędzia diagnostyczne",
            "Alternatywne rozwiązania i obejścia"
        ]
    }
    
    # Znajdź odpowiednie sekcje na podstawie tytułu
    selected_sections = []
    
    # Najpierw dodaj specyficzne sekcje na podstawie słów kluczowych w tytule
    for keyword, sections in specific_sections.items():
        if keyword in title_lower:
            selected_sections.extend(sections)
            break  # Wystarczy jedno dopasowanie
    
    # Jeśli nie znaleziono żadnych specyficznych sekcji, użyj wszystkich wspólnych
    if not selected_sections:
        selected_sections = common_sections
    # W przeciwnym razie dodaj kilka wspólnych sekcji, których brakuje
    else:
        # Dodaj podstawowe sekcje, które nie zostały jeszcze uwzględnione
        for section in common_sections:
            if section not in selected_sections and "FAQ" in section:  # Zawsze dodaj FAQ
                selected_sections.append(section)
    
    # Upewnij się, że sekcja FAQ jest zawsze na końcu
    if "FAQ - Najczęściej zadawane pytania" in selected_sections:
        selected_sections.remove("FAQ - Najczęściej zadawane pytania")
        selected_sections.append("FAQ - Najczęściej zadawane pytania")
    
    return selected_sections

def generate_article_content(article_title, model_name="llama3"):
    """Generuje treść artykułu używając Ollamy z ulepszonymi promptami dla lepszej jakości."""
    readable_title = article_title.split('.', 1)[1].replace('-', ' ').title()
    
    # Określ główne emoji dla tytułu na podstawie tematu
    main_emoji = get_emoji_for_topic(readable_title)
    
    # Przygotuj listę sekcji tematycznych na podstawie tematu artykułu
    sections = prepare_article_sections(readable_title)
    sections_str = "\n".join([f"- {section}" for section in sections])
    
    # Rozbudowany, szczegółowy prompt z przykładową strukturą i stylem
    prompt = f"""Napisz profesjonalny, kompleksowy i szczegółowy artykuł na blog firmy hostingowej IQHost o tytule: "{readable_title}".

## Wymagana specyfikacja artykułu:
- Długość: minimum 2500 słów
- Kompleksowe omówienie tematu z praktycznymi przykładami
- Przystępny, ale profesjonalny styl
- Atrakcyjne formatowanie z wykorzystaniem Markdown
- Artykuł musi być praktyczny, dostarczać konkretną wartość czytelnikom
- Tekst musi być wysokiej jakości, bez błędów gramatycznych i stylistycznych
- Używaj różnorodnego formatowania (pogrubienia, kursywy, listy, tabele, cytaty)

## Dokładna struktura artykułu:
1. Główny tytuł: "# {main_emoji} {readable_title}"
2. Lead/Intro: Trzymający w napięciu wstęp (2-3 zdania) wyróżniony jako cytat
3. Ekspresowe podsumowanie: 4-5 kluczowych punktów z pogrubieniem
4. Sekcja spisu treści zgodna z wytycznymi:
   ```
   ## 🗺️ Spis Treści - Twoja Mapa Drogowa
   <!-- Spis treści generowany automatycznie przez JS -->
   ```
5. Główne sekcje tematyczne (co najmniej 5-6 różnych sekcji), każda z:
   - Nagłówkami H2 rozpoczynającymi się od unikalnego emoji
   - Krótkim wprowadzeniem do sekcji
   - Szczegółowym wyjaśnieniem tematu
   - Praktycznymi przykładami, kodami, konfiguracjami (jeśli temat tego wymaga)
   - Podsekcjami H3 dla bardziej szczegółowych aspektów
   - Poradami, ostrzeżeniami lub najlepszymi praktykami
6. Sekcja FAQ z 4-5 najczęściej zadawanymi pytaniami i wyczerpującymi odpowiedziami
7. Podsumowanie z najważniejszymi wnioskami
8. Call to action kierujący do oferty IQHost

## Sugerowane sekcje dla tego artykułu:
{sections_str}

## Zaawansowane formatowanie do wykorzystania:
1. Tabele porównawcze dla różnych opcji/rozwiązań
2. Bloki cytatu (>) dla ważnych informacji, ostrzeżeń i porad
3. Bloki kodu (```) dla komend, skryptów i konfiguracji
4. Listy numerowane dla sekwencyjnych instrukcji
5. Listy punktowane dla cech, zalet/wad
6. Emoji przy nagłówkach (różne dla każdej sekcji)
7. **Pogrubienie** dla kluczowych terminów i ważnych informacji
8. *Kursywa* dla terminów technicznych lub akcentów
9. Checklisty w sekcji najlepszych praktyk:
   ```
   ### ✅ Twoja Checklista:
   * 🔍 Punkt 1
   * 🔄 Punkt 2
   * 🔒 Punkt 3
   ```

Treść musi być kompleksowa, szczegółowa i przede wszystkim praktyczna. Każda sekcja powinna zawierać konkretne porady, które czytelnik może natychmiast zastosować.

Napisz CAŁĄ treść artykułu zgodnie z tymi wymaganiami. Używaj bogatego, profesjonalnego języka i zadbaj o płynne przejścia między sekcjami. Pamiętaj o wysokiej jakości treści merytorycznej, praktycznych przykładach i wartości dla czytelnika.
"""

    system_message = '''Jesteś doświadczonym ekspertem w dziedzinie technologii, hostingu, domen i serwerów. Twoja specjalizacja to pisanie rozbudowanych, wysokiej jakości artykułów technicznych. Twoje artykuły:
1. Są kompleksowe i wyczerpują temat (minimum 2500 słów)
2. Zawierają praktyczne porady, rzeczywiste przykłady i instrukcje
3. Są starannie ustrukturyzowane z logicznym podziałem na sekcje
4. Mają profesjonalny, ale przystępny język
5. Wykorzystują bogaty Markdown do formatowania
6. Zawierają przykłady kodu, konfiguracji i komendy tam, gdzie są potrzebne
7. Opierają się na najlepszych praktykach branżowych
8. Są SEO-friendly i zawierają wszystkie istotne informacje dla czytelników

Unikasz powierzchownych wyjaśnień i zawsze dostarczasz dogłębne analizy. Podajesz alternatywne rozwiązania i omawiasz ich zalety i wady.'''

    # Definiowanie danych dla API Ollama z ulepszonymi parametrami
    data = {
        "model": model_name,
        "prompt": prompt,
        "system": system_message,
        "stream": False,
        "options": {
            "temperature": 0.75,  # Lekko zwiększona losowość dla kreatywności
            "top_p": 0.9,  # Zmniejszenie z domyślnej 1.0 dla bardziej spójnych wyników
            "top_k": 40,  # Standardowa wartość dla zbalansowanej generacji
            "num_predict": 30000,  # Zwiększenie limitu generowanych tokenów
            "repeat_penalty": 1.1  # Delikatna kara za powtórzenia dla lepszej różnorodności
        }
    }

    print(f"Generowanie rozbudowanej treści artykułu używając Ollama API z modelem {model_name}...")
    try:
        # Ollama domyślnie nasłuchuje na localhost:11434
        response = requests.post('http://mietek:11434/api/generate', json=data)
        
        if response.status_code == 200:
            content = response.json().get('response', '')
            
            # Sprawdź długość wygenerowanego tekstu
            if len(content.split()) < 1000:
                print("Wygenerowana treść jest zbyt krótka. Próbuję ponownie z innymi parametrami...")
                # Spróbuj ponownie z innymi parametrami
                data["options"]["temperature"] = 0.8
                data["options"]["top_p"] = 0.95
                data["prompt"] = prompt + "\n\nPAMIĘTAJ: Artykuł musi być szczegółowy, kompleksowy i mieć MINIMUM 2500 słów długości. Każda sekcja musi być rozbudowana, z wieloma przykładami i szczegółowymi wyjaśnieniami."
                
                response = requests.post('http://mietek:11434/api/generate', json=data)
                if response.status_code == 200:
                    content = response.json().get('response', '')
            
            # Usuń ewentualne otaczające bloki kodu
            content = re.sub(r'^```markdown\s*', '', content)
            content = re.sub(r'\s*```$', '', content)
            content = re.sub(r'<think>.*?</think>', '', content, flags=re.DOTALL)
            
            # Napraw spis treści - zastąp każdy wygenerowany spis treści na właściwy format
            toc_pattern = r'## .*Spis Treści.*\n(?:(?!##).*\n)*'
            content = re.sub(toc_pattern, '## 🗺️ Spis Treści - Twoja Mapa Drogowa\n<!-- Spis treści generowany automatycznie przez JS -->\n\n---\n\n', content, flags=re.DOTALL)
            
            # Napraw formatowanie emoji w nagłówkach jeśli jest potrzebne
            content = re.sub(r'##\s+([^🏆💡⭐🔥✨🚀⏱️🧰🛠️🔧🔍🎯📊📈🔒🌐📱💾🖥️⚙️🔔🎬🎮🎨🔬📚📋🏷️🌟])', r'## 🔹 \1', content)
            
            # Upewnij się, że główny tytuł ma odpowiednie emoji
            content = re.sub(r'^# ([^🏆💡⭐🔥✨🚀⏱️🧰🛠️])', f'# {main_emoji} \\1', content)
            
            # Dodatkowo sprawdź i popraw kod HTML w treści
            content = html.unescape(content)
            
            return content.strip()
        else:
            print(f"Błąd API Ollama przy generowaniu treści: {response.status_code} - {response.text}")
            return None
    except Exception as e:
        print(f"Wystąpił błąd podczas komunikacji z Ollama: {str(e)}")
        return None

def create_yaml_metadata(article_title):
    """Tworzy sekcję metadanych YAML zgodnie z wytycznymi z README.md."""
    readable_title = article_title.split('.', 1)[1].replace('-', ' ').title()
    slug = article_title.split('.', 1)[1]
    current_date = datetime.now().strftime('%Y-%m-%d %H:%M')

    # Generowanie tagów z tytułu
    words = [word.strip() for word in readable_title.lower().split() if len(word) > 3]
    keywords = list(set(words))  # Usuń duplikaty
    
    # Dodatkowe słowa kluczowe na podstawie kontekstu
    context_keywords = []
    for word in words:
        if "wordpress" in word:
            context_keywords.extend(["cms", "blog", "wtyczki", "motywy"])
        elif "hosting" in word:
            context_keywords.extend(["serwer", "domena", "www", "strona"])
        elif "bezpiecz" in word:
            context_keywords.extend(["ochrona", "zabezpieczenia", "firewall", "ssl"])
        elif "błąd" in word or "blad" in word or "error" in word:
            context_keywords.extend(["problem", "naprawa", "rozwiązanie", "diagnostyka"])
        elif "email" in word or "mail" in word or "poczta" in word:
            context_keywords.extend(["wiadomość", "skrzynka", "smtp", "imap"])
    
    # Dodaj kontekstowe słowa kluczowe do głównej listy, unikając duplikatów
    for kw in context_keywords:
        if kw not in keywords:
            keywords.append(kw)
    
    # Wybierz do 10 najlepszych słów kluczowych
    keywords = keywords[:10]
    
    # Tagi - wybierz 3-5 najważniejszych i sformatuj je
    tags = [tag.capitalize() for tag in words[:min(5, len(words))]]
    tags = list(set(tags))  # Usuń duplikaty

    # Kategorie
    categories = ["Hosting"]
    keywords_lower = readable_title.lower()
    
    if any(word in keywords_lower for word in ["wordpress", "wp", "cms"]):
        categories.append("WordPress")
    if any(word in keywords_lower for word in ["błąd", "blad", "problem", "error", "naprawa", "naprawić"]):
        categories.append("Błędy Serwera")
    if any(word in keywords_lower for word in ["bezpieczeństwo", "bezpieczenstwo", "zabezpiecz", "ochrona", "firewall", "ssl"]):
        categories.append("Bezpieczeństwo")
    if any(word in keywords_lower for word in ["serwer", "vps", "dedykowany"]):
        categories.append("Serwery")
    if any(word in keywords_lower for word in ["email", "poczta", "mail", "smtp", "imap", "pop3"]):
        categories.append("Email")
    
    # Usuń duplikaty z kategorii
    categories = list(dict.fromkeys(categories))

    # Opis
    description = f"Dowiedz się wszystkiego o: {readable_title}. Kompleksowy przewodnik wyjaśniający {slug.replace('-', ' ')} - przydatne porady od IQHost."

    yaml = f"""---
title: {readable_title}
slug: {slug}
description: "{description[:160]}"
keywords: [{', '.join(keywords)}]
tags: [{', '.join(tags)}]
author: Zespół IQHost
date: {current_date}
process: 
  markdown: true
taxonomy:
  category:
{chr(10).join(['    - ' + category for category in categories])}
classes:
  quick-start: true
  info: true
  tip: true
  warning: true
  checklist: true
  cta-banner: true
---

"""
    return yaml

def save_article(article_dir, article_title, article_content):
    """Zapisuje artykuł do pliku post.md."""
    yaml_metadata = create_yaml_metadata(article_title)
    full_content = yaml_metadata + article_content
    
    with open(os.path.join(article_dir, 'post.md'), 'w') as f:
        f.write(full_content)

def create_empty_image_placeholder(article_dir):
    """Tworzy pusty plik placeholder dla obrazu."""
    with open(os.path.join(article_dir, 'main.png.txt'), 'w') as f:
        f.write("To jest placeholder dla obrazu głównego artykułu.")

def update_progress_file(progress_file, article_title):
    """Aktualizuje plik progress.md, zmieniając status artykułu na ukończony."""
    with open(progress_file, 'r') as f:
        content = f.read()
    
    # Zmień status artykułu z [ ] na [x]
    updated_content = content.replace(f'- [ ] {article_title}', f'- [x] {article_title}')
    
    with open(progress_file, 'w') as f:
        f.write(updated_content)

def create_progress_file(blog_dir):
    """Tworzy plik progress.md na podstawie istniejących katalogów jeśli nie istnieje."""
    progress_file = os.path.join(blog_dir, 'progress.md')
    
    # Sprawdź czy plik progress.md istnieje
    if os.path.exists(progress_file):
        print(f"Plik {progress_file} już istnieje. Używam istniejącego pliku.")
        return progress_file
        
    print(f"Tworzę nowy plik {progress_file} na podstawie istniejących katalogów...")
    
    # Lista wszystkich katalogów w blog_dir
    subdirs = [d for d in os.listdir(blog_dir) if os.path.isdir(os.path.join(blog_dir, d))]
    
    # Sortowanie katalogów numerycznie
    def extract_number(dirname):
        try:
            return int(dirname.split('.')[0])
        except (ValueError, IndexError):
            return 999999  # Dla katalogów bez numeru
    
    subdirs.sort(key=extract_number)
    
    # Tworzenie zawartości pliku progress.md
    content = "# Postęp pisania artykułów\n\n"
    
    # Dodawanie istniejących katalogów jako ukończone artykuły
    for subdir in subdirs:
        content += f"- [x] {subdir}\n"
    
    # Opcjonalnie, dodaj pewną liczbę placeholderów dla przyszłych artykułów
    if subdirs:
        last_num = extract_number(subdirs[-1])
        for i in range(1, 11):  # Dodaj 10 nowych artykułów
            new_num = last_num + i
            content += f"- [ ] {new_num}.nowy-artykul-{i}\n"
    
    # Zapisz plik
    with open(progress_file, 'w') as f:
        f.write(content)
    
    print(f"Utworzono plik {progress_file} z {len(subdirs)} ukończonymi artykułami.")
    return progress_file

def generate_sample_content(article_title):
    """Generuje przykładową treść artykułu bez korzystania z API."""
    readable_title = article_title.split('.', 1)[1].replace('-', ' ').title()
    
    # Określ główne emoji dla tytułu na podstawie tematu
    main_emoji = get_emoji_for_topic(readable_title)
    
    content = f"""
# {main_emoji} {readable_title}

> "Poznanie zaawansowanych rozwiązań technologicznych to klucz do efektywnego zarządzania infrastrukturą internetową. W tym artykule przedstawiamy kompleksowy przewodnik, który pomoże Ci opanować {readable_title.lower()} i wykorzystać tę wiedzę w praktyce." - zespół ekspertów IQHost

### ⚡ Ekspresowe Podsumowanie:

1. **Kluczowy punkt 1:** {readable_title} to fundamentalny element nowoczesnej infrastruktury internetowej, wymagający odpowiedniego podejścia.
2. **Kluczowy punkt 2:** Prawidłowa implementacja zwiększa wydajność, bezpieczeństwo i stabilność Twojego środowiska.
3. **Kluczowy punkt 3:** Regularne aktualizacje i monitoring zapewniają optymalne działanie i minimalizują ryzyko awarii.
4. **Kluczowy punkt 4:** Kompleksowe zabezpieczenia chronią Twoje dane i zapewniają zgodność z aktualnymi standardami branżowymi.

---

## 🗺️ Spis Treści - Twoja Mapa Drogowa
<!-- Spis treści generowany automatycznie przez JS -->

---

## 📚 Wprowadzenie do {readable_title}

{readable_title} to kluczowy element w ekosystemie nowoczesnych technologii internetowych. Zrozumienie jego fundamentalnych zasad działania jest niezbędne dla każdego profesjonalisty zarządzającego infrastrukturą online. W tej sekcji przedstawimy kompleksowe wprowadzenie do tematu, omawiając jego historię, zastosowania oraz najważniejsze koncepcje.

### Historia i ewolucja

Początki {readable_title.lower()} sięgają wczesnych lat rozwoju technologii internetowych. Na przestrzeni lat rozwiązanie to przeszło znaczącą ewolucję:

* **Wczesne implementacje (lata 90.)**: Pierwsze wersje charakteryzowały się prostotą i ograniczoną funkcjonalnością.
* **Rozwój w latach 2000-2010**: Wprowadzenie standardów branżowych i integracja z nowoczesnymi systemami.
* **Aktualne rozwiązania**: Zaawansowane implementacje wspierające automatyzację, skalowalność i bezpieczeństwo.

### Kluczowe koncepcje i terminologia

Przed zagłębieniem się w szczegóły techniczne, warto zrozumieć fundamentalne pojęcia związane z tematem:

| **Termin** | **Definicja** | **Zastosowanie** |
|----------|-------------|----------------|
| Komponent A | Podstawowy element infrastruktury | Zarządzanie zasobami |
| Protokół B | Standard komunikacji | Wymiana danych między systemami |
| Mechanizm C | Zestaw procedur zabezpieczających | Ochrona przed nieautoryzowanym dostępem |

## 💡 Praktyczne zastosowania {readable_title}

W dzisiejszym cyfrowym świecie, gdzie każda sekunda ma znaczenie, a bezpieczeństwo danych jest priorytetem, prawidłowe wykorzystanie {readable_title.lower()} może stanowić o przewadze konkurencyjnej. Ta sekcja prezentuje konkretne scenariusze implementacji i korzyści płynące z właściwego zastosowania.

### Zwiększenie wydajności i optymalizacja

Odpowiednio zoptymalizowane {readable_title.lower()} może znacząco przyspieszyć działanie Twojej infrastruktury, co bezpośrednio przekłada się na lepsze doświadczenia użytkowników i wyższe wyniki biznesowe.

```bash
# Przykładowa komenda optymalizacji
system optimize --component={readable_title.lower()} --level=advanced
```

Optymalizacja przynosi wymierne korzyści:
1. Redukcja czasów odpowiedzi o 40-60%
2. Zmniejszenie obciążenia serwera o 25-30%
3. Zwiększenie przepustowości dla równoczesnych żądań

### Poprawa bezpieczeństwa i stabilności

**Bezpieczeństwo danych** to jeden z najważniejszych aspektów każdego projektu internetowego. Implementacja najlepszych praktyk w zakresie {readable_title.lower()} pozwala na:

1. Ochronę przed najpopularniejszymi wektorami ataków
2. Zabezpieczenie danych użytkowników zgodnie z regulacjami (RODO/GDPR)
3. Minimalizację ryzyka nieautoryzowanego dostępu
4. Wdrożenie zaawansowanych mechanizmów monitorowania i alertów

> **Wskazówka eksperta:** Zawsze implementuj mechanizm podwójnej weryfikacji dla krytycznych operacji i regularnie przeprowadzaj audyty bezpieczeństwa infrastruktury. Nawet najlepiej zaprojektowany system wymaga cyklicznych przeglądów.

## 🔧 Konfiguracja i wdrożenie {readable_title}

Poprawna konfiguracja to klucz do sukcesu. W tej sekcji przedstawiamy szczegółowy, krok po kroku proces wdrożenia, uwzględniający różne środowiska i scenariusze zastosowań.

### Przygotowanie środowiska

Przed rozpoczęciem właściwej konfiguracji, należy odpowiednio przygotować środowisko:

1. **Aktualizacja systemu:**
   ```bash
   apt-get update && apt-get upgrade -y
   ```

2. **Instalacja niezbędnych komponentów:**
   ```bash
   apt-get install example-package libsupport-tools advanced-utilities
   ```

3. **Weryfikacja wymagań systemowych:**
   - Minimum 4GB RAM
   - 20GB wolnej przestrzeni dyskowej
   - Procesor 2+ rdzenie (4+ zalecane dla środowisk produkcyjnych)
   - Połączenie sieciowe o przepustowości min. 100Mbps

### Podstawowa konfiguracja

Po przygotowaniu środowiska można przystąpić do właściwej konfiguracji:

```bash
# Utworzenie katalogu konfiguracyjnego
mkdir -p /etc/example-config/{readable_title.lower()}

# Konfiguracja podstawowych parametrów
nano /etc/example-config/{readable_title.lower()}/main.conf
```

Przykładowy plik konfiguracyjny:
```ini
[General]
Mode = production
LogLevel = warn
MaxConnections = 1000

[Security]
EnableFirewall = true
AllowedIPs = 192.168.1.0/24,10.0.0.0/8
BlockBruteForce = true
```

### Zaawansowana konfiguracja dla środowisk wysokiej dostępności

Dla wymagających zastosowań biznesowych zalecamy wdrożenie konfiguracji wysokiej dostępności:

1. **Konfiguracja klastra:**
   - Minimum 3 węzły dla zapewnienia quorum
   - Wspólne mechanizmy synchronizacji stanu
   - Automatyczny failover

2. **Monitorowanie i alerting:**
   - Integracja z systemami monitorowania (Nagios, Prometheus, Grafana)
   - Alerty SMS/email dla krytycznych zdarzeń
   - Automatyczne mechanizmy naprawcze

## 🚀 Najlepsze praktyki i optymalizacja

Aby maksymalnie wykorzystać potencjał {readable_title.lower()}, rekomendujemy stosowanie się do następujących najlepszych praktyk branżowych:

* **Regularne aktualizacje** - zapewniają bezpieczeństwo i dostęp do najnowszych funkcji
* **Kompleksowy monitoring** - umożliwia szybkie wykrycie i rozwiązanie potencjalnych problemów
* **Optymalizacja wydajności** - dostosowanie parametrów do konkretnych potrzeb zwiększa efektywność
* **Strategie backupu** - regularne kopie zapasowe zabezpieczają przed utratą danych
* **Automatyzacja rutynowych zadań** - skrypty i narzędzia automatyzacji redukują ryzyko błędu ludzkiego

### ✅ Twoja Checklista Wdrożeniowa:

* 🔍 Przeprowadź audyt aktualnej infrastruktury i zidentyfikuj obszary wymagające poprawy
* 🔄 Upewnij się, że automatyczne aktualizacje są poprawnie skonfigurowane
* 🔒 Zweryfikuj ustawienia bezpieczeństwa i usuń potencjalne luki
* 📊 Skonfiguruj kompleksowy system monitoringu kluczowych metryk
* 💾 Wdróż automatyczne backupy z weryfikacją przywracania
* 📝 Dokumentuj wszystkie zmiany i procedury dla zespołu

## ❓ FAQ - Odpowiedzi na Twoje Pytania

**Jak często należy aktualizować {readable_title}?**  
Zalecamy sprawdzanie dostępności aktualizacji przynajmniej raz w miesiącu. Krytyczne aktualizacje bezpieczeństwa powinny być wdrażane niezwłocznie, natomiast aktualizacje funkcjonalne można planować zgodnie z cyklem rozwojowym aplikacji.

**Czy {readable_title} działa na wszystkich systemach operacyjnych?**  
Tak, większość rozwiązań jest kompatybilna z popularnymi systemami Linux (Ubuntu, CentOS, Debian), a także z Windows Server. Specyficzne funkcjonalności mogą różnić się w zależności od platformy, dlatego zawsze należy zapoznać się z dokumentacją dla konkretnej wersji.

**Jak rozwiązać problem niskiej wydajności {readable_title}?**  
Najczęstszymi przyczynami spadku wydajności są: nieoptymalna konfiguracja, niewystarczające zasoby sprzętowe, brak indeksów w bazach danych oraz nieprawidłowe zarządzanie pamięcią podręczną. Zalecamy przeprowadzenie audytu wydajności oraz implementację rozwiązań odpowiednich dla zidentyfikowanych wąskich gardeł.

**Jakie są alternatywy dla {readable_title}?**  
Na rynku dostępnych jest kilka alternatywnych rozwiązań, takich jak System X, Platforma Y oraz Framework Z. Każde z nich ma swoje zalety i wady, a wybór najlepszego rozwiązania powinien uwzględniać specyficzne wymagania projektu, budżet oraz dostępne kompetencje zespołu.

**Jak zabezpieczyć {readable_title} przed nieautoryzowanym dostępem?**  
Rekomendujemy wdrożenie wielowarstwowej strategii bezpieczeństwa obejmującej: konfigurację zapory sieciowej, mechanizmy uwierzytelniania dwuskładnikowego, regularne aktualizacje, szyfrowanie danych wrażliwych, audyty bezpieczeństwa oraz szkolenia personelu z rozpoznawania zagrożeń.

## 🏁 Podsumowanie - Gotowy na Sukces?

{readable_title} stanowi fundamentalny element nowoczesnej infrastruktury internetowej. Dzięki właściwej konfiguracji, regularnym aktualizacjom i stosowaniu najlepszych praktyk branżowych możesz znacząco zwiększyć wydajność, bezpieczeństwo i niezawodność swoich systemów online.

Kluczowe wnioski z tego artykułu:
1. Prawidłowe wdrożenie wymaga dokładnego planowania i zrozumienia specyficznych potrzeb projektu
2. Regularne aktualizacje stanowią fundament bezpieczeństwa i stabilności
3. Monitoring i proaktywne działania pozwalają unikać większości problemów
4. Dokumentacja i automatyzacja redukują ryzyko błędów i upraszczają zarządzanie

**🚀 Potrzebujesz profesjonalnego wsparcia?**

[Sprawdź ofertę hostingową IQHost](https://iqhost.pl/oferta)

*Nasi eksperci pomogą Ci zoptymalizować Twoją infrastrukturę i rozwiązać nawet najbardziej skomplikowane problemy techniczne. Skontaktuj się z nami już dziś!*
"""
    
    return content

def check_ollama_availability():
    """Sprawdza, czy Ollama API jest dostępne."""
    try:
        response = requests.get('http://mietek:11434/api/tags')
        if response.status_code == 200:
            models = response.json().get('models', [])
            if models:
                print(f"Dostępne modele Ollama: {', '.join([model['name'] for model in models])}")
                return True
            else:
                print("Ollama jest uruchomiona, ale nie znaleziono żadnych modeli.")
                return False
        else:
            print(f"Błąd podczas sprawdzania dostępności Ollama: {response.status_code} - {response.text}")
            return False
    except Exception as e:
        print(f"Nie można połączyć się z Ollama API: {str(e)}")
        print("Upewnij się, że Ollama jest zainstalowana i uruchomiona.")
        return False

def main():
    parser = argparse.ArgumentParser(description='Generuje wysokiej jakości artykuł dla bloga na podstawie numeru lub pełnej nazwy używając modeli Ollama.')
    parser.add_argument('article_input', type=str, nargs='?', help='Numer artykułu lub pełna nazwa artykułu do wygenerowania')
    parser.add_argument('--next', action='store_true', help='Wygeneruj pierwszy nieukończony artykuł z listy')
    parser.add_argument('--check', action='store_true', help='Tylko sprawdź czy artykuł istnieje, bez generowania treści')
    parser.add_argument('--sample-content', action='store_true', help='Użyj przykładowej treści zamiast generowania przez Ollama')
    parser.add_argument('--create-progress', action='store_true', help='Utwórz plik progress.md na podstawie katalogów, jeśli nie istnieje')
    parser.add_argument('--model', type=str, default='phi3', help='Nazwa modelu Ollama do użycia (domyślnie: phi3)')
    args = parser.parse_args()
    
    # Ścieżki
    blog_dir = '/home/stephen/claude/iqhost.pl/content/blog'
    
    # Sprawdź, czy Ollama jest dostępna
    if not args.sample_content and not args.check:
        if not check_ollama_availability():
            print("Kontynuowanie z przykładową treścią...")
            args.sample_content = True
    
    # Sprawdź, czy mamy plik progress.md, jeśli nie - utwórz go na podstawie katalogów
    progress_file = os.path.join(blog_dir, 'progress.md')
    if not os.path.exists(progress_file) or args.create_progress:
        progress_file = create_progress_file(blog_dir)
    
    # Sprawdź, czy chcemy wygenerować pierwszy nieukończony artykuł
    if args.next:
        article_title = get_first_todo_article(progress_file, blog_dir)
        print(f"Wybrany pierwszy nieukończony artykuł: {article_title}")
    elif args.article_input:
        # Sprawdźmy, czy artykuł istnieje w pliku progress.md
        try:
            article_title = get_article_title(args.article_input, progress_file)
            print(f"Znaleziono artykuł: {article_title}")
        except SystemExit:
            # Jeśli get_article_title zakończyło się błędem, pokaż zawartość pliku progress.md
            print("\nWypisuję fragment zawartości pliku progress.md:")
            with open(progress_file, 'r') as f:
                content = f.readlines()
                # Szukaj linii zawierających podobne wzorce
                for i, line in enumerate(content):
                    if args.article_input.split('.')[0] in line:
                        print(f"Linia {i+1}: {line.strip()}")
            sys.exit(1)
    else:
        parser.print_help()
        sys.exit(1)
    
    # Tryb diagnostyczny - tylko sprawdzenie
    if args.check:
        print(f"Artykuł {article_title} został znaleziony i może być wygenerowany.")
        sys.exit(0)
    
    print(f"Generowanie artykułu: {article_title}")
    
    # Utwórz katalog dla artykułu
    article_dir = create_article_directory(blog_dir, article_title)
    
    # Generowanie treści
    if args.sample_content:
        # Użyj przykładowej treści
        article_content = generate_sample_content(article_title)
    else:
        try:
            # Wygeneruj treść artykułu używając Ollama
            article_content = generate_article_content(article_title, args.model)
            
            if article_content is None:
                print("Nie udało się wygenerować treści artykułu. Użyję przykładowej treści.")
                article_content = generate_sample_content(article_title)
            elif len(article_content.split()) < 800:
                print(f"Wygenerowana treść jest za krótka (tylko {len(article_content.split())} słów). Używam przykładowej treści.")
                article_content = generate_sample_content(article_title)
        except Exception as e:
            print(f"Błąd podczas generowania treści: {str(e)}")
            print("Używam przykładowej treści...")
            article_content = generate_sample_content(article_title)
    
    # Zapisz artykuł
    save_article(article_dir, article_title, article_content)
    print(f"Artykuł zapisany w: {os.path.join(article_dir, 'post.md')}")
    
    # Utwórz placeholder dla obrazu
    create_empty_image_placeholder(article_dir)
    print(f"Utworzono placeholder dla obrazu: {os.path.join(article_dir, 'main.png.txt')}")
    
    # Aktualizuj plik progress.md
    update_progress_file(progress_file, article_title)
    print(f"Plik progress.md zaktualizowany, artykuł oznaczony jako ukończony.")
    
    # Wyświetl statystyki wygenerowanego artykułu
    word_count = len(article_content.split())
    print(f"\nStatystyki artykułu:")
    print(f"- Liczba słów: {word_count}")
    print(f"- Szacowany czas czytania: {word_count // 200} min")
    
    # Sugestia uruchomienia na innym modelu jeśli artykuł jest za krótki
    if word_count < 1500 and not args.sample_content:
        print("\nSugestia: Wygenerowany artykuł jest dość krótki. Możesz spróbować wygenerować go ponownie")
        print("używając innego modelu, na przykład:")
        print(f"python3 create_article_ollama_v2.py {article_title} --model mistral")

if __name__ == '__main__':
    main()