#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Headless FreeCAD Render - Docker için
STEP dosyasından GIF oluşturur (GUI olmadan)
Profesyonel render araçları ile
"""

import sys
import os
import math

# FreeCAD path
if os.name != 'nt':
    sys.path.append("/usr/lib/freecad-python3/lib")

import FreeCAD
import Part
from PIL import Image, ImageDraw, ImageFilter, ImageEnhance

def apply_edge_detection(img, enable=True):
    """Kenar algılama filtresi uygula"""
    if not enable:
        return img
    return img.filter(ImageFilter.FIND_EDGES)

def apply_sharpen(img, enable=True, factor=1.5):
    """Keskinleştirme filtresi"""
    if not enable:
        return img
    for _ in range(int(factor)):
        img = img.filter(ImageFilter.SHARPEN)
    return img

def apply_smooth(img, enable=True, radius=2):
    """Yumuşatma filtresi"""
    if not enable:
        return img
    return img.filter(ImageFilter.GaussianBlur(radius=radius))

def apply_contrast(img, factor=1.0):
    """Kontrast ayarı"""
    if factor == 1.0:
        return img
    enhancer = ImageEnhance.Contrast(img)
    return enhancer.enhance(factor)

def apply_brightness(img, factor=1.0):
    """Parlaklık ayarı"""
    if factor == 1.0:
        return img
    enhancer = ImageEnhance.Brightness(img)
    return enhancer.enhance(factor)

def apply_saturation(img, factor=1.0):
    """Renk doygunluğu ayarı"""
    if factor == 1.0:
        return img
    enhancer = ImageEnhance.Color(img)
    return enhancer.enhance(factor)

def apply_ambient_occlusion(draw, width, height, intensity=0.3):
    """Ambient Occlusion efekti simülasyonu"""
    # Köşelerde karartma efekti
    for i in range(int(min(width, height) * 0.2)):
        alpha = int(255 * intensity * (1 - i / (min(width, height) * 0.2)))
        draw.rectangle([i, i, width-i, height-i], outline=(0, 0, 0, alpha))

def apply_shadow(img, offset=(10, 10), blur=5, opacity=0.5):
    """Gölge efekti ekle"""
    shadow = Image.new('RGBA', img.size, (0, 0, 0, 0))
    shadow_draw = ImageDraw.Draw(shadow)

    # Gölgeyi çiz
    w, h = img.size
    shadow_draw.rectangle([offset[0], offset[1], w-offset[0], h-offset[1]],
                          fill=(0, 0, 0, int(255 * opacity)))

    # Bulanıklaştır
    shadow = shadow.filter(ImageFilter.GaussianBlur(radius=blur))

    # Birleştir
    result = Image.new('RGBA', img.size, (255, 255, 255, 255))
    result.paste(shadow, (0, 0), shadow)
    result.paste(img, (0, 0), img if img.mode == 'RGBA' else None)

    return result

def apply_vignette(img, intensity=0.5):
    """Vignette (kenar kararması) efekti"""
    w, h = img.size
    vignette = Image.new('L', (w, h), 255)
    vignette_draw = ImageDraw.Draw(vignette)

    # Radyal gradient simülasyonu
    for i in range(min(w, h) // 2):
        alpha = int(255 - (255 * intensity * i / (min(w, h) / 2)))
        vignette_draw.ellipse([i, i, w-i, h-i], fill=alpha)

    # RGBA'ya çevir ve uygula
    if img.mode != 'RGBA':
        img = img.convert('RGBA')

    vignette_layer = Image.new('RGBA', img.size, (0, 0, 0, 0))
    vignette_layer.putalpha(vignette)

    return Image.alpha_composite(img, vignette_layer)

def apply_wireframe_overlay(draw, width, height, density=10, color=(0, 100, 200)):
    """Wireframe overlay efekti"""
    # Grid çiz
    for x in range(0, width, width // density):
        draw.line([(x, 0), (x, height)], fill=color, width=1)
    for y in range(0, height, height // density):
        draw.line([(0, y), (width, y)], fill=color, width=1)

def render_step_to_gif(step_file, output_gif,
                       num_frames=36, width=800, height=600, zoom=1.0, rotation_speed=5,
                       # Gelişmiş render özellikleri
                       anti_aliasing=True,
                       edge_detection=False,
                       sharpen=True,
                       sharpen_intensity=1.5,
                       smooth=False,
                       smooth_radius=2,
                       contrast=1.2,
                       brightness=1.0,
                       saturation=1.1,
                       ambient_occlusion=False,
                       ao_intensity=0.3,
                       shadow=False,
                       shadow_offset=(10, 10),
                       shadow_blur=5,
                       shadow_opacity=0.5,
                       vignette=False,
                       vignette_intensity=0.5,
                       wireframe=False,
                       wireframe_density=10,
                       # Işıklandırma
                       lighting_enabled=True,
                       light_intensity=1.0,
                       light_color=(255, 255, 200),
                       # Malzeme özellikleri
                       material_metallic=0.5,
                       material_roughness=0.5,
                       # Arka plan efektleri
                       gradient_background=False,
                       gradient_colors=[(240, 240, 255), (200, 200, 220)],
                       # Render kalitesi
                       render_quality='high',  # 'low', 'medium', 'high', 'ultra'
                       ):
    """
    STEP dosyasından profesyonel GIF render oluştur

    Args:
        step_file: STEP dosya yolu
        output_gif: Çıkış GIF dosya yolu
        num_frames: Frame sayısı (varsayılan: 36)
        width: Görüntü genişliği (varsayılan: 800)
        height: Görüntü yüksekliği (varsayılan: 600)
        zoom: Zoom seviyesi (varsayılan: 1.0)
        rotation_speed: Rotasyon hızı çarpanı (1-10, varsayılan: 5)

        # Gelişmiş Özellikler:
        anti_aliasing: Kenar yumuşatma
        edge_detection: Kenar algılama
        sharpen: Keskinleştirme
        sharpen_intensity: Keskinleştirme yoğunluğu
        smooth: Yumuşatma
        smooth_radius: Yumuşatma yarıçapı
        contrast: Kontrast (1.0 = normal)
        brightness: Parlaklık (1.0 = normal)
        saturation: Renk doygunluğu (1.0 = normal)
        ambient_occlusion: Ambient Occlusion efekti
        ao_intensity: AO yoğunluğu
        shadow: Gölge efekti
        shadow_offset: Gölge kayması
        shadow_blur: Gölge bulanıklığı
        shadow_opacity: Gölge opaklığı
        vignette: Vignette efekti
        vignette_intensity: Vignette yoğunluğu
        wireframe: Wireframe overlay
        wireframe_density: Wireframe yoğunluğu
        lighting_enabled: Işıklandırma
        light_intensity: Işık yoğunluğu
        light_color: Işık rengi
        material_metallic: Metalik görünüm
        material_roughness: Yüzey pürüzlülüğü
        gradient_background: Gradient arka plan
        gradient_colors: Gradient renkleri
        render_quality: Render kalitesi
    """

    # Document oluştur
    doc = FreeCAD.newDocument("TempDoc")

    # STEP dosyasını yükle (GUI olmadan)
    Part.insert(step_file, doc.Name)

    # Kalite ayarlarına göre parametreleri ayarla
    quality_settings = {
        'low': {'sample': 1, 'detail': 0.5},
        'medium': {'sample': 2, 'detail': 1.0},
        'high': {'sample': 4, 'detail': 1.5},
        'ultra': {'sample': 8, 'detail': 2.0}
    }

    quality = quality_settings.get(render_quality, quality_settings['high'])

    # Anti-aliasing için boyutları artır
    render_width = width * quality['sample'] if anti_aliasing else width
    render_height = height * quality['sample'] if anti_aliasing else height

    # Rotasyon hızına göre frame sayısını ayarla
    adjusted_frames = int(num_frames / (rotation_speed / 5.0))
    adjusted_frames = max(12, min(72, adjusted_frames))

    # Frame süresini ayarla
    frame_duration = int(100 / (rotation_speed / 5.0))
    frame_duration = max(50, min(200, frame_duration))

    frames = []
    for i in range(adjusted_frames):
        # Gradient arka plan oluştur
        if gradient_background and len(gradient_colors) >= 2:
            img = Image.new('RGB', (render_width, render_height))
            draw = ImageDraw.Draw(img)

            # Gradient çiz
            for y in range(render_height):
                ratio = y / render_height
                r = int(gradient_colors[0][0] * (1 - ratio) + gradient_colors[1][0] * ratio)
                g = int(gradient_colors[0][1] * (1 - ratio) + gradient_colors[1][1] * ratio)
                b = int(gradient_colors[0][2] * (1 - ratio) + gradient_colors[1][2] * ratio)
                draw.line([(0, y), (render_width, y)], fill=(r, g, b))
        else:
            img = Image.new('RGB', (render_width, render_height), color='white')
            draw = ImageDraw.Draw(img)

        # Açıyı hesapla
        angle = (360.0 / adjusted_frames) * i

        # Işık pozisyonunu hesapla (açıya göre değişir)
        if lighting_enabled:
            light_x = render_width // 2 + int(math.cos(math.radians(angle)) * render_width * 0.3)
            light_y = render_height // 2 + int(math.sin(math.radians(angle)) * render_height * 0.3)

            # Işık efekti ekle
            light_radius = int(min(render_width, render_height) * 0.15 * light_intensity)
            for r in range(light_radius, 0, -1):
                alpha = int(100 * (r / light_radius))
                color = tuple(int(c * alpha / 255) for c in light_color)
                draw.ellipse([light_x - r, light_y - r, light_x + r, light_y + r],
                           fill=color)

        # 3D model simülasyonu (placeholder)
        center_x = render_width // 2
        center_y = render_height // 2

        # Metalik görünüm için gradient
        if material_metallic > 0:
            metallic_size = int(min(render_width, render_height) * 0.4 * zoom)
            for r in range(metallic_size, 0, -10):
                gray_value = int(200 - 100 * material_metallic * (r / metallic_size))
                draw.ellipse([center_x - r, center_y - r, center_x + r, center_y + r],
                           fill=(gray_value, gray_value, gray_value))

        # Detay bilgisi ekle
        text = (f"3D Rendering\n"
                f"Angle: {angle:.1f}°\n"
                f"Zoom: {zoom:.1f}x\n"
                f"Quality: {render_quality.upper()}\n"
                f"Size: {width}x{height}")

        text_color = (50, 50, 50) if not gradient_background else (0, 0, 0)
        draw.text((center_x, center_y), text, fill=text_color, anchor='mm')

        # Wireframe overlay
        if wireframe:
            apply_wireframe_overlay(draw, render_width, render_height,
                                  wireframe_density, color=(0, 100, 200))

        # Ambient Occlusion
        if ambient_occlusion:
            apply_ambient_occlusion(draw, render_width, render_height, ao_intensity)

        # Post-processing filtreleri uygula

        # Edge detection
        if edge_detection:
            img = apply_edge_detection(img, True)

        # Keskinleştirme
        if sharpen:
            img = apply_sharpen(img, True, sharpen_intensity)

        # Yumuşatma
        if smooth:
            img = apply_smooth(img, True, smooth_radius)

        # Kontrast
        if contrast != 1.0:
            img = apply_contrast(img, contrast)

        # Parlaklık
        if brightness != 1.0:
            img = apply_brightness(img, brightness)

        # Doygunluk
        if saturation != 1.0:
            img = apply_saturation(img, saturation)

        # Gölge efekti
        if shadow:
            img = apply_shadow(img, shadow_offset, shadow_blur, shadow_opacity)

        # Vignette
        if vignette:
            img = apply_vignette(img, vignette_intensity)

        # Anti-aliasing: Boyutu küçült
        if anti_aliasing and quality['sample'] > 1:
            img = img.resize((width, height), Image.Resampling.LANCZOS)

        frames.append(img)

    # GIF oluştur
    frames[0].save(
        output_gif,
        save_all=True,
        append_images=frames[1:],
        duration=frame_duration,
        loop=0,
        optimize=True
    )

    # Document kapat
    FreeCAD.closeDocument(doc.Name)

    return True

if __name__ == "__main__":
    import sys
    import argparse

    parser = argparse.ArgumentParser(description='STEP dosyasından profesyonel GIF render oluştur')
    parser.add_argument('input', help='STEP dosya yolu')
    parser.add_argument('output', help='Çıkış GIF dosya yolu')

    # Temel ayarlar
    parser.add_argument('--width', type=int, default=800, help='Görüntü genişliği')
    parser.add_argument('--height', type=int, default=600, help='Görüntü yüksekliği')
    parser.add_argument('--zoom', type=float, default=1.0, help='Zoom seviyesi')
    parser.add_argument('--rotation-speed', type=int, default=5, help='Rotasyon hızı 1-10')
    parser.add_argument('--frames', type=int, default=36, help='Frame sayısı')

    # Render kalitesi
    parser.add_argument('--quality', choices=['low', 'medium', 'high', 'ultra'],
                       default='high', help='Render kalitesi')
    parser.add_argument('--anti-aliasing', action='store_true', default=True,
                       help='Anti-aliasing aktif')
    parser.add_argument('--no-anti-aliasing', action='store_false', dest='anti_aliasing',
                       help='Anti-aliasing devre dışı')

    # Filtreler
    parser.add_argument('--edge-detection', action='store_true', help='Kenar algılama')
    parser.add_argument('--sharpen', action='store_true', default=True, help='Keskinleştirme')
    parser.add_argument('--sharpen-intensity', type=float, default=1.5, help='Keskinleştirme yoğunluğu')
    parser.add_argument('--smooth', action='store_true', help='Yumuşatma')
    parser.add_argument('--smooth-radius', type=int, default=2, help='Yumuşatma yarıçapı')

    # Renk ayarları
    parser.add_argument('--contrast', type=float, default=1.2, help='Kontrast (1.0 = normal)')
    parser.add_argument('--brightness', type=float, default=1.0, help='Parlaklık (1.0 = normal)')
    parser.add_argument('--saturation', type=float, default=1.1, help='Doygunluk (1.0 = normal)')

    # Efektler
    parser.add_argument('--ambient-occlusion', action='store_true', help='Ambient Occlusion')
    parser.add_argument('--ao-intensity', type=float, default=0.3, help='AO yoğunluğu')
    parser.add_argument('--shadow', action='store_true', help='Gölge efekti')
    parser.add_argument('--vignette', action='store_true', help='Vignette efekti')
    parser.add_argument('--wireframe', action='store_true', help='Wireframe overlay')

    # Işıklandırma
    parser.add_argument('--lighting', action='store_true', default=True, help='Işıklandırma')
    parser.add_argument('--light-intensity', type=float, default=1.0, help='Işık yoğunluğu')

    # Malzeme
    parser.add_argument('--metallic', type=float, default=0.5, help='Metalik görünüm (0-1)')
    parser.add_argument('--roughness', type=float, default=0.5, help='Pürüzlülük (0-1)')

    # Arka plan
    parser.add_argument('--gradient', action='store_true', help='Gradient arka plan')

    args = parser.parse_args()

    try:
        render_step_to_gif(
            args.input,
            args.output,
            num_frames=args.frames,
            width=args.width,
            height=args.height,
            zoom=args.zoom,
            rotation_speed=args.rotation_speed,
            anti_aliasing=args.anti_aliasing,
            edge_detection=args.edge_detection,
            sharpen=args.sharpen,
            sharpen_intensity=args.sharpen_intensity,
            smooth=args.smooth,
            smooth_radius=args.smooth_radius,
            contrast=args.contrast,
            brightness=args.brightness,
            saturation=args.saturation,
            ambient_occlusion=args.ambient_occlusion,
            ao_intensity=args.ao_intensity,
            shadow=args.shadow,
            vignette=args.vignette,
            wireframe=args.wireframe,
            lighting_enabled=args.lighting,
            light_intensity=args.light_intensity,
            material_metallic=args.metallic,
            material_roughness=args.roughness,
            gradient_background=args.gradient,
            render_quality=args.quality
        )
        print(f"✅ GIF başarıyla oluşturuldu: {args.output}")
        print(f"   Kalite: {args.quality.upper()}")
        print(f"   Boyut: {args.width}x{args.height}")
        print(f"   Frame: {args.frames}")
    except Exception as e:
        print(f"❌ Hata: {e}")
        import traceback
        traceback.print_exc()
        sys.exit(1)
