"""
Explorační skript: projde všechny fotky v demo_fotky/ a vytáhne maximum dat.
Výstup do konzole + JSON soubor pro detailní analýzu.
"""
import hashlib
import json
import os
import re
import sys
from datetime import datetime
from pathlib import Path

# Windows konzole - vynutit UTF-8
if sys.stdout.encoding.lower() != "utf-8":
    sys.stdout.reconfigure(encoding="utf-8")
    sys.stderr.reconfigure(encoding="utf-8")

import exifread
import imagehash
from PIL import Image, ImageOps, IptcImagePlugin
from PIL.ExifTags import TAGS, GPSTAGS

PHOTOS_DIR = Path(__file__).parent / "demo_fotky"
OUTPUT_JSON = Path(__file__).parent / "photo_exploration.json"


def file_hash_sha256(path: Path, chunk_size: int = 65536) -> str:
    """Hash celého souboru - detekce přesné kopie."""
    h = hashlib.sha256()
    with open(path, "rb") as f:
        while chunk := f.read(chunk_size):
            h.update(chunk)
    return h.hexdigest()


def pixel_hash_sha256(path: Path) -> str | None:
    """Hash dekódovaných pixelů - identita fotky nezávisle na metadatech.
    Aplikuje EXIF orientation pro konzistenci."""
    try:
        with Image.open(path) as img:
            img = ImageOps.exif_transpose(img)
            if img.mode != "RGB":
                img = img.convert("RGB")
            return hashlib.sha256(img.tobytes()).hexdigest()
    except Exception as e:
        return None


def perceptual_hashes(path: Path) -> dict:
    """Perceptuální hashe - detekce vizuálně podobných fotek.
    Každý hash je 64-bit, porovnává se Hamming distance."""
    out = {}
    try:
        with Image.open(path) as img:
            img = ImageOps.exif_transpose(img)
            out["phash"] = str(imagehash.phash(img))
            out["dhash"] = str(imagehash.dhash(img))
            out["ahash"] = str(imagehash.average_hash(img))
            out["whash"] = str(imagehash.whash(img))
    except Exception as e:
        out["_error"] = str(e)
    return out


def iptc_info(path: Path) -> dict:
    """IPTC metadata - keywords, title, description, author atd."""
    out = {}
    # Mapování IPTC numerických tagů na čitelné názvy
    iptc_names = {
        (2, 5):   "ObjectName",       # Title
        (2, 10):  "Urgency",
        (2, 15):  "Category",
        (2, 20):  "SupplementalCategories",
        (2, 25):  "Keywords",
        (2, 40):  "SpecialInstructions",
        (2, 55):  "DateCreated",
        (2, 60):  "TimeCreated",
        (2, 80):  "Byline",            # Creator/Author
        (2, 85):  "BylineTitle",
        (2, 90):  "City",
        (2, 92):  "SubLocation",
        (2, 95):  "ProvinceState",
        (2, 100): "CountryCode",
        (2, 101): "CountryName",
        (2, 103): "OriginalTransmissionReference",
        (2, 105): "Headline",
        (2, 110): "Credit",
        (2, 115): "Source",
        (2, 116): "Copyright",
        (2, 118): "Contact",
        (2, 120): "Caption",           # Description
        (2, 122): "WriterEditor",
    }
    try:
        with Image.open(path) as img:
            raw = IptcImagePlugin.getiptcinfo(img)
            if not raw:
                return {}
            for key, value in raw.items():
                name = iptc_names.get(key, f"IPTC{key}")
                if isinstance(value, bytes):
                    value = value.decode("utf-8", errors="replace")
                elif isinstance(value, list):
                    value = [v.decode("utf-8", errors="replace") if isinstance(v, bytes) else v for v in value]
                out[name] = value
    except Exception as e:
        out["_error"] = str(e)
    return out


def xmp_info(path: Path) -> dict:
    """XMP metadata - moderní alternativa IPTC, často keywords/rating/regions."""
    out = {}
    try:
        with Image.open(path) as img:
            xmp_raw = img.info.get("xmp")
            if not xmp_raw:
                return {}
            if isinstance(xmp_raw, bytes):
                xmp_raw = xmp_raw.decode("utf-8", errors="replace")

            # Velmi jednoduchý parser - vytáhne nejčastější pole regexem
            patterns = {
                "creator_tool":  r'xmp:CreatorTool="([^"]+)"',
                "create_date":   r'xmp:CreateDate="([^"]+)"',
                "modify_date":   r'xmp:ModifyDate="([^"]+)"',
                "rating":        r'xmp:Rating="([^"]+)"',
                "label":         r'xmp:Label="([^"]+)"',
                "title":         r'<dc:title[^>]*>.*?<rdf:li[^>]*>([^<]+)</rdf:li>',
                "description":   r'<dc:description[^>]*>.*?<rdf:li[^>]*>([^<]+)</rdf:li>',
                "creator":       r'<dc:creator[^>]*>.*?<rdf:li[^>]*>([^<]+)</rdf:li>',
                "subject_keywords": r'<dc:subject[^>]*>(.*?)</dc:subject>',
            }
            for name, pat in patterns.items():
                m = re.search(pat, xmp_raw, re.DOTALL)
                if m:
                    out[name] = m.group(1).strip()

            # Keywords z dc:subject - vytáhnout jednotlivé rdf:li
            if "subject_keywords" in out:
                kws = re.findall(r'<rdf:li[^>]*>([^<]+)</rdf:li>', out["subject_keywords"])
                out["subject_keywords"] = kws

            # Apple regions (rozpoznané obličeje s pozicí)
            face_count = len(re.findall(r'mwg-rs:Type="Face"', xmp_raw))
            if face_count:
                out["face_regions_count"] = face_count

            # Délka raw XMP pro představu
            out["_xmp_length_bytes"] = len(xmp_raw)
    except Exception as e:
        out["_error"] = str(e)
    return out


