import os
import re
import argparse
import shutil
from PIL import Image

# --- Konfiguracija skripte ---
PROJECT_ROOT = os.path.dirname(os.path.abspath(__file__)) # Predvideva, da je skripta v root direktoriju projekta

IMAGES_DIR_NAME = "images"
ORIGINAL_IMAGES_SUBDIR_NAME = "original" # Podmapa znotraj IMAGES_DIR_NAME

# Mape, v katerih skripta išče datoteke za posodobitev referenc
DIRECTORIES_TO_SCAN = ['en', 'si', 'mk', 'css'] 
# Dodatne datoteke v korenski mapi za preverjanje
FILES_IN_ROOT_TO_SCAN = ['main.js']

# Končnice datotek, v katerih iščemo in posodabljamo reference na slike
FILE_EXTENSIONS_TO_UPDATE = ['.html', '.css', '.js'] 

WEBP_QUALITY = 80 # Kakovost kompresije za WebP (0-100). Višja številka = boljša kakovost, večja datoteka.
MAX_IMAGE_DIMENSION = 1920 # Maksimalna dimenzija (širina ali višina) za pomanjšanje, če je slika večja. Ohranijo se razmerja. Če je 0, se ne pomanjšuje.

IMAGE_EXTENSIONS_TO_OPTIMIZE = ['.jpg', '.jpeg', '.png', '.gif'] # Končnice datotek, ki jih želimo optimizirati
EXCLUDE_FILES_FROM_OPTIMIZATION = [
    '1-logo.png',       # Logotip, ki ga morda ne želimo spreminjati
    '13-whitelogo.png', # Beli logotip, ki ga morda ne želimo spreminjati
    'favicon.ico'       # Ikona, ki ni slikovni format, ki ga Pillow lahko enostavno pretvori v WebP
    # Dodaj še druga imena datotek, ki jih želiš izključiti iz optimizacije
]

# --- Pomožne funkcije ---

def optimize_image(image_path, output_path, quality, max_dim, dry_run=False):
    """
    Naloži sliko, jo po potrebi pomanjša, optimizira in pretvori v WebP format.
    """
    try:
        with Image.open(image_path) as img:
            original_size = img.size
            
            if img.mode in ('P', 'LA', 'RGBA'):
                if img.mode != 'RGBA':
                    img = img.convert("RGBA")
            
            if max_dim > 0 and (img.width > max_dim or img.height > max_dim):
                print(f"  Pomanjšujem sliko {os.path.basename(image_path)} iz {img.width}x{img.height} ...", end="")
                img.thumbnail((max_dim, max_dim), Image.LANCZOS)
                print(f" na {img.width}x{img.height}")
            else:
                print(f"  Obdelujem sliko {os.path.basename(image_path)} ({img.width}x{img.height})...", end="")

            if not dry_run:
                img.save(output_path, "webp", quality=quality, method=6)
                print(f" Shrani v {os.path.basename(output_path)} (kvaliteta: {quality}).")
            else:
                print(f" DRY RUN: Shranil bi v {os.path.basename(output_path)} (kvaliteta: {quality}).")

            return True
    except FileNotFoundError:
        print(f"  Napaka: Izvorna slika '{image_path}' ni najdena.")
        return False
    except Exception as e:
        print(f"  Napaka pri optimizaciji slike '{image_path}': {e}")
        return False

def update_file_references(file_path, old_filename_with_ext, new_filename_with_ext, dry_run=False):
    """
    Poišče staro ime slike v datoteki (HTML, CSS, JS) in ga zamenja z novim imenom WebP.
    """
    try:
        with open(file_path, 'r', encoding='utf-8') as f:
            content = f.read()
    except Exception as e:
        print(f"  Napaka pri branju datoteke '{file_path}': {e}")
        return False

    original_content = content
    # Uporabimo preprosto zamenjavo niza, ki je varna, saj zamenjujemo celotno ime datoteke z končnico.
    # To bo delovalo za poti v narekovajih (HTML, JS) in v url() (CSS).
    if old_filename_with_ext in content:
        content = content.replace(old_filename_with_ext, new_filename_with_ext)

    if content != original_content:
        if not dry_run:
            backup_path = file_path + ".bak"
            try:
                # Preverimo, ali datoteka obstaja, preden jo kopiramo
                if os.path.exists(file_path):
                    shutil.copy2(file_path, backup_path)
            except Exception as e:
                print(f"  Napaka pri ustvarjanju varnostne kopije za '{file_path}': {e}")
                return False

            try:
                with open(file_path, 'w', encoding='utf-8') as f:
                    f.write(content)
                print(f"  Posodobljene reference za '{old_filename_with_ext}' v '{os.path.relpath(file_path, PROJECT_ROOT)}'.")
                return True
            except Exception as e:
                print(f"  Napaka pri zapisovanju v datoteko '{file_path}': {e}")
                return False
        else:
            print(f"  DRY RUN: Reference za '{old_filename_with_ext}' bi bile posodobljene v '{os.path.relpath(file_path, PROJECT_ROOT)}'.")
            return True
    return False


