import subprocess
import os
from typing import Generic, TypeVar
from win32com.client import CDispatch

from IFikomObject import IFikomObject
import IFikatia

import IPencere
from IKameralar import IKameralar
from ISecililer import ISecililer
from IGosterim3d import IGosterim3d

class IPPRDokuman(IFikomObject):
    pass


class IPartDokuman:
    pass


class IDokuman(IFikomObject):
    def __init__(self, obj: CDispatch, sahip: IFikomObject = None):
        """Constructor for IDokuman"""
        super(IDokuman, self).__init__(obj, sahip)
        # ---> Standart Degiskenler
        self.__sahip = sahip
        self.tipi = "IDokuman"

    @property
    def sahip(self) -> IFikatia:
        return self.__sahip

    @sahip.setter
    def sahip(self, value: IFikatia):
        self.__sahip = value

    @property
    def pencere(self) -> IPencere:
        dokumanIsmi = self.catNesne.FullName
        Pencereler = self.anaProgram.pencereler
        pencereSayisi = Pencereler.sayisi

        rslt = None
        for x in range(0, pencereSayisi):
            print(Pencereler.item(x).catNesne.Name)
            if dokumanIsmi in Pencereler.item(x).catNesne.Name:
                rslt = Pencereler.item(x)
                break
        return rslt

    @property
    def gosterim(self)->IGosterim3d:
        return self.pencere.gosterimler.item(0)

    def ac(self):
        self.anaProgram.dokumanlar.ac(self.tamIsmi)

    @property
    def ismi(self) -> str:
        return str(self.catNesne.Name)

    @property
    def tamIsmi(self) -> str:
        return str(self.catNesne.FullName)

    @property
    def klasoru(self):
        return str(self.catNesne.Path)

    @property
    def kaydedilmismi(self) -> bool:
        return bool(self.catNesne.Saved)

    @property
    def gizliOlanlariGoster(self) -> bool:
        return bool(self.catNesne.SeeHiddenElements)

    @gizliOlanlariGoster.setter
    def gizliOlanlariGoster(self, value: bool):
        self.catNesne.SeeHiddenElements = value

    @property
    def saltOkunur(self) -> bool:
        return bool(self.catNesne.ReadOnly)

    @property
    def gecerliFilitre(self) -> str:
        return str(self.catNesne.CurrentFilter)

    @gecerliFilitre.setter
    def gecerliFilitre(self, value: str):
        self.catNesne.CurrentFilter = value

    @property
    def gecerliKatman(self) -> int:
        return self.catNesne.CurrentLayer

    @gecerliKatman.setter
    def gecerliKatman(self, value: str):
        self.catNesne.CurrentLayer = value

    @property
    def turu(self) -> str:
        base = os.path.basename(self.tamIsmi)
        return str(os.path.splitext(base[::])[1][::])

    @property
    def kameralar(self) -> IKameralar:
        return IKameralar(obj=self.catNesne.Cameras, sahip=self)

    @property
    def secililer(self):
        return ISecililer(obj=self.catNesne.Selection, sahip=self)

    @secililer.setter
    def secililer(self, value):
        pass

    def kapat(self):
        self.catNesne.Close()

    def aktifEt(self):
        """Dökümanı Aktif Eder"""
        self.catNesne.Activate()

    def veriAktar(self, val1, val2):
        self.catNesne.ExportData(val1, val2)

    def yeniPencere(self):
        self.catNesne.NewWindow()

    def kaydet(self):
        self.catNesne.Save()

    def farkliKaydet(self, dosya: str):
        self.catNesne.SaveAs(dosya)

    def klasoruAc(self):
        os.startfile(self.klasoru)

    def klasoruAcSecimli(self):
        Popen_arg = str("explorer /select," + str(self.tamIsmi))
        subprocess.Popen(Popen_arg)

    @property
    def asProcessDokuman(self):
        from IProcessDokuman import IProcessDokuman

        if not self.turu.lower() == ".catprocess":
            raise TypeError("Döküman Türü Uyumsuz.CATProcess Olmalı")
        return IProcessDokuman(obj=self.catNesne, sahip=self)

    @property
    def asPPRDokuman(self):
        # if not self.turu.lower()==".catprocess":
        #     raise TypeError("Döküman Türü Uyumsuz.CATProcess Olmalı")
        return IPPRDokuman(obj=self.catNesne, sahip=self)

    @property
    def asPartDokuman(self) -> IPartDokuman:
        from IProcessDokuman import IProcessDokuman

        return IPartDokuman(obj=self.catNesne, sahip=self)

    @property
    def asProductDokuman(self):
        return IProductDokuman(obj=self.catNesne, sahip=self)

    def __str__(self):
        return repr(self.ismi)


from IProcessDokuman import IProcessDokuman
from IPPRDokuman import IPPRDokuman
from IPartDokuman import IPartDokuman
from IProductDokuman import IProductDokuman