def filesystem_info(path: Path) -> dict:
    stat = path.stat()
    return {
        "file_name": path.name,
        "file_path": str(path),
        "file_size_bytes": stat.st_size,
        "file_size_mb": round(stat.st_size / 1024 / 1024, 2),
        "mtime": datetime.fromtimestamp(stat.st_mtime).isoformat(),
        "ctime": datetime.fromtimestamp(stat.st_ctime).isoformat(),
        "extension": path.suffix.lower(),
    }


def pillow_info(path: Path) -> dict:
    info = {}
    try:
        with Image.open(path) as img:
            info["format"] = img.format
            info["mode"] = img.mode
            info["width"] = img.width
            info["height"] = img.height
            info["megapixels"] = round((img.width * img.height) / 1_000_000, 2)
            info["has_transparency"] = img.mode in ("RGBA", "LA") or "transparency" in img.info
            info["dpi"] = img.info.get("dpi")
            info["icc_profile_present"] = "icc_profile" in img.info
            info["exif_present"] = bool(img.getexif())

            # XMP (často v JPG od Adobe)
            if "xmp" in img.info:
                xmp_raw = img.info["xmp"]
                if isinstance(xmp_raw, bytes):
                    xmp_raw = xmp_raw[:500].decode("utf-8", errors="ignore")
                info["xmp_snippet"] = str(xmp_raw)[:500]

            # Thumbnail embedded?
            info["has_embedded_thumbnail"] = "thumbnail" in img.info
    except Exception as e:
        info["error"] = str(e)
    return info


def pillow_exif(path: Path) -> dict:
    """Pillow EXIF — čitelné názvy."""
    out = {}
    try:
        with Image.open(path) as img:
            exif = img.getexif()
            if not exif:
                return {}
            for tag_id, value in exif.items():
                tag = TAGS.get(tag_id, f"Tag{tag_id}")
                # GPS info jako vnořený dict
                if tag == "GPSInfo":
                    gps = {}
                    for gps_tag_id, gps_value in value.items():
                        gps_tag = GPSTAGS.get(gps_tag_id, f"GPSTag{gps_tag_id}")
                        gps[gps_tag] = _serializable(gps_value)
                    out[tag] = gps
                else:
                    out[tag] = _serializable(value)
    except Exception as e:
        out["_error"] = str(e)
    return out


def exifread_tags(path: Path) -> dict:
    """ExifRead — často víc tagů než Pillow, mj. detailní MakerNote."""
    out = {}
    try:
        with open(path, "rb") as f:
            tags = exifread.process_file(f, details=True)
            for k, v in tags.items():
                # přeskočit binární thumbnail
                if "Thumbnail" in k and "JPEGInterchangeFormat" not in k:
                    continue
                out[k] = str(v)
    except Exception as e:
        out["_error"] = str(e)
    return out


def _serializable(v):
    """Pillow vrací občas IFDRational, bytes apod. → převést na JSON-friendly."""
    if isinstance(v, bytes):
        return v[:200].decode("utf-8", errors="replace")
    if isinstance(v, (tuple, list)):
        return [_serializable(x) for x in v]
    if isinstance(v, dict):
        return {str(k): _serializable(val) for k, val in v.items()}
    if hasattr(v, "numerator") and hasattr(v, "denominator"):
        try:
            return float(v)
        except Exception:
            return str(v)
    try:
        json.dumps(v)
        return v
    except (TypeError, ValueError):
        return str(v)


def explore_photo(path: Path) -> dict:
    return {
        "filesystem": filesystem_info(path),
        "hashes": {
            "sha256_file":   file_hash_sha256(path),
            "sha256_pixels": pixel_hash_sha256(path),
            **perceptual_hashes(path),
        },
        "pillow": pillow_info(path),
        "exif_pillow": pillow_exif(path),
        "exif_exifread": exifread_tags(path),
        "iptc": iptc_info(path),
        "xmp": xmp_info(path),
    }


def hamming_distance(h1: str, h2: str) -> int:
    """Hamming distance mezi dvěma hex perceptual hashes."""
    return bin(int(h1, 16) ^ int(h2, 16)).count("1")