def find_files_to_update(scan_dirs, root_files):
    """
    Rekurzivno poišče vse datoteke z ustreznimi končnicami v podanih mapah.
    """
    found_files = []
    # Najprej poišči datoteke v navedenih mapah
    for directory in scan_dirs:
        dir_path = os.path.join(PROJECT_ROOT, directory)
        if os.path.isdir(dir_path):
            for dirpath, _, filenames in os.walk(dir_path):
                for filename in filenames:
                    if any(filename.endswith(ext) for ext in FILE_EXTENSIONS_TO_UPDATE):
                        found_files.append(os.path.join(dirpath, filename))
        else:
             print(f"Opozorilo: Mapa za skeniranje '{dir_path}' ne obstaja. Preskakujem.")

    # Nato dodaj posamezne datoteke iz korenske mape
    for filename in root_files:
        file_path = os.path.join(PROJECT_ROOT, filename)
        if os.path.isfile(file_path):
            found_files.append(file_path)

    # Vrne unikaten, sortiran seznam poti
    return sorted(list(set(found_files)))

# --- Glavna funkcija ---

def main():
    parser = argparse.ArgumentParser(description="Skripta za optimizacijo slik (pretvorba v WebP) in posodobitev referenc v HTML, CSS in JS datotekah.")
    parser.add_argument("--dry-run", action="store_true", help="Izvede operacije, vendar ne spreminja datotek in ne premika originalnih slik.")
    args = parser.parse_args()

    images_full_path = os.path.join(PROJECT_ROOT, IMAGES_DIR_NAME)
    original_images_full_path = os.path.join(images_full_path, ORIGINAL_IMAGES_SUBDIR_NAME)

    if not os.path.isdir(images_full_path):
        print(f"Napaka: Mapa s slikami '{images_full_path}' ne obstaja. Preverite konfiguracijo.")
        return

    if not args.dry_run:
        os.makedirs(original_images_full_path, exist_ok=True)
        print(f"Mapa za originalne slike: '{original_images_full_path}' (ustvarjena, če ni obstajala).")
    else:
        print(f"DRY RUN: Mapa za originalne slike bi bila '{original_images_full_path}'.")


    optimized_images_map = []
    
    print("\n--- ZAČETEK OPTIMIZACIJE SLIK ---")
    for filename in os.listdir(images_full_path):
        if filename == ORIGINAL_IMAGES_SUBDIR_NAME:
            continue
        
        file_path = os.path.join(images_full_path, filename)

        if os.path.isfile(file_path):
            name, ext = os.path.splitext(filename)
            ext = ext.lower()

            if filename in EXCLUDE_FILES_FROM_OPTIMIZATION:
                print(f"  Preskakujem izključeno datoteko: '{filename}'.")
                continue

            if ext in IMAGE_EXTENSIONS_TO_OPTIMIZE:
                new_filename = f"{name}.webp"
                new_file_path = os.path.join(images_full_path, new_filename)
                
                if os.path.exists(new_file_path) and os.path.getmtime(new_file_path) > os.path.getmtime(file_path):
                    print(f"  WebP različica '{new_filename}' že obstaja in je novejša od originala. Preskakujem optimizacijo.")
                    optimized_images_map.append({'old_name': filename, 'new_name': new_filename})
                    continue

                if optimize_image(file_path, new_file_path, WEBP_QUALITY, MAX_IMAGE_DIMENSION, args.dry_run):
                    optimized_images_map.append({'old_name': filename, 'new_name': new_filename})
                    if not args.dry_run:
                        try:
                            shutil.move(file_path, os.path.join(original_images_full_path, filename))
                            print(f"  Originalna slika premaknjena: '{filename}' -> '{ORIGINAL_IMAGES_SUBDIR_NAME}/'.")
                        except Exception as e:
                            print(f"  Napaka pri premikanju originalne slike '{filename}': {e}")
                    else:
                        print(f"  DRY RUN: Originalna slika '{filename}' bi bila premaknjena v '{ORIGINAL_IMAGES_SUBDIR_NAME}/'.")
                
            else:
                print(f"  Preskakujem datoteko (ni slika za optimizacijo): '{filename}'.")

    if not optimized_images_map:
        print("\nNi slik za optimizacijo ali pa so že optimizirane. Preskakujem posodabljanje referenc.")
        print("\n--- OPTIMIZACIJA SLIK ZAKLJUČENA ---")
        return

    print("\n--- ZAČETEK POSODABLJANJA REFERENC V DATOTEKAH ---")
    
    all_files_to_update = find_files_to_update(DIRECTORIES_TO_SCAN, FILES_IN_ROOT_TO_SCAN)

    if not all_files_to_update:
        print("Ni najdenih datotek za posodobitev referenc (.html, .css, .js).")
        print("\n--- OPTIMIZACIJA SLIK ZAKLJUČENA ---")
        return

    updated_files_count = 0
    processed_files = set()

    for file_path in all_files_to_update:
        if file_path in processed_files:
            continue

        file_changed_in_this_run = False
        for img_info in optimized_images_map:
            if update_file_references(file_path, img_info['old_name'], img_info['new_name'], args.dry_run):
                file_changed_in_this_run = True
        
        if file_changed_in_this_run:
            updated_files_count += 1
        
        processed_files.add(file_path)
            
    print(f"\nPregledanih je bilo {len(all_files_to_update)} datotek.")
    print(f"Posodobljenih je bilo {updated_files_count} datotek (vključno z DRY RUN).")
    print("\n--- OPTIMIZACIJA SLIK ZAKLJUČENA ---")

if __name__ == "__main__":
    main()