from IAktiviteler.IAktivite import IAktivite
from ICikaricilar.IFikoOpGLv1 import IFikoOpGLv1
import IProcessDokuman
from IProgramlar import IProgramlar
from IProgram import IProgram
import os
from pprint import pprint
from typing import TypeVar, List
import json

# from IMakineIslemeEkseni import IMakineIslemeEkseni
from IMakine import IMakine
from IProduct import IProduct
from IYardimciSiniflar import SifirKonum

__author__ = "CAM"

from IFikomObject import IFikomObject

# from IParametreler import IParametreler
# from IProgramlar import IProgramlar
from win32com.client import CDispatch


# from IGuvenlikDuzlemi import IGuvenlikDuzlemi
# from IYardimciSiniflar import XYZ, XYZO, IJK
# from IMakine import IMakine


class IProgramlar:
    pass


class IPartOperasyonu(IFikomObject):
    def __init__(self, obj: CDispatch, sahip: IFikomObject = None):
        """Constructor for IPartOperasyonu"""
        super(IPartOperasyonu, self).__init__(obj, sahip)
        self.sahip = sahip
        self.tipi = "IPartOperasyonu"
        # --->
        self.__dosya = os.path.realpath(
            os.path.join(self.anaProgram.scriptYolu, "Prg", "FikoDosya")
        )
        self._sifirKonum = None

    @property
    def ismi(self) -> str:
        return self.catNesne.Name

    @ismi.setter
    def ismi(self, value: str):
        self.catNesne.Name = value

    @property
    def aciklama(self) -> str:
        return str(self.catNesne.Comment)

    @aciklama.setter
    def aciklama(self, value: str):
        self.catNesne.Comment = value

    @property
    def aktif(self) -> bool:
        return bool(self.catNesne.Active)

    @aktif.setter
    def aktif(self, value: bool):
        self.catNesne.Active = value

    @property
    def processDokuman(self) -> IProcessDokuman:
        return IProcessDokuman.IProcessDokuman(self.catNesne.Parent.Parent)

    @processDokuman.setter
    def processDokuman(self, value: IProcessDokuman):
        self.__processDokuman = value

    @property
    def dizaynGeometriListesi(self) -> list:
        evalCode = """
			Dim CurrentSetup As ManufacturingSetup
             Set CurrentSetup = PO
             Dim DesignGeometriesListSize As Long
             DesignGeometriesListSize = CurrentSetup.DesignGeometriesCount
             If DesignGeometriesListSize > 0 Then
               Dim ListOfDesignGeometries() As Variant
               Redim ListOfDesignGeometries(DesignGeometriesListSize-1)
               CurrentSetup.ListDesignGeometries(ListOfDesignGeometries)
             End If
			return = ListOfDesignGeometries
		"""
        rsltex = self.anaProgram.eval(
            evalCode, "PO As Object", [self.catNesne])
        rslt = [IFikomObject(obj=nesne) for nesne in rsltex]
        return rslt

    @property
    def dizaynGeometriSayisi(self) -> int:
        return int(self.catNesne.DesignGeometriesCount())

    @property
    def fiksturGeometriListesi(self) -> list:
        evalCode = """
			Dim CurrentSetup As ManufacturingSetup
             Set CurrentSetup = PO
             Dim FixtureGeometriesListSize As Long
             FixtureGeometriesListSize = CurrentSetup.FixtureGeometriesCount
             If FixtureGeometriesListSize > 0 Then
               Dim ListOfFixtureGeometries() As Variant
               Redim ListOfFixtureGeometries(FixtureGeometriesListSize-1)
               CurrentSetup.ListFixtureGeometries(ListOfFixtureGeometries)
             End If

			return = ListOfFixtureGeometries
		"""
        rsltex = self.anaProgram.eval(
            evalCode, "PO As Object", [self.catNesne])
        if rsltex:
            rslt = [IFikomObject(obj=nesne) for nesne in rsltex]
        else:
            rslt = []
        return rslt

    @property
    def fiksturGeometriSayisi(self) -> int:
        return int(self.catNesne.FixtureGeometriesCount())

    @property
    def islemModelListesi(self) -> list:
        evalCode = """
			 Dim CurrentSetup As ManufacturingSetup
             Set CurrentSetup = PO
             Dim IPMBodiesListSize As Long
             IPMBodiesListSize = CurrentSetup.InProcessModelBodiesCount
             If IPMBodiesListSize > 0 Then
               Dim ListOfIPMBodies() As Variant
               Redim ListOfIPMBodies(IPMBodiesListSize-1)
               CurrentSetup.ListInProcessModelBodies(ListOfIPMBodies)
             End If
			return = ListOfIPMBodies
		"""
        rsltex = self.anaProgram.eval(
            evalCode, "PO As Object", [self.catNesne])
        if rsltex:
            rslt = [IFikomObject(obj=nesne) for nesne in rsltex]
        else:
            rslt = []
        return rslt

    @property
    def islemModelSayisi(self) -> int:
        return int(self.catNesne.InProcessModelBodiesCount())

    @property
    def kutukListesi(self) -> list:
        evalCode = """
			 Dim CurrentSetup As ManufacturingSetup
             Set CurrentSetup = PO
             Dim StockGeometriesListSize As Long
             StockGeometriesListSize = CurrentSetup.StockGeometriesCount
             If StockGeometriesListSize > 0 Then
               Dim ListOfStockGeometries() As Variant
               Redim ListOfStockGeometries(StockGeometriesListSize-1)
               CurrentSetup.ListStockGeometries(ListOfStockGeometries)
             End If
			return = ListOfStockGeometries
		"""
        rsltex = self.anaProgram.eval(
            evalCode, "PO As Object", [self.catNesne])
        if rsltex:
            rslt = [IFikomObject(obj=nesne) for nesne in rsltex]
        else:
            rslt = []
        return rslt

    @property
    def kutukSayisi(self) -> int:
        return int(self.catNesne.StockGeometriesCount())

    @property
    def partIsmi(self) -> str:
        try:
            return str(self.catNesne.GetPartName())
        except Exception:
            return ""

    @property
    def guvenlikDuzlemi(self):
        from IGuvenlikDuzlemi import IGuvenlikDuzlemi

        return IGuvenlikDuzlemi(iArray=self.catNesne.GetSafetyPlane())

    @guvenlikDuzlemi.setter
    def guvenlikDuzlemi(self, value):
        pass

    @property
    def makine(self):
        """
        Tanımlı Part Operasyonunun Makinesini IMakine Nesnesi Olarak Döndürür
        :return: IMakine
        """
        from IMakine import IMakine

        return IMakine(obj=self.catNesne.Machine, sahip=self)

    def makineYarat(self, MknIsmi, Out="APT", Tzg="IMSPPCC_MILL.pptable"):
        """
        Yeni Bir Makine Oluşturmak İçin Kullanılır

        :param MknIsmi: İsim Veriyor
        :param Out: Standart Post Tipi
        :param Tzg: Tezgah ppTable'ı
        :return: IMakine
        """
        Mkn = self.catNesne.CreateMachine(MknIsmi)
        Mkn.GetAttribute("MFG_OUTPUT_TYPE").ValuateFromString(Out)
        Mkn.PPTableName = Tzg
        return IMakine(Mkn, self.obj)

    @property
    def islemeEkseni(self):
        from IMakineIslemeEkseni import IMakineIslemeEkseni

        return IMakineIslemeEkseni(obj=self.catNesne.MachiningAxisSystem, sahip=self)

    @islemeEkseni.setter
    def islemeEkseni(self, value):
        pass

    @property
    def eksen(self):
        from IYardimciSiniflar import XYZO

        evalCode = """
			Dim dirc(3, 2) As Double
			PO.MachiningAxisSystem.GetOriginXDirection dirc(0, 0), dirc(0, 1), dirc(0, 2)
			PO.MachiningAxisSystem.GetOriginYDirection dirc(1, 0), dirc(1, 1), dirc(1, 2)
			PO.MachiningAxisSystem.GetOriginZDirection dirc(2, 0), dirc(2, 1), dirc(2, 2)
			PO.MachiningAxisSystem.GetOriginPoint dirc(3, 0), dirc(3, 1), dirc(3, 2)
			return = dirc
		"""
        try:
            rslt = self.anaProgram.eval(
                evalCode, "PO As Object", [self.catNesne])
        except:
            rslt = [[1, 0, 0], [0, 1, 0], [0, 0, 1], [0, 0, 0]]
        # ---->
        return XYZO(
            X=[rslt[0][0], rslt[0][1], rslt[0][2]],
            Y=[rslt[1][0], rslt[1][1], rslt[1][2]],
            Z=[rslt[2][0], rslt[2][1], rslt[2][2]],
            O=[rslt[3][0], rslt[3][1], rslt[3][2]],
        )

    @eksen.setter
    def eksen(self, value):
        evalCode = """
			PO.MachiningAxisSystem.SetOriginXDirection X1, X2, X3
			PO.MachiningAxisSystem.SetOriginZDirection Z1, Z2, Z3
			PO.MachiningAxisSystem.SetOriginPointByCoordinates O1, O2, O3
			'return = ""
		"""
        self.anaProgram.eval(
            evalCode,
            "PO As Object, X1,X2,X3, Z1,Z2,Z3 ,O1,O2,O3",
            [
                self.catNesne,
                value.X[0],
                value.X[1],
                value.X[2],
                value.Z[0],
                value.Z[1],
                value.Z[2],
                value.O[0],
                value.O[1],
                value.O[2],
            ],
        )

    @property
    def eksenIsmi(self) -> str:
        return self.catNesne.MachiningAxisSystem.Name

    @eksenIsmi.setter
    def eksenIsmi(self, value: str):
        self.catNesne.MachiningAxisSystem.Name = value

    @property
    def programlar(self) -> IProgramlar:
        from IProgramlar import IProgramlar

        return IProgramlar(obj=self.catNesne, sahip=self)

    @property
    def parametreler(self):
        from IParametreler import IParametreler

        return IParametreler(obj=self.catNesne.Parameters, sahip=self)

    @property
    def urunDokumani(self) -> IProduct:
        return IProduct(obj=self.catNesne.GetProductInstance(), sahip=self.anaProgram)

    @urunDokumani.setter
    def urunDokumani(self, value: IProduct):
        if isinstance(value, IFikomObject):
            self.catNesne.SetProductAndReconciliate(value.catNesne)
        else:
            self.catNesne.SetProductAndReconciliate(value)

    @property
    def carpmaKontrolu(self) -> bool:
        return self.parametreler["Activate collisions checking"].degeri

    @carpmaKontrolu.setter
    def carpmaKontrolu(self, value: bool):
        self.parametreler["Activate collisions checking"].degeri = value

    @property
    def carpmaDizaynKontrolu(self) -> bool:
        return self.parametreler["Collisions checking on design part"].degeri

    @carpmaDizaynKontrolu.setter
    def carpmaDizaynKontrolu(self, value: bool):
        self.parametreler["Collisions checking on design part"].degeri = value

    @property
    def carpmaFiksturKontrolu(self) -> bool:
        return self.parametreler["Collisions checking on fixtures"].degeri

    @carpmaFiksturKontrolu.setter
    def carpmaFiksturKontrolu(self, value: bool):
        self.parametreler["Collisions checking on fixtures"].degeri = value

    @property
    def carpmaKutukKontrolu(self) -> bool:
        return self.parametreler["Collisions checking on input stock"].degeri

    @carpmaKutukKontrolu.setter
    def carpmaKutukKontrolu(self, value: bool):
        self.parametreler["Collisions checking on input stock"].degeri = value

    @property
    def carpmaTakimOffset(self) -> float:
        return self.parametreler["Offset on tool shank"].degeri

    @carpmaTakimOffset.setter
    def carpmaTakimOffset(self, value: float):
        self.parametreler["Offset on tool shank"].degeri = value

    @property
    def carpmaTutucuOffset(self) -> float:
        return self.parametreler["Offset on tool assembly"].degeri

    @carpmaTutucuOffset.setter
    def carpmaTutucuOffset(self, value: float):
        self.parametreler["Offset on tool assembly"].degeri = value

    @property
    def kutukTakibi(self) -> bool:
        return self.parametreler["MfgIntermediateStockIsActive"].degeri

    @kutukTakibi.setter
    def kutukTakibi(self, value: bool):
        self.parametreler["MfgIntermediateStockIsActive"].degeri = value

    @property
    def kutukTakibiGecis(self) -> float:
        return self.parametreler["MfgSafetyDistanceOnStock"].degeri

    @kutukTakibiGecis.setter
    def kutukTakibiGecis(self, value: float):
        self.parametreler["MfgSafetyDistanceOnStock"].degeri = value

    @property
    def takimDegisimKoordinatlari(self):
        from IYardimciSiniflar import XYZ

        return XYZ(
            X=self.parametreler["Tool change point X"].degeri,
            Y=self.parametreler["Tool change point Y"].degeri,
            Z=self.parametreler["Tool change point Z"].degeri,
        )

    @takimDegisimKoordinatlari.setter
    def takimDegisimKoordinatlari(self, value):
        from IYardimciSiniflar import XYZ
        if isinstance(value, list):
            self.parametreler["Tool change point X"].degeri = value[0]
            self.parametreler["Tool change point Y"].degeri = value[1]
            self.parametreler["Tool change point Z"].degeri = value[2]
        elif isinstance(value, XYZ):
            self.parametreler["Tool change point X"].degeri = value.X
            self.parametreler["Tool change point Y"].degeri = value.Y
            self.parametreler["Tool change point Z"].degeri = value.Z

    @property
    def takimDegisimKoordinatlariAktif(self) -> bool:
        return self.parametreler["Tool change point"].degeri

    @takimDegisimKoordinatlariAktif.setter
    def takimDegisimKoordinatlariAktif(self, value: bool):
        self.parametreler["Tool change point"].degeri = value

    @property
    def referansKoordinatlari(self):
        from IYardimciSiniflar import XYZ

        return XYZ(
            X=self.parametreler["MfgSetUpHomePointX"].degeri,
            Y=self.parametreler["MfgSetUpHomePointY"].degeri,
            Z=self.parametreler["MfgSetUpHomePointZ"].degeri,
        )

    @referansKoordinatlari.setter
    def referansKoordinatlari(self, value):
        from IYardimciSiniflar import XYZ
        if isinstance(value, list):
            self.parametreler["MfgSetUpHomePointX"].degeri = value[0]
            self.parametreler["MfgSetUpHomePointY"].degeri = value[1]
            self.parametreler["MfgSetUpHomePointZ"].degeri = value[2]
        elif isinstance(value, XYZ):
            self.parametreler["MfgSetUpHomePointX"].degeri = value.X
            self.parametreler["MfgSetUpHomePointY"].degeri = value.Y
            self.parametreler["MfgSetUpHomePointZ"].degeri = value.Z

    @property
    def referansYonu(self):
        from IYardimciSiniflar import IJK

        return IJK(
            I=self.parametreler["MfgSetUpHomePointI"].degeri,
            J=self.parametreler["MfgSetUpHomePointJ"].degeri,
            K=self.parametreler["MfgSetUpHomePointK"].degeri,
        )

    @referansYonu.setter
    def referansYonu(self, value):
        from IYardimciSiniflar import IJK
        if isinstance(value, list):
            self.parametreler["MfgSetUpHomePointI"].degeri = value[0]
            self.parametreler["MfgSetUpHomePointJ"].degeri = value[1]
            self.parametreler["MfgSetUpHomePointK"].degeri = value[2]
        elif isinstance(value, IJK):
            self.parametreler["MfgSetUpHomePointI"].degeri = value.I
            self.parametreler["MfgSetUpHomePointJ"].degeri = value.J
            self.parametreler["MfgSetUpHomePointK"].degeri = value.K

    @property
    def referansKoordinatlariAktif(self) -> bool:
        return self.parametreler["MfgUseMachineHomePoint"].degeri

    @referansKoordinatlariAktif.setter
    def referansKoordinatlariAktif(self, value: bool):
        self.parametreler["MfgUseMachineHomePoint"].degeri = value

    @property
    def tablaMerkezKoordinatlari(self):
        from IYardimciSiniflar import XYZ, XYZO, IJK

        return XYZ(
            X=self.parametreler["SetUp delta X"].degeri,
            Y=self.parametreler["SetUp delta Y"].degeri,
            Z=self.parametreler["SetUp delta Z"].degeri,
        )

    @tablaMerkezKoordinatlari.setter
    def tablaMerkezKoordinatlari(self, value):
        from IYardimciSiniflar import XYZ, XYZO, IJK
        if isinstance(value, list):
            self.parametreler["SetUp delta X"].degeri = value[0]
            self.parametreler["SetUp delta Y"].degeri = value[1]
            self.parametreler["MfgSetUpHomePointZ"].degeri = value[2]
        elif isinstance(value, XYZ):
            self.parametreler["SetUp delta X"].degeri = value.X
            self.parametreler["SetUp delta Y"].degeri = value.Y
            self.parametreler["SetUp delta Z"].degeri = value.Z

    @property
    def simulasyonKutukHassasiyeti(self) -> float:
        return self.parametreler["Stocks Accuracy"].degeri

    @simulasyonKutukHassasiyeti.setter
    def simulasyonKutukHassasiyeti(self, value: float):
        self.parametreler["Stocks Accuracy"].degeri = value

    @property
    def dizaynHassasiyeti(self) -> float:
        return self.parametreler["Designs Accuracy"].degeri

    @dizaynHassasiyeti.setter
    def dizaynHassasiyeti(self, value: float):
        self.parametreler["Designs Accuracy"].degeri = value

    @property
    def dizaynSinirOlculeri(self):
        from IYardimciSiniflar import XYZ

        scriptDosya = os.path.join(self.__dosya, "FikoMfgKtkOlc.FikoDll")

        part = self.urunDokumani.referansProduct.dokuman.asPartDokuman.part

        yonler = self.islemeEkseni

        hsf = part.catNesne.HybridShapeFactory

        bodyer = part.catNesne.hybridBodies
        try:
            fikoBody = bodyer.item("FikoMantasyon")
            part.catNesne.InWorkObject = fikoBody
            part.guncelle()
        except:
            fikoBody = bodyer.add()
            fikoBody.name = "FikoMantasyon"

        if self.dizaynGeometriSayisi > 0:
            bodyReferans = [x.catNesne for x in self.dizaynGeometriListesi]
        else:
            bodyReferans = [part.catNesne.mainBody]
        dndr: List = []
        for rfrns in bodyReferans:
            factory = part.catNesne.GetCustomerFactory("InstanceFactory")

            factory.BeginInstanceFactory("FikoKutukOlculeri", scriptDosya)

            factory.BeginInstantiate()
            factory.PutInputData("ParcaBody", bodyReferans[0])

            Instance = factory.Instantiate()

            factory.EndInstantiate()
            factory.EndInstanceFactory()

            Instance.GetParameter("O.X").value = yonler.merkez.X
            Instance.GetParameter("O.Y").value = yonler.merkez.Y
            Instance.GetParameter("O.Z").value = yonler.merkez.Z

            Instance.GetParameter("X.X").value = yonler.x.X
            Instance.GetParameter("X.Y").value = yonler.x.Y
            Instance.GetParameter("X.Z").value = yonler.x.Z

            Instance.GetParameter("Y.X").value = yonler.y.X
            Instance.GetParameter("Y.Y").value = yonler.y.Y
            Instance.GetParameter("Y.Z").value = yonler.y.Z

            Instance.GetParameter("Z.X").value = yonler.z.X
            Instance.GetParameter("Z.Y").value = yonler.z.Y
            Instance.GetParameter("Z.Z").value = yonler.z.Z

            part.guncelle()

            param1 = Instance

            rslt = param1.GetParameter("Olculer").value

            if rslt == "x100x70":
                rslt = "0x0x0"

            rtrn = []
            for dgr in rslt.split("x"):
                try:
                    rtrn.append(float(dgr.replace(",", ".")))
                except:
                    rtrn.append(float(dgr.replace(".", ",")))

            dndr = XYZ(rtrn[0], rtrn[1], rtrn[2])
        # --->
        # Xlist=[]
        # Ylist=[]
        # Zlist=[]
        # for itm in dndr:
        #     Xlist.append(itm.X)
        #     Ylist.append(itm.Y)
        #     Zlist.append(itm.Z)
        # print(Xlist)
        # Xmin = min(Xlist)
        # Xmax =max(Xlist)
        # Ymin = min(Ylist)
        # Ymax = max(Ylist)
        # Zmin = min(Zlist)
        # Zmax = max(Zlist)
        # print(
        #     Xmin,
        #     Xmax,
        #     Ymin,
        #     Ymax,
        #     Zmin,
        #     Zmax,
        # )
        return dndr

    @property
    def kutukSinirOlculeri(self):
        from IYardimciSiniflar import XYZ

        # -->
        scriptDosya = os.path.join(self.__dosya, "FikoMfg0.FikoDll")

        part = self.urunDokumani.referansProduct.dokuman.asPartDokuman.part

        yonler = self.islemeEkseni

        hsf = part.catNesne.HybridShapeFactory

        bodyer = part.catNesne.hybridBodies
        try:
            fikoBody = bodyer.item("FikoMantasyon")
            part.catNesne.InWorkObject = fikoBody
        except:
            fikoBody = bodyer.add()
            fikoBody.name = "FikoMantasyon"

        if self.kutukSayisi > 0:
            bodyReferans = [x.catNesne for x in self.kutukListesi]
        else:
            return XYZ(0.0, 0.0, 0.0)
        dndr: List = []
        for rfrns in bodyReferans:
            factory = part.catNesne.GetCustomerFactory("InstanceFactory")

            factory.BeginInstanceFactory("Fiko0", scriptDosya)

            factory.BeginInstantiate()
            factory.PutInputData("ParcaBody", rfrns)

            Instance = factory.Instantiate()

            factory.EndInstantiate()
            factory.EndInstanceFactory()

            Instance.GetParameter("O.X").value = yonler.merkez.X
            Instance.GetParameter("O.Y").value = yonler.merkez.Y
            Instance.GetParameter("O.Z").value = yonler.merkez.Z

            Instance.GetParameter("X.X").value = yonler.x.X
            Instance.GetParameter("X.Y").value = yonler.x.Y
            Instance.GetParameter("X.Z").value = yonler.x.Z

            Instance.GetParameter("Y.X").value = yonler.y.X
            Instance.GetParameter("Y.Y").value = yonler.y.Y
            Instance.GetParameter("Y.Z").value = yonler.y.Z

            Instance.GetParameter("Z.X").value = yonler.z.X
            Instance.GetParameter("Z.Y").value = yonler.z.Y
            Instance.GetParameter("Z.Z").value = yonler.z.Z

            part.guncelle()

            param1 = Instance

            rslt = []
            rslt.append(param1.GetParameter("Xmin").value)
            rslt.append(param1.GetParameter("Xmax").value)
            rslt.append(param1.GetParameter("Ymin").value)
            rslt.append(param1.GetParameter("Ymax").value)
            rslt.append(param1.GetParameter("Zmin").value)
            rslt.append(param1.GetParameter("Zmax").value)

            self.urunDokumani.referansProduct.dokuman.secililer.temizle()
            self.urunDokumani.referansProduct.dokuman.secililer.ekle(Instance)
            self.urunDokumani.referansProduct.dokuman.secililer.gorunur = False

            dndr.append(SifirKonum(*rslt))
        # --->
        Xminlist = []
        Xmaxlist = []
        Yminlist = []
        Ymaxlist = []
        Zminlist = []
        Zmaxlist = []
        for itm in dndr:
            Xminlist.append(abs(itm.Xmin))
            Xmaxlist.append(abs(itm.Xmax))

            Yminlist.append(abs(itm.Ymin))
            Ymaxlist.append(abs(itm.Ymax))

            Zminlist.append(abs(itm.Zmin))
            Zmaxlist.append(abs(itm.Zmax))

        Xmin = max(Xminlist)
        Xmax = max(Xmaxlist)
        Ymin = max(Yminlist)
        Ymax = max(Ymaxlist)
        Zmin = max(Zminlist)
        Zmax = max(Zmaxlist)

        rslt = SifirKonum(Xmin, Xmax, Ymin, Ymax, Zmin, Zmax)
        return XYZ(rslt.XOlcusu, rslt.YOlcusu, rslt.ZOlcusu)

        # --->
        scriptDosya = os.path.join(self.__dosya, "FikoMfgKtkOlc.FikoDll")

        part = self.urunDokumani.referansProduct.dokuman.asPartDokuman.part

        yonler = self.islemeEkseni

        hsf = part.catNesne.HybridShapeFactory

        bodyer = part.catNesne.hybridBodies
        try:
            fikoBody = bodyer.item("FikoMantasyon")
            part.catNesne.InWorkObject = fikoBody
            part.guncelle()
        except:
            fikoBody = bodyer.add()
            fikoBody.name = "FikoMantasyon"

        if self.kutukSayisi > 0:
            bodyReferans = self.kutukListesi[0].catNesne
        else:
            return XYZ(0.0, 0.0, 0.0)

        factory = part.catNesne.GetCustomerFactory("InstanceFactory")

        factory.BeginInstanceFactory("FikoKutukOlculeri", scriptDosya)

        factory.BeginInstantiate()
        factory.PutInputData("ParcaBody", bodyReferans)

        Instance = factory.Instantiate()

        factory.EndInstantiate()
        factory.EndInstanceFactory()

        Instance.GetParameter("O.X").value = yonler.merkez.X
        Instance.GetParameter("O.Y").value = yonler.merkez.Y
        Instance.GetParameter("O.Z").value = yonler.merkez.Z

        Instance.GetParameter("X.X").value = yonler.x.X
        Instance.GetParameter("X.Y").value = yonler.x.Y
        Instance.GetParameter("X.Z").value = yonler.x.Z

        Instance.GetParameter("Y.X").value = yonler.y.X
        Instance.GetParameter("Y.Y").value = yonler.y.Y
        Instance.GetParameter("Y.Z").value = yonler.y.Z

        Instance.GetParameter("Z.X").value = yonler.z.X
        Instance.GetParameter("Z.Y").value = yonler.z.Y
        Instance.GetParameter("Z.Z").value = yonler.z.Z

        part.guncelle()

        param1 = Instance

        rslt = param1.GetParameter("Olculer").value

        if rslt == "x100x70":
            rslt = "0x0x0"

        rtrn = []
        for dgr in rslt.split("x"):
            try:
                rtrn.append(float(dgr.replace(",", ".")))
            except:
                rtrn.append(float(dgr.replace(".", ",")))

        dndr = XYZ(rtrn[0], rtrn[1], rtrn[2])
        return dndr

    @property
    def Z0(self):
        return self.sifirKonum.Zmin
        # --->
        # scriptDosya = os.path.join(self.__dosya, "FikoMfgZ0.FikoDll")
        #
        # part = self.urunDokumani.referansProduct.dokuman.asPartDokuman.part
        #
        # yonler = self.islemeEkseni
        #
        # hsf = part.catNesne.HybridShapeFactory
        #
        # bodyer = part.catNesne.hybridBodies
        # try:
        #     fikoBody = bodyer.item("FikoMantasyon")
        #     part.catNesne.InWorkObject = fikoBody
        # except:
        #     fikoBody = bodyer.add()
        #     fikoBody.name = "FikoMantasyon"
        #
        # if self.dizaynGeometriSayisi > 0:
        #     bodyReferans = self.dizaynGeometriListesi[0].catNesne
        # else:
        #     return [0.0]
        #
        # factory = part.catNesne.GetCustomerFactory("InstanceFactory")
        #
        # factory.BeginInstanceFactory("FikoZ0", scriptDosya)
        #
        # factory.BeginInstantiate()
        # factory.PutInputData("ParcaBody", bodyReferans)
        #
        # Instance = factory.Instantiate()
        #
        # factory.EndInstantiate()
        # factory.EndInstanceFactory()
        #
        # Instance.GetParameter("O.X").value = yonler.merkez.X
        # Instance.GetParameter("O.Y").value = yonler.merkez.Y
        # Instance.GetParameter("O.Z").value = yonler.merkez.Z
        #
        # Instance.GetParameter("X.X").value = yonler.x.X
        # Instance.GetParameter("X.Y").value = yonler.x.Y
        # Instance.GetParameter("X.Z").value = yonler.x.Z
        #
        # Instance.GetParameter("Y.X").value = yonler.y.X
        # Instance.GetParameter("Y.Y").value = yonler.y.Y
        # Instance.GetParameter("Y.Z").value = yonler.y.Z
        #
        # Instance.GetParameter("Z.X").value = yonler.z.X
        # Instance.GetParameter("Z.Y").value = yonler.z.Y
        # Instance.GetParameter("Z.Z").value = yonler.z.Z
        #
        # part.guncelle()
        #
        # param1 = Instance
        #
        # rslt = param1.GetParameter("FikoZ0").value
        #
        # return rslt

    @property
    def sifirKonum(self) -> SifirKonum:
        if self._sifirKonum:
            return self._sifirKonum

        scriptDosya = os.path.join(self.__dosya, "FikoMfg0.FikoDll")

        part = self.urunDokumani.referansProduct.dokuman.asPartDokuman.part

        yonler = self.islemeEkseni

        hsf = part.catNesne.HybridShapeFactory

        bodyer = part.catNesne.hybridBodies
        try:
            fikoBody = bodyer.item("FikoMantasyon")
            part.catNesne.InWorkObject = fikoBody
        except:
            fikoBody = bodyer.add()
            fikoBody.name = "FikoMantasyon"

        if self.dizaynGeometriSayisi > 0:
            bodyReferans = [x.catNesne for x in self.dizaynGeometriListesi]
        else:
            bodyReferans = [part.catNesne.mainBody]
        dndr: List = []
        for rfrns in bodyReferans:
            factory = part.catNesne.GetCustomerFactory("InstanceFactory")

            factory.BeginInstanceFactory("Fiko0", scriptDosya)

            factory.BeginInstantiate()
            factory.PutInputData("ParcaBody", rfrns)

            Instance = factory.Instantiate()

            factory.EndInstantiate()
            factory.EndInstanceFactory()

            Instance.GetParameter("O.X").value = yonler.merkez.X
            Instance.GetParameter("O.Y").value = yonler.merkez.Y
            Instance.GetParameter("O.Z").value = yonler.merkez.Z

            Instance.GetParameter("X.X").value = yonler.x.X
            Instance.GetParameter("X.Y").value = yonler.x.Y
            Instance.GetParameter("X.Z").value = yonler.x.Z

            Instance.GetParameter("Y.X").value = yonler.y.X
            Instance.GetParameter("Y.Y").value = yonler.y.Y
            Instance.GetParameter("Y.Z").value = yonler.y.Z

            Instance.GetParameter("Z.X").value = yonler.z.X
            Instance.GetParameter("Z.Y").value = yonler.z.Y
            Instance.GetParameter("Z.Z").value = yonler.z.Z

            part.guncelle()

            param1 = Instance

            rslt = []
            rslt.append(param1.GetParameter("Xmin").value)
            rslt.append(param1.GetParameter("Xmax").value)
            rslt.append(param1.GetParameter("Ymin").value)
            rslt.append(param1.GetParameter("Ymax").value)
            rslt.append(param1.GetParameter("Zmin").value)
            rslt.append(param1.GetParameter("Zmax").value)

            self.urunDokumani.referansProduct.dokuman.secililer.temizle()
            self.urunDokumani.referansProduct.dokuman.secililer.ekle(Instance)
            self.urunDokumani.referansProduct.dokuman.secililer.gorunur = False

            dndr.append(SifirKonum(*rslt))
        # --->
        Xminlist = []
        Xmaxlist = []
        Yminlist = []
        Ymaxlist = []
        Zminlist = []
        Zmaxlist = []
        for itm in dndr:
            Xminlist.append(abs(itm.Xmin))
            Xmaxlist.append(abs(itm.Xmax))

            Yminlist.append(abs(itm.Ymin))
            Ymaxlist.append(abs(itm.Ymax))

            Zminlist.append(abs(itm.Zmin))
            Zmaxlist.append(abs(itm.Zmax))

        Xmin = max(Xminlist)
        Xmax = max(Xmaxlist)
        Ymin = max(Yminlist)
        Ymax = max(Ymaxlist)
        Zmin = max(Zminlist)
        Zmax = max(Zmaxlist)

        self.__sifirKonum = SifirKonum(Xmin, Xmax, Ymin, Ymax, Zmin, Zmax)
        return self.__sifirKonum

    @property
    def mfgGorunum(self):
        from IMfgGorunum.IMfgGorunum import IMfgGorunum

        evalCode = """
        Dim CurrentSetup As ManufacturingSetup
        Set CurrentSetup = PO
        Dim mfgView As ManufacturingView
        Set MfgView = PO.GetManufacturingView

        set return = MfgView
        """
        rslt = self.anaProgram.eval(evalCode, "PO as Object", [self.catNesne])
        return IMfgGorunum(obj=rslt, sahip=self)

    def exportFikoGL(self):
        rslt = {"ismi": self.ismi, "aciklama": self.aciklama}

        islemeEkseni: dict = {}
        islemeEkseni["x"] = self.islemeEkseni.x.to_array()
        islemeEkseni["y"] = self.islemeEkseni.y.to_array()
        islemeEkseni["z"] = self.islemeEkseni.z.to_array()
        islemeEkseni["merkez"] = self.islemeEkseni.merkez.to_array()

        rslt["islemeEkseni"] = islemeEkseni
        # ---->
        partDokuman = self.urunDokumani.referansProduct.dokuman
        dosya_ismi = self.ismi
        if os.path.exists(os.path.join(
            partDokuman.klasoru, dosya_ismi +
            ".FikoWrl"
        )):
            os.remove(os.path.join(
                partDokuman.klasoru,
                dosya_ismi
                + ".FikoWrl"
            ))

        partDokuman.veriAktar(
            os.path.join(
                partDokuman.klasoru
                , dosya_ismi
                + ".FikoWrl"
            ),
            "wrl",
        )
        with open(
            os.path.join(
                partDokuman.klasoru
                , dosya_ismi
                + ".FikoWrl"
            )
        ) as f:
            contents = f.read()
        rslt["cizim"] = contents
        # --->
        programlar = []
        for i in range(self.programlar.sayisi):
            prg: IProgram = self.programlar.item(i)
            if prg.bos and prg.isimsiz == False:
                programlar.append(
                    {"ismi": prg.ismi, "aciklama": prg.aciklama, "apt": None}
                )
            else:
                aptFilePath = prg.apt
                with open(aptFilePath, "r") as f:
                    programlar.append(
                        {
                            "ismi": prg.ismi,
                            "aciklama": prg.aciklama,
                            "apt": f.readlines(),
                        }
                    )
        rslt["programlar"] = programlar
        # pprint(programlar)
        if os.path.exists(
            os.path.join(
                partDokuman.klasoru
                , dosya_ismi
                + ".FikoOpGL"
            )
        ):
            os.remove(
                os.path.join(
                    partDokuman.klasoru
                    , dosya_ismi
                    + ".FikoOpGL"
                ),
            )
        with open(
            os.path.join(
                partDokuman.klasoru
                , dosya_ismi
                + ".FikoOpGL"
            ),
            "w",
        ) as fp:
            json.dump(rslt, fp)
        pass

    def exportFikoGL1(self):
        rslt = {"ismi": self.ismi, "aciklama": self.aciklama, "turu": self.tipi}

        islemeEkseni: dict = {}
        islemeEkseni["x"] = self.islemeEkseni.x.to_array()
        islemeEkseni["y"] = self.islemeEkseni.y.to_array()
        islemeEkseni["z"] = self.islemeEkseni.z.to_array()
        islemeEkseni["merkez"] = self.islemeEkseni.merkez.to_array()

        rslt["islemeEkseni"] = islemeEkseni
        # ---->
        partDokuman = self.urunDokumani.referansProduct.dokuman
        if os.path.exists(
            partDokuman.klasoru
            + "//"
            + partDokuman.ismi.replace(partDokuman.turu, "")
            + ".FikoWrl"
        ):
            os.remove(
                partDokuman.klasoru
                + "//"
                + partDokuman.ismi.replace(partDokuman.turu, "")
                + ".FikoWrl"
            )

        partDokuman.veriAktar(
            partDokuman.klasoru
            + "//"
            + partDokuman.ismi.replace(partDokuman.turu, "")
            + ".FikoWrl",
            "wrl",
        )
        with open(
            partDokuman.klasoru
            + "//"
            + partDokuman.ismi.replace(partDokuman.turu, "")
            + ".FikoWrl"
        ) as f:
            cizimContents = f.read()
        #rslt["cizim"] = cizimContents
        # --->
        programlar = []
        for i in range(self.programlar.sayisi):
            programlar.append(self.programlar[i].toFikoGL)
            # aktiviteler = []
            # prg: IProgram = self.programlar.item(i)
            # for ai in range(prg.aktiviteler.sayisi):
            #     akt: IAktivite = prg.aktiviteler.item(ai)
            #     aktiviteler.append({
            #         "ismi": akt.ismi,
            #         "aciklama": akt.aciklama,
            #         "turu": akt.turu,
            #         "parametreler": akt.fikoGlParametreler
            #     })
            # if prg.bos and prg.isimsiz == False:
            #     programlar.append(
            #         {"ismi": prg.ismi, "aciklama": prg.aciklama, "turu": prg.tipi}
            #     )
            # else:
            #     # aptFilePath = prg.apt
            #     # with open(aptFilePath, "r") as f:
            #     programlar.append(
            #         {
            #             "ismi": prg.ismi,
            #             "aciklama": prg.aciklama,
            #             "aktiviteler": aktiviteler,
            #             "turu": prg.tipi
            #             # "apt":f.readlines(),
            #         }
            #     )
        rslt["programlar"] = programlar

        if os.path.exists(
            partDokuman.klasoru
            + "\\"
            + partDokuman.ismi.replace(partDokuman.turu, "")
            + ".FikoOpGLv1"
        ):
            os.remove(
                partDokuman.klasoru
                + "\\"
                + partDokuman.ismi.replace(partDokuman.turu, "")
                + ".FikoOpGLv1"
            )
        with open(
            partDokuman.klasoru
            + "\\"
            + partDokuman.ismi.replace(partDokuman.turu, "")
            + ".FikoOpGLv1",
            "w",
        ) as fp:
            json.dump(rslt, fp)
        pass

    def toJson(self, onlyStr: bool = True):
        if not onlyStr:
            liste = self.__dir__()
            rslt = {}
            for x in liste:
                rslt[x] = getattr(self, x)

            return rslt
        else:
            rslt = {}
            rslt["ismi"] = self.ismi
            rslt["aciklama"] = self.aciklama
            rslt["aktif"] = self.aktif
            return rslt

    @property
    def fiko_op_gl_v1(self) -> IFikoOpGLv1:
        return IFikoOpGLv1(self)

    @property
    def toFikoGL(self):
        __rslt = {}
        programlar = []
        for prgi in range(self.programlar.sayisi):
            prg = self.programlar[prgi]
            programlar.append(prg.toFikoGL)
        __rslt = {
            "ismi": self.ismi,
            "aciklama": self.aciklama,
            "programlar": programlar,
            "turu": self.tipi,
            "islemeEkseni": {"x": self.islemeEkseni.x.to_array(), "y": self.islemeEkseni.y.to_array(), "z": self.islemeEkseni.z.to_array(), "merkez": self.islemeEkseni.merkez.to_array()},
            # "apt":f.readlines(),
        }
        return __rslt

    def __str__(self, *args, **kwargs):
        return repr(self.ismi)
