import sys
import os
import json
import inspect
from pathlib import Path
from datetime import datetime

from PyQt6.QtWidgets import (QApplication, QMainWindow, QMessageBox,
                             QFileDialog, QProgressBar, QLabel)
from PyQt6.QtCore import Qt, pyqtSignal, pyqtSlot, QUrl, QVariant
from PyQt6.QtGui import QMovie, QPixmap
from PyQt6.uic import loadUi
from win32com.client import CDispatch, Dispatch

# Proje modüllerini import et
sys.path.append(os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()) + "\\..\\..")))
_current_dir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
_project_root = os.path.dirname(os.path.dirname(os.path.dirname(_current_dir)))
sys.path.insert(0, _project_root)
sys.path.insert(0, _current_dir)

from IFikatia import IFikatia


class IFikoCikariciDialog(QMainWindow):
    """
    FikoYT Çıkarıcı Dialog

    CATIA dökümanlarından aşağıdaki işlemleri gerçekleştirir:
    - WRL (VRML) formatında 3D dosya dışa aktarma
    - Kamera görüntülerinden PNG/JPG resim çekme
    - Teknik dokümantasyon oluşturma
    - Tüm verileri .fikoyt gizli klasöründe saklama
    """


    def __init__(self, parent=None, flags=None, Catia=None):
        """
        Dialog constructor

        Args:
            parent: Parent widget (None - standalone)
            flags: Qt window flags (Qt.WindowType)
            Catia: CATIA COM Application nesnesi
        """
        # CATIA COM nesnesi kontrolü
        if Catia is None:
            raise ValueError("CATIA parametresi boş olamaz!")

        # PyQt6 initialization (super çağrısından önce)
        if not QApplication.instance():
            self.app = QApplication([sys.argv])
        else:
            self.app = QApplication.instance()

        # Default flags ayarla
        if flags is None:
            flags = Qt.WindowType.Window

        # Parent widget olmamalı (standalone dialog)
        super(IFikoCikariciDialog, self).__init__(None)

        # CATIA COM nesnesi sarmalama
        self.__fikatia = IFikatia(obj=Catia)
        self.__dokuman = self.__fikatia.aktifDokuman

        # Script dosyasının yolu
        self.ScriptYolu = str(Path(__file__).parent)

        # Proje kök dizini
        self.ProjeKlasoru = self.__dokuman.klasoru if self.__dokuman else ""

        # .fikoyt gizli klasörü yolu (henüz oluşturulmamış)
        self.FikoytKlasoru = os.path.join(self.ProjeKlasoru, ".fikoyt")

        # PyQt6 UI dosyasını yükle
        try:
            ui_path = os.path.join(self.ScriptYolu, "formAna.ui")
            self.ui = loadUi(ui_path, self)
        except Exception as e:
            QMessageBox.critical(self, "Hata", f"UI dosyası yüklenemedi: {e}")
            self.close()
            return

        # Pencere özelliklerini ayarla
        self.setWindowFlags(
            Qt.WindowType.Window |
            Qt.WindowType.WindowCloseButtonHint |
            Qt.WindowType.CustomizeWindowHint |
            Qt.WindowType.WindowStaysOnTopHint
        )

        self.setWindowTitle("FikoYT - Çıkarıcı Dialog")
        self.setGeometry(100, 100, 600, 500)

        # Loading animasyonu
        self._setup_loading_animation()

        # Signal-slot bağlantıları
        self._connect_signals()

    def _setup_loading_animation(self):
        """Loading GIF animasyonunu ekle"""
        try:
            # Resimler klasöründen GIF dosyasını yükle
            gif_path = os.path.join(self.ScriptYolu, "Resimler", "hiper.gif")
            if hasattr(self.ui, 'labelLoading') and os.path.exists(gif_path):
                movie = QMovie(gif_path)
                self.ui.labelLoading.setMovie(movie)
                self.ui.labelLoading.hide()  # Başlangıçta gizli
                self.loading_movie = movie
        except Exception as e:
            print(f"Loading animasyonu yüklenemedi: {e}")

    def _connect_signals(self):
        """PyQt6 signal-slot bağlantılarını kur"""
        # Dialog butonları (formAna.ui'de tanımlandığını varsayıyoruz)
        if hasattr(self.ui, 'btnWrlKaydet'):
            self.ui.btnWrlKaydet.clicked.connect(self.wrl_kaydet)

        if hasattr(self.ui, 'btnResimCek'):
            self.ui.btnResimCek.clicked.connect(self.resim_cek)

        if hasattr(self.ui, 'btnDokumanOlustur'):
            self.ui.btnDokumanOlustur.clicked.connect(self.dokuman_olustur)

        if hasattr(self.ui, 'btnCikis'):
            self.ui.btnCikis.clicked.connect(self.close)

        # Checkbox'lar (seçenekler)
        if hasattr(self.ui, 'checkWrlKaydet'):
            self.ui.checkWrlKaydet.stateChanged.connect(self.ozellik_degisti)

        if hasattr(self.ui, 'checkResimCek'):
            self.ui.checkResimCek.stateChanged.connect(self.ozellik_degisti)

        if hasattr(self.ui, 'checkDokumanOlustur'):
            self.ui.checkDokumanOlustur.stateChanged.connect(self.ozellik_degisti)

    @pyqtSlot()
    def wrl_kaydet(self):
        """WRL (VRML) formatında 3D dosya dışa aktarma"""
        try:
            self._fikoyt_klasoru_kontrol_et()

            # CATIA'daki aktif belge COM nesnesi
            doc_com = self.__dokuman.catNesne

            # WRL dosyasının yolu
            wrl_dosya = os.path.join(self.FikoytKlasoru, "model.wrl")

            print(f"[DEBUG] WRL kaydediliyor: {wrl_dosya}")

            # ExportData ile WRL formatında dışa aktar
            doc_com.ExportData(wrl_dosya, "wrl")

            # Dosya oluşturulduğunu kontrol et
            if not os.path.exists(wrl_dosya):
                raise RuntimeError(f"WRL dosyası oluşturulamadı: {wrl_dosya}")

            dosya_boyutu = os.path.getsize(wrl_dosya)
            print(f"[DEBUG] WRL başarılı: {dosya_boyutu} bytes")

            self.ui.statusBar().showMessage(f"✓ WRL kaydedildi: {wrl_dosya}")
            QMessageBox.information(self, "Başarılı",
                                  f"WRL dosyası başarıyla kaydedildi.\n\nKonum: {wrl_dosya}")

        except Exception as e:
            print(f"[ERROR] WRL kaydetme hatası: {str(e)}")
            import traceback
            traceback.print_exc()
            self.ui.statusBar().showMessage(f"✗ Hata: {str(e)}")
            QMessageBox.critical(self, "Hata", f"WRL kaydedilemedi:\n\n{str(e)}")

    @pyqtSlot()
    def resim_cek(self):
        """Belge görüntüsünden JPEG resim çekme"""
        try:
            self._fikoyt_klasoru_kontrol_et()

            # Gosterim nesnesini al (IGosterim3d sarmalı veya COM nesnesi)
            gosterim = self.__dokuman.gosterim

            if gosterim is None:
                raise ValueError("Gosterim nesnesi alınamadı!")

            # Eğer sarmalı nesneyse, COM nesnesini çıkar
            if hasattr(gosterim, 'catNesne'):
                gosterim_com = gosterim.catNesne
            else:
                gosterim_com = gosterim

            # JPEG dosyasının yolu
            jpeg_dosya = os.path.join(self.FikoytKlasoru, "screenshot.jpg")

            print(f"[DEBUG] JPEG kaydediliyor: {jpeg_dosya}")
            print(f"[DEBUG] COM nesnesi tipi: {type(gosterim_com)}")
            print(f"[DEBUG] CaptureToFile çağrılıyor...")

            # Doğrudan COM metodu çağır - Format=5 (JPEG)
            gosterim_com.CaptureToFile(5, jpeg_dosya)

            # Kontrol et
            if not os.path.exists(jpeg_dosya):
                raise RuntimeError(f"JPEG dosyası oluşturulamadı: {jpeg_dosya}")

            dosya_boyutu = os.path.getsize(jpeg_dosya)
            print(f"[DEBUG] JPEG başarılı: {dosya_boyutu} bytes")

            self.ui.statusBar().showMessage(f"✓ JPEG kaydedildi: {jpeg_dosya}")
            QMessageBox.information(self, "Başarılı",
                                  f"JPEG dosyası başarıyla kaydedildi.\n\nKonum: {jpeg_dosya}")

        except Exception as e:
            print(f"[ERROR] Resim çekme hatası: {str(e)}")
            import traceback
            traceback.print_exc()
            self.ui.statusBar().showMessage(f"✗ Hata: {str(e)}")
            QMessageBox.critical(self, "Hata", f"Resim çekilemedi:\n\n{str(e)}")

    @pyqtSlot()
    def dokuman_olustur(self):
        """Teknik dokümantasyon JSON dosyası oluşturma"""
        try:
            self._fikoyt_klasoru_kontrol_et()

            # Dokümantasyon veri yapısı
            dokumantasyon = {
                "olusturma_tarihi": datetime.now().isoformat(),
                "dokuman_adi": self.__dokuman.ismi,
                "dokuman_tam_yolu": self.__dokuman.tamIsmi,
                "belge_turu": self.__dokuman.turu,
                "kaydedilmis": self.__dokuman.kaydedilmismi,
                "proje_klasoru": self.ProjeKlasoru,
                "fikoyt_klasoru": self.FikoytKlasoru,
                "islemler": {
                    "wrl_kayit": os.path.exists(os.path.join(self.FikoytKlasoru, "model.wrl")),
                    "resim_cikti": os.path.exists(os.path.join(self.FikoytKlasoru, "fikoyt.jpg"))
                }
            }

            # JSON dosyası olarak kaydet
            json_dosya = os.path.join(self.FikoytKlasoru, "dokumantasyon.json")
            with open(json_dosya, 'w', encoding='utf-8') as f:
                json.dump(dokumantasyon, f, indent=2, ensure_ascii=False)

            self.ui.statusBar().showMessage(f"✓ JSON kaydedildi: {json_dosya}")
            QMessageBox.information(self, "Başarılı",
                                  f"Dokümantasyon dosyası başarıyla kaydedildi.\n\nKonum: {json_dosya}")

        except Exception as e:
            print(f"[ERROR] Dokümantasyon oluşturma hatası: {str(e)}")
            import traceback
            traceback.print_exc()
            self.ui.statusBar().showMessage(f"✗ Hata: {str(e)}")
            QMessageBox.critical(self, "Hata", f"Dokümantasyon oluşturulamadı:\n\n{str(e)}")

    @pyqtSlot()
    def ozellik_degisti(self):
        """Checkbox seçenekleri değiştiğinde çağrılır"""
        pass

    def _fikoyt_klasoru_kontrol_et(self):
        """
        .fikoyt gizli klasörünü kontrol et ve oluştur
        """
        if not os.path.exists(self.FikoytKlasoru):
            try:
                os.makedirs(self.FikoytKlasoru)
                # Windows'ta gizli klasör yap
                import ctypes
                ctypes.windll.kernel32.SetFileAttributesW(self.FikoytKlasoru, 2)
            except Exception as e:
                QMessageBox.critical(self, "Hata",
                                   f".fikoyt klasörü oluşturulamadı: {e}")
                return False
        return True

    def closeEvent(self, event):
        """Pencere kapatılırken çağrılır"""
        event.accept()

    def __str__(self):
        return f"IFikoCikariciDialog(dokuman={self.__dokuman.ismi})"

if __name__ == '__main__':
    app = QApplication(sys.argv)
    app.setStyle("fusion")

    cizgiYumusatici = IFikoCikariciDialog(Catia=Dispatch("Catia.Application"))
    cizgiYumusatici.show()

    sys.exit(app.exec())