def print_summary(photos: list[dict]) -> None:
    print(f"\n{'=' * 70}")
    print(f"PŘEHLED: {len(photos)} fotek")
    print(f"{'=' * 70}\n")

    # Které EXIF tagy existují napříč fotkami?
    all_pillow_keys = set()
    all_exifread_keys = set()
    for p in photos:
        all_pillow_keys.update(p["exif_pillow"].keys())
        all_exifread_keys.update(p["exif_exifread"].keys())

    print(f"Unikátní EXIF tagy (Pillow):    {len(all_pillow_keys)}")
    print(f"Unikátní EXIF tagy (ExifRead):  {len(all_exifread_keys)}")
    print()

    for i, p in enumerate(photos, 1):
        fs = p["filesystem"]
        pi = p["pillow"]
        h = p["hashes"]
        er = p["exif_exifread"]
        print(f"[{i}] {fs['file_name']}")
        print(f"    Velikost:    {fs['file_size_mb']} MB ({pi.get('width')}x{pi.get('height')}, {pi.get('megapixels')} Mpx)")
        print(f"    Formát:      {pi.get('format')} / mode={pi.get('mode')}")
        print(f"    sha256_file:   {h['sha256_file'][:16]}...")
        print(f"    sha256_pixels: {(h.get('sha256_pixels') or 'N/A')[:16]}...")
        print(f"    phash:       {h.get('phash')}    (perceptual)")
        print(f"    EXIF tagů:   ExifRead={len(er)}, Pillow={len(p['exif_pillow'])}")
        print(f"    IPTC polí:   {len([k for k in p['iptc'] if not k.startswith('_')])}")
        print(f"    XMP polí:    {len([k for k in p['xmp'] if not k.startswith('_')])}")

        # ExifRead je spolehlivější (Pillow má GPS bug)
        interesting = {
            "Kamera":     f"{er.get('Image Make', '')} {er.get('Image Model', '')}".strip(),
            "Objektiv":   er.get("EXIF LensModel"),
            "Datum":      er.get("EXIF DateTimeOriginal") or er.get("Image DateTime"),
            "TZ offset":  er.get("EXIF OffsetTimeOriginal") or er.get("EXIF OffsetTime"),
            "Clona":      er.get("EXIF FNumber"),
            "ISO":        er.get("EXIF ISOSpeedRatings"),
            "Expozice":   er.get("EXIF ExposureTime"),
            "Ohnisko mm": er.get("EXIF FocalLength"),
            "Flash":      er.get("EXIF Flash"),
            "GPS lat":    er.get("GPS GPSLatitude"),
            "GPS lon":    er.get("GPS GPSLongitude"),
            "Software":   er.get("Image Software"),
        }
        for k, v in interesting.items():
            if v and str(v).strip():
                print(f"    {k:12s}: {v}")

        # IPTC / XMP — vypsat všechno, co je
        if p["iptc"]:
            for k, v in p["iptc"].items():
                if not k.startswith("_"):
                    print(f"    IPTC.{k:8s}: {v}")
        if p["xmp"]:
            for k, v in p["xmp"].items():
                if not k.startswith("_"):
                    print(f"    XMP.{k:9s}: {v}")
        print()

    # Tabulka perceptuálních podobností (Hamming distance phash)
    print(f"{'=' * 70}")
    print("PERCEPTUÁLNÍ PODOBNOST (phash Hamming distance)")
    print("Hodnota 0-10 = vizuálně velmi podobné, >20 = odlišné")
    print(f"{'=' * 70}")
    n = len(photos)
    header = "        " + "".join(f"  [{i+1}]" for i in range(n))
    print(header)
    for i in range(n):
        row = f"   [{i+1}]  "
        for j in range(n):
            if i == j:
                row += "    -"
            else:
                h1 = photos[i]["hashes"].get("phash")
                h2 = photos[j]["hashes"].get("phash")
                if h1 and h2:
                    d = hamming_distance(h1, h2)
                    marker = "*" if d <= 10 and i != j else " "
                    row += f"  {d:3d}{marker}"
                else:
                    row += "  N/A "
        print(row)
    print("\n   * = vizuálně podobné fotky (možná duplikát po editaci)")
    print()


def main():
    if not PHOTOS_DIR.exists():
        print(f"[ERROR] Složka neexistuje: {PHOTOS_DIR}")
        return

    files = sorted([p for p in PHOTOS_DIR.iterdir()
                    if p.is_file() and p.suffix.lower() in {".jpg", ".jpeg", ".png", ".heic", ".tiff", ".tif", ".webp"}])

    if not files:
        print(f"[WARN] Žádné fotky v {PHOTOS_DIR}")
        return

    print(f"Nalezeno {len(files)} fotek v {PHOTOS_DIR}\n")

    photos = []
    for f in files:
        print(f"  zpracovávám: {f.name} ...", end=" ", flush=True)
        try:
            photos.append(explore_photo(f))
            print("OK")
        except Exception as e:
            print(f"FAIL: {e}")

    print_summary(photos)

    # Uložit do JSON pro detailní analýzu
    with open(OUTPUT_JSON, "w", encoding="utf-8") as f:
        json.dump(photos, f, indent=2, ensure_ascii=False, default=str)
    print(f"\n[OK] Detailní data uložena: {OUTPUT_JSON}")


if __name__ == "__main__":
    main()