import nazca as nd
import numpy as np
from numpy import pi

from ...routing import Route
from ...structures import _my_polygon,circle,Clothoid
from ...basic import __cell_arg__

class ring_bus_wg:
    ## two types:
    ## DC, BDC
    """
        Initialize ring-bus waveguide coupler settings.

        Parameters
        ----------
        xs : str, optional
            Waveguide cross-section name (default is "strip").
        R_cp : int, optional
            Coupling waveguide bend radius in microns for BDC mode (default is 20).
        w_bus : float, optional
            Coupling waveguide width in microns (default is 0.5).
        w_wg : float, optional
            Port waveguide width in microns (default is 0.5).
        bend_DC : bool, optional
            Use bend directional coupler (True) or straight DC (False, default is True).
        dLc : int, optional
            Straight coupling length in microns for DC mode (default is 10).
        dAc : int, optional
            Coupling angle in degrees for BDC mode (default is 10).
        euler_transistion : bool, optional
            Enable Euler transition segments before/after the coupling arc (default is False).
        dL_trans : int, optional
            Straight transition length in microns when Euler transition is enabled (default is 10).
        dA_trans : int, optional
            Transition bend angle in degrees for the Euler segment (default is 30).
        R_max_trans : int, optional
            Maximum radius in microns for the transition segment (default is 100).
        w_trans : float, optional
            Waveguide width in microns inside the transition (default is 0.5).
        euler_anti_bend : bool, optional
            Enable Euler anti-bend routing after the coupling section (default is False).
        R_max_anti : int, optional
            Maximum radius in microns for the anti-bend segment (default is 100).
        R_min_anti : int, optional
            Minimum radius in microns for the anti-bend segment (default is 10).
        A_anti : float, optional
            Anti-bend angle in degrees (default is None, meaning auto-calculated).
        res : float, optional
            Geometry discretization step in microns (default is 0.1).
        wg_Ltp : int, optional
            Port taper length in microns (default is 5).
        dL_p2p : float, optional
            Target horizontal spacing in microns between input/output ports (default is None).
        sharp_patch : bool, optional
            Insert chamfer polygons to avoid sharp corners (default is True).
        show_pins : bool, optional
            Draw Nazca stub markers for debugging (default is False).
        end_patch : bool, optional
            Force small straight fillers at the end of Euler segments (default is False).
        clothoid_order : int, optional
            Order of the spiral section used inside :class:`Clothoid` transitions (default is 1).
    """
     
    def __init__(self,
                 xs='strip',
                 R_cp = 20,
                 w_bus = 0.5,
                 bend_DC = True, 
                 w_wg = 0.5,
                 dLc = 10,
                 dAc = 10,
                 
                 euler_transistion = False,
                 dL_trans = 10,
                 dA_trans = 30,
                 R_max_trans = 100,
                 w_trans = 0.5,
                 
                 euler_anti_bend = False,
                 R_max_anti = 100,
                 R_min_anti = 10,
                 A_anti = None,
                 res = 0.1,
                 wg_Ltp = 5,
                 dL_p2p = None,
                 sharp_patch = True,
                 show_pins = False,
                 end_patch = False,
                 clothoid_order = 1,
                 ) -> None:
       
        self.xs = xs
        self.R_cp = R_cp
        self.w_bus = w_bus
        self.dLc = dLc
        self.dAc = dAc
        # self.n_points = n_points
        self.w_wg = w_wg
        self.bend_DC = bend_DC
        self.euler_transistion = euler_transistion
        self.dL_trans = dL_trans
        self.dA_trans = dA_trans
        self.R_max_trans = R_max_trans
        self.w_trans = w_trans
        # self.euler_anti_bend = euler_anti_bend ## parameter abondond
        self.R_max_anti = R_max_anti
        self.R_min_anti = R_min_anti
        self.A_anti = A_anti
        self.wg_Ltp = wg_Ltp
        self.dL_p2p = dL_p2p
        self.res = res
        
        self.end_patch = end_patch
        
        self.L = 0
        self.clothoid_order = clothoid_order
        self.cell = self.generate_gds(sharp_patch=sharp_patch,show_pins=show_pins)
    
    def generate_gds(self,sharp_patch,show_pins=False):
        with nd.Cell(instantiate=False) as C:

            w_crack = 0.002
            if (self.bend_DC and self.euler_transistion):
                if (self.A_anti == None):
                    self.A_anti = self.dAc/2+self.dA_trans

                cp = Clothoid(R=[self.R_cp,self.R_cp,self.R_max_trans,self.R_min_anti,self.R_max_anti],
                                A=[0,       self.dAc/2,self.dAc/2+self.dA_trans,(self.dAc/2+self.dA_trans) - self.A_anti/2,(self.dAc/2+self.dA_trans) - self.A_anti],
                                w=[self.w_bus,self.w_bus,self.w_trans,(self.w_trans+self.w_wg)/2,self.w_wg],xs=self.xs,
                                spiral_order=[1,self.clothoid_order,1,1],
                                sharp_patch=sharp_patch,end_patch=self.end_patch)
                ar = cp.cell.put('a1',0,0,0).pin['b1']
                al = cp.cell.put('a1',0,0,180,flip=1).pin['b1']
                
                nd.strt(length=w_crack,width=self.w_bus,xs=self.xs).put(-w_crack/2,0,0)
                nd.strt(length=w_crack,width=self.w_wg,xs=self.xs).put(ar.x-w_crack/2,ar.y,0)
                nd.strt(length=w_crack,width=self.w_wg,xs=self.xs).put(al.x-w_crack/2,al.y,0)
                
                self.L = self.L + cp.L0
                
            elif (self.bend_DC):
                """ Bend DC without Euler transision """

            # if (self.bend_DC):
                cp = circle(xs=self.xs,radius=self.R_cp, width = self.w_bus, theta_start = 270-self.dAc/2, theta_stop=270+self.dAc/2,res=self.res,
                            # n_points=self.n_points,
                            sharp_patch=sharp_patch).cell.put(0,self.R_cp,0)
                al = cp.pin['a1']
                ar = cp.pin['b1']
                
                self.L = self.L + self.R_cp*self.dAc/180*np.pi

                self.w_trans = self.w_bus
                TL = nd.strt(length=self.dL_trans,width=self.w_bus,xs=self.xs).put('a0',al)            
                TR = nd.strt(length=self.dL_trans,width=self.w_bus,xs=self.xs).put('a0',ar)            
                Ainner = self.dAc/2
                
                self.L = self.L + self.dL_trans*2
            
                if (self.A_anti == None):
                    self.A_anti = Ainner
                
                Anti = circle(xs=self.xs,radius=self.R_max_anti, width = self.w_trans, theta_start = 90, theta_stop=90+self.A_anti,res=self.res,
                            # n_points=self.n_points,
                            sharp_patch=sharp_patch)
                ar = Anti.cell.put('b1',TR.pin['b0']).pin['a1'] 
                al = Anti.cell.put('b1',TL.pin['b0'],flip=1).pin['a1']       

                self.L = self.L + self.R_max_anti*self.A_anti*2*180/np.pi
            
            
            TPR = nd.taper(length=self.wg_Ltp,width1=ar.width,width2=self.w_wg,xs=self.xs).put('a0',ar)            
            TPL = nd.taper(length=self.wg_Ltp,width1=al.width,width2=self.w_wg,xs=self.xs).put('a0',al)    
            self.L = self.L + self.wg_Ltp*2
            
            L = (TPR.pin['b0'].x - TPL.pin['b0'].x) ## L distance pin2pin
            if (self.dL_p2p!=None):
                if (L<self.dL_p2p):
                    dL_patch = (self.dL_p2p - L)/2/np.cos(TPR.pin['b0'].a/180*np.pi)
                    TPR = nd.strt(length=dL_patch,width=self.w_wg,xs=self.xs).put(TPR.pin['b0'])      
                    TPL = nd.strt(length=dL_patch,width=self.w_wg,xs=self.xs).put(TPL.pin['b0'])  
                        
                    self.L = self.L + dL_patch*2
            
            # self.dL_patch = dL_patch
            nd.Pin(name='a1',pin=TPL.pin['b0'],width=self.w_wg).put()
            nd.Pin(name='b1',pin=TPR.pin['b0'],width=self.w_wg).put()
            
            nd.strt(length=0.1,width=TPL.pin['b0'].width,xs=self.xs).put(TPL.pin['b0'].move(-0.05,0,0))
            nd.strt(length=0.1,width=TPR.pin['b0'].width,xs=self.xs).put(TPR.pin['b0'].move(-0.05,0,0))

            self.w = self.w_bus
            self.sz = [abs(TPL.pin['b0'].x-TPR.pin['b0'].x),abs(TPL.pin['b0'].y)]
            
            if (show_pins):
                nd.put_stub()
          
        return C

        
class ADC_STD_2x2:
    """
        General-purpose 2×2 adiabatic directional coupler scaffold.

        Parameters
        ----------
        name : str, optional
            Unique cell identifier (default is None, meaning no instantiation).
        xs : str, optional
            Registered Nazca cross-section name (default is "strip").
        wu0 : float, optional
            Upper waveguide width at the input plane in microns (default is 0.45).
        wu1 : float, optional
            Upper waveguide width at the output plane in microns (default is 0.61).
        wu_in : float, optional
            Upper input port width in microns (default is 0.45).
        wu_out : float, optional
            Upper output port width in microns (default is 0.8).
        wd0 : float, optional
            Lower waveguide width at the input plane in microns (default is 0.33).
        wd1 : float, optional
            Lower waveguide width at the output plane in microns (default is 0.2).
        wd_in : float, optional
            Lower input port width in microns (default is 0.45).
        wd_out : float, optional
            Lower output port width in microns (default is 0.8).
        Lu : int, optional
            Interaction length of the upper core in microns (default is 33).
        Ld : int, optional
            Interaction length of the lower core in microns (default is 33).
        angle : int, optional
            Sbend deflection angle in degrees (default is 20).
        g0 : float, optional
            Gap between the two cores at the input plane in microns (default is 0.2).
        g1 : float, optional
            Gap between the two cores at the output plane in microns (default is 0.2).
        sbend_type : str, optional
            Type of IO transition ("euler" or "circular", default is "euler").
        Rmax : optional
            Maximum Euler bend radius in microns (default is None, meaning auto).
        Rmin : int, optional
            Minimum Euler bend radius in microns (default is 5).
        Ru0 : int, optional
            Upper input bend radius in microns (default is 0).
        Ru1 : int, optional
            Upper output bend radius in microns (default is 20).
        Rd0 : int, optional
            Lower input bend radius in microns (default is 20).
        Rd1 : int, optional
            Lower output bend radius in microns (default is 0).
        tp_angle : int, optional
            Half-angle of straight tapers in degrees when Euler bends are disabled (default is 2).
        sharp_patch : bool, optional
            Insert chamfer polygons to reduce acute corners (default is True).
        show_pins : bool, optional
            Draw Nazca stub markers for debugging (default is False).
        euler_points : int, optional
            Number of sampling points for Euler/Clothoid evaluation (default is 64).
        res : float, optional
            Geometry discretization step in microns (default is 0.1).
    """

    def __init__ (self,
                    name = None,
                    xs='strip',
                    wu0=0.45,
                    wu1=0.61,
                    wu_in=0.45,
                    wu_out=0.8,
                    wd0=0.33,
                    wd1=0.20,
                    wd_in=0.45,
                    wd_out=0.8,
                    Lu=33,
                    Ld=33,
                    angle=20,
                    g0=0.2,
                    g1=0.2,
                    sbend_type='euler',
                    Rmax=None,
                    Rmin=5,
                    Ru0=0,
                    Ru1=20,
                    Rd0=20,
                    Rd1=0,
                    tp_angle=2,
                    sharp_patch=True,
                    show_pins=False,
                    euler_points = 64,
                    res = 0.1):

        self.name = name
        if (self.name==None):
            self.instantiate = False
        else :
            self.instantiate = True
        
        self.wu0 = wu0
        self.xs = xs
        self.wu1 = wu1
        self.wu_in = wu_in
        self.wu_out = wu_out
        self.wd0 = wd0
        self.wd1 = wd1
        self.wd_in = wd_in
        self.wd_out = wd_out
        self.Lu = Lu
        self.Ld = Ld
        self.angle = angle
        self.g0 = g0
        self.g1 = g1
        self.sbend_type = sbend_type
        self.Rmax = Rmax
        self.Rmin = Rmin
        self.sharp_patch = sharp_patch
        self.euler_points = euler_points
        self.res = res

        if (Rmax!=None and Rmax!=0):
            if (Ru0!=0):
                Ru0 = Rmax
            if (Ru1!=0):
                Ru1 = Rmax
            if (Rd0!=0):
                Rd0 = Rmax
            if (Rd1!=0):
                Rd1 = Rmax

        self.Ru0 = Ru0
        self.Ru1 = Ru1
        self.Rd0 = Rd0
        self.Rd1 = Rd1
        self.tp_angle = tp_angle
        self.sharp_patch = sharp_patch
        self.cell = self.generate_gds(err=0,show_pins=show_pins)
        self.L = np.abs(self.cell.pin['a1'].x - self.cell.pin['b1'].x)
    
    def generate_gds(self,err=0,show_pins=False):

        with nd.Cell(instantiate = self.instantiate, name=self.name ) as C:
            for layers,growx,growy,acc in nd.layeriter(xs=self.xs):
                (a1,b1), (a2,b2),c1,c2 = growx
                
                vtx_upper_x = np.array([0,self.Lu,self.Lu,0])
                vtx_lower_x = np.array([0,self.Ld,self.Ld,0])
                
                ## consisting the error 
                vtx_upper_y = np.array([ (self.g0-err)/2+b2, (self.g1-err)/2+b2, (self.g1-err)/2+(self.wu1+err)+b1, (self.g0-err)/2+(self.wu0+err)+b1])  
                vtx_lower_y = np.array([-(self.g0-err)/2+b1,-(self.g1-err)/2+b1,-(self.g1-err)/2-(self.wd1+err)+b2,-(self.g0-err)/2-(self.wd0+err)+b2])  
                vtx_upper_x = np.array([0,self.Lu,self.Lu,0])
                vtx_lower_x = np.array([0,self.Ld,self.Ld,0])
                
                vtx_upper = np.c_[vtx_upper_x,vtx_upper_y]
                vtx_lower = np.c_[vtx_lower_x,vtx_lower_y]

                _my_polygon(layers,vtx_upper).put(0,0,0)
                _my_polygon(layers,vtx_lower).put(0,0,0)

            """ input waveguide wires of the left, upper port """
            if (self.Rd0!=0):
                ## placing the adiabatic bend attachment to lower waveguide, input port, label 0
                if (self.sbend_type=='euler'):
                    
                    attach_in = Clothoid(R=[self.Rd0,self.Rmin,self.Rd0] , w=[self.wd0,self.wd0], A=[0,self.angle/2,self.angle], dL_cal=0.001,dL_wg=self.res,
                                         xs=self.xs,width_type='linear',
                                         sharp_patch=self.sharp_patch,spiral_order=1)
                    attach_in.cell.put(0,vtx_lower_y[0]/2+vtx_lower_y[-1]/2,180,flip=0)
                    pin_a2 = Clothoid(R=[self.Rd0,self.Rmin,self.Rd0] , w=[self.wd0,self.wd_in], A=[self.angle,self.angle/2,0], dL_cal=0.001,dL_wg=self.res,
                                                xs=self.xs,width_type='linear',
                                                sharp_patch=self.sharp_patch,
                                                spiral_order=1).cell.put(flip=0).pin['b0']

                else: 
                    Ltp = np.max([0.5,np.abs(self.wd0-self.wd_in)/np.tan(self.tp_angle/180*pi)])
                    attach_in = Clothoid(R=[self.Rd0,self.Rd0,self.Rd0] , w=[self.wd0,self.wd0], A=[0,self.angle,0], dL_cal=0.001,dL_wg=self.res,
                        xs=self.xs,width_type='linear',end_patch=False,
                        sharp_patch=self.sharp_patch,spiral_order=1).cell.put(0,vtx_lower_y[0]/2+vtx_lower_y[-1]/2,180,flip=0)

                    # attach_in = circle(angle=self.angle,radius=self.Rd0,width=self.wd0+err,xs=self.xs).cell.put('a1',0,vtx_lower_y[0]/2+vtx_lower_y[-1]/2,180,flip=0)
                    # attach_in = circle(angle=self.angle,radius=self.Rd0,width=self.wd0+err,xs=self.xs).cell.put('b1',attach_in.pin['b1'],flip=0)
                    pin_a2=nd.taper(width1=self.wd0+err,width2=self.wd_in,length=Ltp,xs=self.xs).put(attach_in.pin['b1']).pin['b0']
                    patch = nd.strt(xs=self.xs,length=0.01,width=pin_a2.width).put()

            else :
                Ltp = np.max([5,np.abs(self.wd0-self.wd_in)/np.tan(self.tp_angle/180*pi)])
                Ltp = int(Ltp*20)*0.05 ## keep it in integer
                temp = nd.strt(xs=self.xs,length=5,width=self.wd0+err).put(0,vtx_lower_y[0]/2+vtx_lower_y[-1]/2,180,flip=0)
                pin_a2 = nd.taper(xs=self.xs,length=Ltp,width1=self.wd0+err,width2=self.wd_in).put(temp.pin['b0']).pin['b0']
                patch = nd.strt(xs=self.xs,length=0.01,width=pin_a2.width).put()

            nd.Pin(name='a2',width=self.wd_in,pin=pin_a2).put()

            if (self.Rd1!=0):
                ## placing the adiabatic bend attachment to lower waveguide, output port, label 1
                if (self.sbend_type=='euler'):
                    attach_in = Clothoid(R=[self.Rd1,self.Rmin,self.Rd1] , w=[self.wd1,self.wd1], A=[0,self.angle/2,self.angle], dL_cal=0.001,dL_wg=self.res,
                                         xs=self.xs,width_type='linear',
                                         sharp_patch=self.sharp_patch,spiral_order=1)                    
                    attach_in.cell.put(self.Ld,vtx_lower_y[1]/2+vtx_lower_y[-2]/2,0,flip=1)
                    pin_b2 = Clothoid(R=[self.Rd1,self.Rmin,self.Rd1] , w=[self.wd1,self.wd_out], A=[self.angle,self.angle/2,0], dL_cal=0.001,dL_wg=self.res,
                                                xs=self.xs,width_type='linear',
                                                sharp_patch=self.sharp_patch,spiral_order=1).cell.put(flip=1).pin['b0']
                else: 
                    Ltp = np.max([0.5,np.abs(self.wd1+err-self.wd_out)/np.tan(self.tp_angle/180*pi)])
                    Ltp = int(Ltp*20)*0.05 ## keep it in integer
                    attach_in = Clothoid(R=[self.Rd1,self.Rd1,self.Rd1] , w=[self.wd1,self.wd1], A=[0,self.angle,0], dL_cal=0.001,dL_wg=self.res,
                        xs=self.xs,width_type='linear',end_patch=False,
                        sharp_patch=self.sharp_patch,spiral_order=1).cell.put(self.Ld,vtx_lower_y[1]/2+vtx_lower_y[-2]/2,0,flip=1)

                    # attach_in = circle(angle=self.angle,radius=self.Rd1,width=self.wd1+err,xs=self.xs).cell.put('a1',self.Ld,vtx_lower_y[1]/2+vtx_lower_y[-2]/2,0,flip=1)
                    # attach_in = circle(angle=self.angle,radius=self.Rd1,width=self.wd1+err,xs=self.xs).cell.put('b1',attach_in.pin['b1'],flip=1)
                    pin_b2=nd.taper(width1=self.wd1+err,width2=self.wd_out,length=Ltp,xs=self.xs).put(attach_in.pin['b1']).pin['b0']        
                    patch = nd.strt(xs=self.xs,length=0.01,width=pin_b2.width).put()
                    
                _dX_ = abs(pin_b2.x - self.Ld)    
            else :
                Ltp = np.abs(self.wd1+err-self.wd_out)/np.tan(self.tp_angle/180*pi)
                Ltp = int(Ltp*20)*0.05 ## keep it in integer
                temp = nd.strt(xs=self.xs,length=5,width=self.wd1+err).put(self.Ld,vtx_lower_y[1]/2+vtx_lower_y[-2]/2,0,flip=0)

                pin_b2 = nd.taper(xs=self.xs,length=Ltp,width1=self.wd1+err,width2=self.wd_out).put().pin['b0']
                patch = nd.strt(xs=self.xs,length=0.01,width=pin_b2.width).put()

            nd.Pin(name='b2',width=self.wd_out,pin=pin_b2).put()


            if (self.Ru0!=0):
                if (self.sbend_type=='euler'):
                    ## placing the adiabatic bend attachment to upper waveguide, input port, label 0
                    attach_in = Clothoid(R=[self.Ru0,self.Rmin,self.Ru0] , w=[self.wu0,self.wu0], A=[0,self.angle/2,self.angle], dL_cal=0.001,dL_wg=self.res,
                                         xs=self.xs,width_type='linear',
                                         sharp_patch=self.sharp_patch,spiral_order=1)
                    attach_in.cell.put(0,vtx_upper_y[0]/2+vtx_upper_y[-1]/2,180,flip=1)
                    pin_a1 = Clothoid(R=[self.Ru0,self.Rmin,self.Ru0] , w=[self.wu0,self.wu_in], A=[self.angle,self.angle/2,0], dL_cal=0.001,dL_wg=self.res, 
                                                xs=self.xs,width_type='linear',
                                                sharp_patch=self.sharp_patch,spiral_order=1).cell.put(flip=1).pin['b0']
                else: 
                    Ltp = np.max([0.5,np.abs(self.wu0+err-self.wu_in)/np.tan(self.tp_angle/180*pi)])
                    Ltp = int(Ltp*20)*0.05 ## keep it in integer
                    attach_in = Clothoid(R=[self.Ru0,self.Ru0,self.Ru0] , w=[self.wu0,self.wu0], A=[0,self.angle,0], dL_cal=0.001,dL_wg=self.res,
                        xs=self.xs,width_type='linear',end_patch=False,
                        sharp_patch=self.sharp_patch,spiral_order=1).cell.put(0,vtx_upper_y[0]/2+vtx_upper_y[-1]/2,180,flip=1)

                    # attach_in = circle(angle=self.angle,radius=self.Ru0,width=self.wu0+err,xs=self.xs).cell.put('a1',0,vtx_upper_y[0]/2+vtx_upper_y[-1]/2,180,flip=1)
                    # attach_in = circle(angle=self.angle,radius=self.Ru0,width=self.wu0+err,xs=self.xs).cell.put('b1',attach_in.pin['b1'],flip=1)

                    pin_a1=nd.taper(width1=self.wu0+err,width2=self.wu_in,length=Ltp,xs=self.xs).put(attach_in.pin['b1']).pin['b0']  
                    patch = nd.strt(xs=self.xs,length=0.01,width=pin_a1.width).put()
                     
                _dX_ = abs(pin_a1.x)    
            
            else :
                Ltp = np.max([-5,np.abs(self.wu0+err-self.wu_in)/np.tan(self.tp_angle/180*pi)])
                Ltp = int(Ltp*20)*0.05 ## keep it in integer
                temp = nd.strt(xs=self.xs,length=5,width=self.wu0+err).put(0,vtx_upper_y[0]/2+vtx_upper_y[-1]/2,180,flip=0)
                pin_a1 = nd.taper(xs=self.xs,length=Ltp,width1=self.wu0+err,width2=self.wu_in).put().pin['b0']
                patch = nd.strt(xs=self.xs,length=0.01,width=pin_a1.width).put()

            nd.Pin(name='a1',width=self.wu_in,pin=pin_a1).put()

            if (self.Ru1!=0):
                if (self.sbend_type=='euler'):
                    ## placing the adiabatic bend attachment to upper waveguide, output port, label 1
                    attach_in = Clothoid(R=[self.Ru1,self.Rmin,self.Ru1] , w=[self.wu1,self.wu1], A=[0,self.angle/2,self.angle], dL_cal=0.001,dL_wg=self.res,
                                         xs=self.xs,width_type='linear',
                                         sharp_patch=self.sharp_patch,spiral_order=1)
                    attach_in.cell.put(self.Lu,vtx_upper_y[1]/2+vtx_upper_y[-2]/2,0,flip=0)
                    pin_b1=Clothoid(R=[self.Ru1,self.Rmin,self.Ru1] , w=[self.wu1,self.wu_in], A=[self.angle,self.angle/2,0], dL_cal=0.001,dL_wg=self.res,
                                                xs=self.xs,width_type='linear',
                                                sharp_patch=self.sharp_patch,spiral_order=1).cell.put(flip=0).pin['b0']
                else: ## circular attachment
                    
                    Ltp = np.max([0.5,np.abs(self.wu1+err-self.wu_out)/np.tan(self.tp_angle/180*pi)])
                    Ltp = int(Ltp*20)*0.05 ## keep it in integer
                    
                    attach_in = Clothoid(R=[self.Ru1,self.Ru1,self.Ru1] , w=[self.wu1,self.wu1], A=[0,self.angle,0], dL_cal=0.001,dL_wg=self.res,
                        xs=self.xs,width_type='linear',end_patch=False,
                        sharp_patch=self.sharp_patch,spiral_order=1).cell.put(self.Lu,vtx_upper_y[1]/2+vtx_upper_y[-2]/2,0,flip=0)
                    
                    # attach_in = circle(angle=self.angle,radius=self.Ru1,width=self.wu1+err,xs=self.xs).cell.put('a1',self.Lu,vtx_upper_y[1]/2+vtx_upper_y[-2]/2,0,flip=0)
                    # attach_in = circle(angle=self.angle,radius=self.Ru1,width=self.wu1+err,xs=self.xs).cell.put('b1',attach_in.pin['b1'],flip=0)
                    pin_b1=nd.taper(width1=self.wu1+err,width2=self.wu_out,length=Ltp,xs=self.xs).put(attach_in.pin['b1']).pin['b0']  
                    patch = nd.strt(xs=self.xs,length=0.01,width=pin_b1.width).put()
            else :
                Ltp = np.max([5,np.abs(self.wu1+err-self.wu_out)/np.tan(self.tp_angle/180*pi)])
                Ltp = int(Ltp*20)*0.05 ## keep it in integer
                temp = nd.strt(xs=self.xs,length=5,width=self.wu1+err).put(self.Lu,vtx_upper_y[1]/2+vtx_upper_y[-2]/2,0,flip=0)
                pin_b1 = nd.taper(xs=self.xs,length=Ltp,width1=self.wu1+err,width2=self.wu_out).put().pin['b0']
                patch = nd.strt(xs=self.xs,length=0.01,width=pin_b1.width).put()

            nd.Pin(name='b1',width=self.wu_out,pin=pin_b1).put()

            dY1 = np.abs(pin_a1.y-pin_a2.y)
            dX1 = np.abs(pin_a1.x-pin_a2.x)
            dY2 = np.abs(pin_b1.y-pin_b2.y)
            dX2 = np.abs(pin_b1.x-pin_b2.x)

            # if (self.sharp_patch==True):
            #     for layers,growx,growy,acc in nd.layeriter(xs=self.xs):
            #         (a1,b1), (a2,b2),c1,c2 = growx
            #         if (b1!=0 and b2!=0):
            #             L_patch = (dX1+5)*(a1-a2)+(b1-b2)
            #             W_patch = (dY1+self.wu_in/2+self.wd_in/2)*(a1-a2)+(b1-b2)
            #             nd.strt(length=L_patch,width=W_patch,layer=layers).put(np.max([pin_a1.x,pin_a2.x]),(pin_a1.y+self.wu_in/2-self.wd_in/2+pin_a2.y)/2,180)


            #             L_patch = (dX2+5)*(a1-a2)+(b1-b2)
            #             W_patch = (dY2+self.wu_out/2+self.wd_out/2)*(a1-a2)+(b1-b2)
            #             nd.strt(length=L_patch,width=W_patch,layer=layers).put(np.min([pin_b1.x,pin_b2.x]),(pin_b1.y+self.wu_out/2-self.wd_out/2+pin_b2.y)/2,0)

            if show_pins:
                nd.put_stub(pinname='a1',pinsize=3)
                nd.put_stub(pinname='a2',pinsize=3)
                nd.put_stub(pinname='b1',pinsize=3)
                nd.put_stub(pinname='b2',pinsize=3)

        return C

    def generate_err(self,err=0.02):
        self.err = err
        self.cell = self.generate_gds(err=err)
        return self
    
    def generate_test_gds(self,gc,dX_gc2gc=400,dY_gc2gc=80,sharp_patch=True):
        with nd.Cell(instantiate=False) as C:
            if (isinstance(gc,nd.Cell)):
                gc_cell =gc
            elif (hasattr(gc,'cell')):
                gc_cell = gc.cell
            else :
                raise Exception("ERROR: In <mxpic::passive::ADC_STD_2x2::generate_test_gds>, <gc> is not recongized as a cell")
            
            inst = self.cell.put('a1',-self.L/2,self.cell.pin['a1'].y,0)
            pic_strip = Route(radius=15,width=self.wu_in,xs=self.xs)
            
            GT_U_In = gc_cell.put('g1',-dX_gc2gc/2,dY_gc2gc/2,180)
            nd.taper(width1=GT_U_In.pin['g1'].width,width2=self.wu_in,length=5,xs=self.xs).put(GT_U_In.pin['g1'])
            pic_strip.sbend_p2p(original_function=not sharp_patch,pin2=inst.pin['a1']).put()

            GT_D_In = gc_cell.put('g1',-dX_gc2gc/2,-dY_gc2gc/2,180)
            nd.taper(width1=GT_D_In.pin['g1'].width,width2=self.wd_in,length=5,xs=self.xs).put(GT_D_In.pin['g1'])
            pic_strip.sbend_p2p(original_function=not sharp_patch,pin2=inst.pin['a2'],width=self.wd_in).put()

            GT_U_Out = gc_cell.put('g1', dX_gc2gc/2,dY_gc2gc/2,0)
            nd.taper(width1=GT_U_Out.pin['g1'].width,width2=self.wu_out,length=5,xs=self.xs).put(GT_U_Out.pin['g1'])
            pic_strip.sbend_p2p(original_function=not sharp_patch,pin2=inst.pin['b1'],width=self.wu_out).put()

            GT_D_Out = gc_cell.put('g1', dX_gc2gc/2,-dY_gc2gc/2,0)
            nd.taper(width1=GT_D_Out.pin['g1'].width,width2=self.wd_out,length=5,xs=self.xs).put(GT_D_Out.pin['g1'])
            pic_strip.sbend_p2p(original_function=not sharp_patch,pin2=inst.pin['b2'],width=self.wd_out).put()
            
        return C


class DC(ADC_STD_2x2):
    """
        Standard symmetric directional coupler wrapper built on ``ADC_STD_2x2``.

        Parameters
        ----------
        name : str, optional
            Unique cell identifier (default is None, meaning no instantiation).
        xs : str, optional
            Nazca cross-section key for both guides (default is "strip").
        w_cp : float, optional
            Coupling-section core width in microns (default is 0.45).
        w_wg : float, optional
            IO port width in microns (default is 0.45).
        L_cp : float, optional
            Coupling-section length in microns (default is 30).
        angle : float, optional
            Port bend deflection angle in degrees (default is 20).
        gap : float, optional
            Gap between the two cores in microns (default is 0.2).
        sbend_type : str, optional
            Type of the IO bend ("euler" or "circular", default is "circular").
        Rmax : float, optional
            Maximum Euler radius in microns when "sbend_type" is "euler" (default is None).
        Rmin : int, optional
            Minimum Euler radius in microns (default is 5).
        R0 : int, optional
            Circular bend radius in microns applied to both ports (default is 10).
        tp_angle : int, optional
            Straight taper half-angle in degrees when Euler bends are disabled (default is 2).
        sharp_patch : bool, optional
            Insert chamfer polygons to avoid acute corners (default is True).
        show_pins : bool, optional
            Draw Nazca stub markers for debugging (default is False).
    """
    def __init__(self,
                 name = None,
                xs:str='strip', 
                w_cp:float=0.45, 
                w_wg:float=0.45, 
                L_cp:float=30, 
                angle:float=20, 
                gap:float=0.2,
                sbend_type:str='circular', 
                Rmax:float=None, 
                Rmin:float=5, 
                R0:float=10,  
                tp_angle:float=2, 
                sharp_patch:bool=True,
                show_pins:bool=False):
     
        super().__init__(name, xs, wu0=w_cp, wu1=w_cp, 
        wu_in=w_wg, wu_out=w_wg, 
        wd0=w_cp, wd1=w_cp, 
        wd_in=w_wg, wd_out=w_wg, 
        Lu=L_cp, Ld=L_cp, angle=angle,
        g0=gap, g1=gap, 
        sbend_type=sbend_type, Rmax=Rmax, Rmin=Rmin, 
        Ru0=R0, Ru1=R0, Rd0=R0, Rd1=R0, tp_angle=tp_angle, sharp_patch=sharp_patch,show_pins=show_pins)

    def generate_test_gds(self,gc,dX_gc2gc=300,dY_gc2gc=40,sharp_patch=True):
        with nd.Cell(name=self.cell.cell_name+"_test", instantiate=False) as C:
            
            gc_cell = __cell_arg__(arg=gc,arg_name="gc",func_name="mxpic::DC::generate_test_gds")
            
            gc_ID = gc_cell.put('g1',0,-dY_gc2gc,180)
            gc_IU = gc_cell.put('g1',0,0,180)
            gc_OU = gc_cell.put('g1',dX_gc2gc,-dY_gc2gc,0)
            gc_OD = gc_cell.put('g1',dX_gc2gc,0,0)
            # Put DC
            inst = self.cell.put('a1',-self.L/2+dX_gc2gc/2,self.cell.pin['a1'].y-dY_gc2gc/2,0)

            # Connect all the ports 
            stripe=Route(radius=self.Ru0, width=self.wu_in, xs="strip") 
            
            if (abs(inst.pin['b1'].y - inst.pin['b2'].y)<10) :
                temp = stripe.sbend_route(pin=inst.pin['a1'],offset=5).put(flip=1)
                stripe.sbend_p2p(pin1=gc_IU.pin['g1'],pin2=temp.pin['b0'],arrow=False,original_function=not sharp_patch).put() 
                
                temp = stripe.sbend_route(pin=inst.pin['a2'],offset=5).put()
                stripe.sbend_p2p(pin1=gc_ID.pin['g1'],pin2=temp.pin['b0'],arrow=False,original_function=not sharp_patch).put()

                temp = stripe.sbend_route(pin=inst.pin['b1'],offset=5).put()
                stripe.sbend_p2p(pin1=gc_OD.pin['g1'],pin2=temp.pin['b0'],arrow=False,original_function=not sharp_patch).put()

                temp = stripe.sbend_route(pin=inst.pin['b2'],offset=5).put(flip=1)
                stripe.sbend_p2p(pin1=gc_OU.pin['g1'],pin2=temp.pin['b0'],arrow=False,original_function=not sharp_patch).put() 
            else :               
                stripe.sbend_p2p(pin1=gc_IU.pin['g1'],pin2=inst.pin['a1'],arrow=False,original_function=not sharp_patch).put() 
                stripe.sbend_p2p(pin1=gc_ID.pin['g1'],pin2=inst.pin['a2'],arrow=False,original_function=not sharp_patch).put()
                stripe.sbend_p2p(pin1=gc_OD.pin['g1'],pin2=inst.pin['b1'],arrow=False,original_function=not sharp_patch).put()
                stripe.sbend_p2p(pin1=gc_OU.pin['g1'],pin2=inst.pin['b2'],arrow=False,original_function=not sharp_patch).put() 
        return C            
    
class BS_tdc(ADC_STD_2x2):
    """
        Balanced splitter based on asymmetric taper-directional-coupler sections.

        Parameters
        ----------
        name : str, optional
            Nazca cell name (default is None).
        xs : str, optional
            Nazca cross-section for both guides (default is "strip").
        wa0 : float, optional
            Upper input width in microns (default is 0.35).
        wa1 : float, optional
            Upper output width in microns (default is 0.45).
        wb0 : float, optional
            Lower input width in microns (default is 0.55).
        wb1 : float, optional
            Lower output width in microns (default is 0.45).
        w_wg : float, optional
            External IO width in microns (default is 0.45).
        gap : float, optional
            Coupling gap in microns (default is 0.2).
        Lt : float, optional
            Coupling/taper length in microns (default is 20).
        R0 : float, optional
            Port bend radius in microns (default is 30).
        angle : float, optional
            Port bend angle in degrees (default is 15).
        sbend_type : str, optional
            IO bend type ("circle" or "euler", default is "circle").
    """
    def __init__(self,
                 name=None,
                xs:str ='strip',
                wa0:float = 0.35,
                wa1:float  = 0.45,
                wb0:float  = 0.55,
                wb1:float  = 0.45,
                w_wg:float  = 0.45,
                gap:float =0.2,
                Lt:float =20,
                R0:float =30,
                angle:float =15,
                sbend_type:str ='circle',
                ):
   
        super().__init__(name = name,
                         xs=xs,
                        wu0=wa0,wu1=wa1,wu_in=w_wg,wu_out=w_wg,
                        wd0=wb0,wd1=wb1,wd_in=w_wg,wd_out=w_wg,
                        g0=gap,g1=gap,
                        Ru0=R0,Ru1=R0,Rmin=5,
                        Rd0=R0,Rd1=R0,angle=angle,
                        Ld=Lt,Lu=Lt,
                        sbend_type=sbend_type)                          


class MDM(ADC_STD_2x2):
    """
        Mode-division-multiplexing directional coupler derived from ``ADC_STD_2x2``.

        Parameters
        ----------
        name : str, optional
            Nazca cell name (default is None).
        xs : str, optional
            Device cross-section key (default is "strip").
        wb0 : float, optional
            BUS waveguide width at the input plane in microns (default is 0.45).
        wb1 : float, optional
            BUS waveguide width at the output plane in microns (default is 0.61).
        wb_in : float, optional
            BUS input port width in microns (default is 0.45).
        wb_out : float, optional
            BUS output port width in microns (default is 0.88).
        w_wg : float, optional
            Coupler-waveguide IO width in microns (default is 0.45).
        w0 : float, optional
            Coupler waveguide width at the input plane in microns (default is 0.33).
        w1 : float, optional
            Coupler waveguide width at the output plane in microns (default is 0.2).
        gap0 : float, optional
            Initial BUS–coupler gap in microns (default is 0.2).
        Lt_bus : float, optional
            BUS taper length from wb0 to wb1 in microns (default is 20).
        R0 : float, optional
            Lower-waveguide bend radius in microns (default is 40).
        angle : float, optional
            Bend deflection angle in degrees (default is 22.5).
        Lt_cp : float, optional
            Coupler taper length from w0 to w1 in microns (default is None, meaning ``Lt_bus``).
        gap1 : float, optional
            Final BUS–coupler gap in microns (default is None, meaning ``gap0``).
        Lb0 : float, optional
            Reserved for future BUS offsets (default is None).
        symmetric_BUS : bool, optional
            Whether BUS geometry is mirrored (default is True).
        single_end : bool, optional
            Keep single-ended termination on the coupler arm (default is True).
        Rmin : float, optional
            Minimum Euler radius in microns for bends (default is 8).
    """
    def __init__(self,
                 name = None,
                xs:str='strip',
                wb0:float =0.45,
                wb1:float =0.61,
                wb_in:float =0.45,
                wb_out:float =0.88,
                w_wg:float =0.45,
                w0:float =0.33,
                w1:float =0.2,
                gap0:float =0.2,
                Lt_bus:float =20,
                R0:float =40,
                angle:float =22.5,
                Lt_cp:float =None,
                gap1:float =None,
                Lb0:float =None,
                symmetric_BUS:bool =True,
                single_end:bool =True,
                Rmin:float =8
                ):

        self.wb0=wb0 ## BUS waveguide width on the input

        if (wb1!=None):  ## BUS waveguide width on the output
            self.wb1=wb1
        else:
            self.wb1=wb0   
            wb1 = wb0         
        self.w0=w0
        if (w1!=None):
            self.w1=w1
        else:
            self.w1=w0 
            w1= w0       
        self.w_wg=w_wg
        self.gap0=gap0
        if (gap1!=None):
            self.gap1=gap1
        else:
            self.gap1=gap0
            gap1 = gap0

        if (Lt_cp==None):
            Lt_cp = Lt_bus

        self.Lt_bus = Lt_bus
        self.Lt_cp = Lt_cp
    
        self.xs = xs
        self.Lt_cp = Lt_cp
        self.R0 = R0
        self.angle = angle
        self.symmetric_BUS = symmetric_BUS ## defining the type of bus waveguide
        self.Rmin = Rmin
        super().__init__(name = name,xs=xs,
                        wu0=wb0,wu1=wb1,wu_in=wb_in,wu_out=wb_out,
                        wd0=w0,wd1=w1,wd_in=w_wg,wd_out=w1,
                        Lu=Lt_bus,Ld=Lt_cp,
                        g0=gap0,g1=gap1,
                        Ru0=0,Ru1=0,
                        Rmin=self.Rmin,
                        Rd0=R0,Rd1=R0,
                        angle=angle)   
                           
        self.L = np.abs(self.cell.pin['a1'].x-self.cell.pin['b1'].x)

    def generate_test_gds(self,gc,dX_gc2gc=300,dY_gc2gc=40,sharp_patch=True):
        with nd.Cell(name=self.cell.cell_name+"_test", instantiate=False) as C:

            gc_cell = __cell_arg__(arg=gc,arg_name="gc",func_name="mxpic::MDM::generate_test_gds")

            # Put DC
            L_taper = (np.abs(self.cell.pin['a1'].width-gc_cell.pin['g1'].width))/np.tan(2/180*pi)

            mdm_In = self.cell.put('b1',-dX_gc2gc/2 + self.L + 25+L_taper,0,180)
            mdm_Out = self.cell.put('b1', dX_gc2gc/2 - self.L - 25-L_taper,0,0,flip=1)


            GC_IU = gc_cell.put('g1',-dX_gc2gc/2,dY_gc2gc/2,180)
            GC_ID = gc_cell.put('g1',-dX_gc2gc/2,-dY_gc2gc/2,180)
            GC_OU = gc_cell.put('g1', dX_gc2gc/2,dY_gc2gc/2,0)
            GC_OD = gc_cell.put('g1', dX_gc2gc/2,-dY_gc2gc/2,0)

            # # Connect all the ports 
            stripe=Route(radius=10, width=self.w_wg, xs="strip") 
            nd.taper(width1=mdm_In.pin['a1'].width,width2=gc_cell.pin['g1'].width,length=L_taper,xs='strip').put(mdm_In.pin['a1'])
            stripe.sbend_p2p(pin2=GC_IU.pin['g1'],arrow=False,original_function=not sharp_patch).put() 

            stripe.sbend_p2p(pin1=GC_ID.pin['g1'],pin2=mdm_In.pin['a2'],arrow=False,original_function=not sharp_patch).put()

            nd.taper(width1=mdm_Out.pin['a1'].width,width2=gc_cell.pin['g1'].width,length=L_taper,xs='strip').put(mdm_Out.pin['a1'])
            stripe.sbend_p2p(pin1=GC_OU.pin['g1'],arrow=False,original_function=not sharp_patch).put()
            stripe.sbend_p2p(pin1=GC_OD.pin['g1'],pin2=mdm_Out.pin['a2'],arrow=False,original_function=not sharp_patch).put() 

            stripe.taper_p2p(pin1=mdm_In.pin['b1'],pin2=mdm_Out.pin['b1'],arrow=False).put()

        return C        




class DC_bend :
    '''
    This is a class for bend directional coupler for broadband and fabrication tolerant power splitting. 
    Written by HU GAOLEI at 2022.5.15. 
    '''

    """
        Bend-based directional coupler for broadband, fabrication-tolerant splitting.

        Parameters
        ----------
        name : str, optional
            Nazca cell name (default is None).
        w_in : float, optional
            Inner (tight) waveguide width in the coupling region, in microns (default is 0.45).
        w_out : float, optional
            Outer waveguide width in the coupling region, in microns (default is 0.45).
        gap : float, optional
            Separation between waveguides in microns (default is 0.2).
        r_in : float, optional
            Bend radius of the inner waveguide in microns (default is 40).
        theta_arc : float, optional
            Coupling-arc angle in degrees (default is 30).
        w_wg : float, optional
            IO waveguide width in microns (default is 0.45).
        theta_ext : float, optional
            Extra bend angle used to align IO planes in degrees (default is 15).
        xs_wg : str, optional
            Nazca cross-section for both waveguides (default is "strip").
        sharp_patch : bool, optional
            Insert chamfer polygons to smooth acute corners (default is True).
        show_pins : bool, optional
            Draw Nazca stub markers for debugging (default is False).
    """
    

    def __init__(
        self, 
        name = None,
        w_in=0.45, 
        w_out=0.45, 
        gap=0.2, 
        r_in=40, 
        theta_arc=30, 
        w_wg=0.45, 
        theta_ext=15, 
        xs_wg='strip', 

        sharp_patch=True, 
        show_pins=False
    ):

        self.name = name
        if (self.name==None):
            self.instantiate = False
        else :
            self.instantiate = True
                
        self.w_in = w_in 
        self.w_out = w_out
        self.gap = gap
        self.r_in = r_in
        self.r_out = self.r_in+(self.w_in+self.w_out)/2+self.gap
        self.theta_arc = theta_arc
        self.theta_ext = theta_ext
        self.w_wg = w_wg
        self.xs_wg = xs_wg
        self.sharp_patch = sharp_patch
        self.show_pins = show_pins
        self.cell = self.generate_gds(name)

    def generate_gds(self, cellname=""):
        '''
        Generate GDS.
        '''
        with nd.Cell(name="DC_Bend"+str(cellname), instantiate=self.instantiate) as C:
            wg = Route(width=self.w_wg, radius=10, xs=self.xs_wg)
            ## Put Outer Bend Region first 
            
            bent_out_coup_r = wg.bend(width=self.w_out, radius=self.r_out, angle=self.theta_arc/2, arrow=False).put(0, 0, 0)
            bend_out_connect_r = wg.bend(width=self.w_out, radius=self.r_out, angle=-self.theta_arc/2, arrow=False).put(bent_out_coup_r.pin['b0'])

            bent_out_coup_l = wg.bend(width=self.w_out, radius=self.r_out, angle=self.theta_arc/2, arrow=False).put(0, 0, 0, flop=True)
            bend_out_connect_l = wg.bend(width=self.w_out, radius=self.r_out, angle=self.theta_arc/2, arrow=False).put(bent_out_coup_l.pin['b0'])
            ##  Put Inner Bend Region 
            bent_in_coup_r = wg.bend(width=self.w_in, radius=self.r_in, angle=self.theta_arc/2, arrow=False).put(0, (self.w_in+self.w_out)/2+self.gap, 0)
            wg.bend(width=self.w_in, radius=self.r_in, angle=self.theta_ext, arrow=False).put(bent_in_coup_r.pin['b0'])
            bend_in_connect_r = wg.bend(width=self.w_in, angle=-self.theta_arc/2-self.theta_ext, arrow=False).put()

            bend_in_coup_l = wg.bend(width=self.w_in, radius=self.r_in, angle=self.theta_arc/2, arrow=False).put(0, (self.w_in+self.w_out)/2+self.gap, 0, flop=True)
            wg.bend(width=self.w_in, radius=self.r_in, angle=-self.theta_ext, arrow=False).put(bend_in_coup_l.pin['b0'])
            bend_in_connect_l = wg.bend(width=self.w_in, angle=self.theta_arc/2+self.theta_ext, arrow=False).put()

            ## Make upper and lower waveguide's output at the same x-plane 
            if bend_out_connect_r.pin['b0'].x > bend_in_connect_r.pin['b0'].x:
                l_extra = bend_out_connect_r.pin['b0'].x-bend_in_connect_r.pin['b0'].x
                bend_in_connect_r = wg.strt(length=l_extra, width=self.w_in, arrow=False).put(bend_in_connect_r.pin['b0'])
                bend_in_connect_l = wg.strt(length=l_extra, width=self.w_in, arrow=False).put(bend_in_connect_l.pin['b0'])
            elif bend_out_connect_r.pin['b0'].x < bend_in_connect_r.pin['b0'].x:
                l_extra = bend_in_connect_r.pin['b0'].x-bend_out_connect_r.pin['b0'].x
                bend_out_connect_r = wg.strt(length=l_extra, width=self.w_out, arrow=False).put(bend_out_connect_r.pin['b0'])
                bend_out_connect_l = wg.strt(length=l_extra, width=self.w_out, arrow=False).put(bend_out_connect_l.pin['b0'])
            
            ## Add taper to make the width in the coupling region connect with normal wg
            l_taper = 2
            port_out1 = wg.taper(width1=self.w_in, width2=self.w_wg, length=l_taper, arrow=False).put(bend_in_connect_r.pin['b0'])
            port_in1 = wg.taper(width1=self.w_in, width2=self.w_wg, length=l_taper, arrow=False).put(bend_in_connect_l.pin['b0'])
            port_out2 = wg.taper(width1=self.w_out, width2=self.w_wg, length=l_taper, arrow=False).put(bend_out_connect_r.pin['b0'])
            port_in2 = wg.taper(width1=self.w_out, width2=self.w_wg, length=l_taper, arrow=False).put(bend_out_connect_l.pin['b0'])

            ## Put pins
            nd.Pin(name="a0", width=self.w_wg).put((port_in1.pin['b0'].x+port_in2.pin['b0'].x)/2, (port_in1.pin['b0'].y+port_in2.pin['b0'].y)/2, 180)
            nd.Pin(name="a1", width=self.w_wg).put(port_in1.pin['b0'])
            nd.Pin(name="a2", width=self.w_wg).put(port_in2.pin['b0'])
            nd.Pin(name="b1", width=self.w_wg).put(port_out1.pin['b0'])
            nd.Pin(name="b2", width=self.w_wg).put(port_out2.pin['b0'])
            self.width = np.abs(port_out1.pin['b0'].y - port_out2.pin['b0'].y)
            self.length = np.abs(port_out1.pin['b0'].x - port_in1.pin['b0'].x) 
            if self.show_pins:
                nd.put_stub()
            
            pin_a1 = port_in1.pin['b0']
            pin_a2 = port_in2.pin['b0']
            pin_b1 = port_out1.pin['b0']
            pin_b2 = port_out2.pin['b0']
            dY1 = np.abs(pin_a1.y-pin_a2.y)
            dX1 = np.abs(pin_a1.x-pin_a2.x)
            dY2 = np.abs(pin_b1.y-pin_b2.y)
            dX2 = np.abs(pin_b1.x-pin_b2.x)

            if (self.sharp_patch==True):
                for layers,growx,growy,acc in nd.layeriter(xs=self.xs_wg):
                    (a1,b1), (a2,b2),c1,c2 = growx
                    if (b1!=0 and b2!=0):
                        L_patch = (dX1+5)*(a1-a2)+(b1-b2)
                        W_patch = (dY1+self.w_wg)*(a1-a2)+(b1-b2)
                        nd.strt(length=L_patch,width=W_patch,layer=layers).put(np.max([pin_a1.x,pin_a2.x]),(pin_a1.y+pin_a2.y)/2,180)


                        L_patch = (dX2+5)*(a1-a2)+(b1-b2)
                        W_patch = (dY2+self.w_wg)*(a1-a2)+(b1-b2)
                        nd.strt(length=L_patch,width=W_patch,layer=layers).put(np.min([pin_b1.x,pin_b2.x]),(pin_b1.y+pin_b2.y)/2,0)
        return C

    def generate_test_gds(self,gc,dX_gc2gc=300,dY_gc2gc=40,sharp_patch=True):
        with nd.Cell(name=self.cell.cell_name+"_test", instantiate=False) as C:
            
            gc_cell = __cell_arg__(arg=gc,arg_name="gc",func_name="mxpic::DC_bend::generate_test_gds")

            # gc_ID = gc_cell.put('g1',-dX_gc2gc/2,-dY_gc2gc/2,180)
            # gc_IU = gc_cell.put('g1',-dX_gc2gc/2,dY_gc2gc/2,180)
            # gc_OU = gc_cell.put('g1',dX_gc2gc/2,-dY_gc2gc/2,0)
            # gc_OD = gc_cell.put('g1',dX_gc2gc/2,dY_gc2gc/2,0)
            # # Put DC
            # dc = self.cell.put('a1',-self.length/2,0,0)
            
            gc_ID = gc_cell.put('g1',0,-dY_gc2gc,180)
            gc_IU = gc_cell.put('g1',0,0,180)
            gc_OU = gc_cell.put('g1',dX_gc2gc,-dY_gc2gc,0)
            gc_OD = gc_cell.put('g1',dX_gc2gc,0,0)
            # Put DC
            dL_DC = self.cell.pin['b1'].x - self.cell.pin['a1'].x
            inst = self.cell.put('a1',-dL_DC/2+dX_gc2gc/2,self.cell.pin['a1'].y-dY_gc2gc/2,0)

            # Connect all the ports 
            stripe=Route(radius=10, width=self.w_wg, xs="strip") 
            stripe.sbend_p2p(pin1=gc_IU.pin['g1'],pin2=inst.pin['a1'],arrow=False,original_function=not sharp_patch).put() 
            stripe.sbend_p2p(pin1=gc_ID.pin['g1'],pin2=inst.pin['a2'],arrow=False,original_function=not sharp_patch).put()
            stripe.sbend_p2p(pin1=gc_OD.pin['g1'],pin2=inst.pin['b1'],arrow=False,original_function=not sharp_patch).put()
            stripe.sbend_p2p(pin1=gc_OU.pin['g1'],pin2=inst.pin['b2'],arrow=False,original_function=not sharp_patch).put() 
        return C


class DC_pX_3sg:
    """
        Three-segment phase-tunable directional coupler (pX) generator.

        Parameters
        ----------
        name : str, optional
            Nazca cell name (default is None).
        xs_wg : str, optional
            Cross-section key for all segments (default is "strip").
        Lc1 : float, optional
            Length of the first coupling segment in microns (default is 10).
        Lp1 : float, optional
            Phase-shifter length in microns (default is 5).
        Lc2 : float, optional
            Length of the second coupling segment in microns (default is 10).
        Lt : float, optional
            Taper length between coupling and phase sections in microns (default is 1).
        w_cp : float, optional
            Nominal coupling width in microns (default is 0.5).
        dw : float, optional
            Width offset applied to the phase section in microns (default is 0.1).
        gap : float, optional
            Vertical spacing between the two cores in microns (default is 0.2).
        R0 : float, optional
            Bend radius in microns for port transitions (default is 10).
        A : float, optional
            Bend angle in degrees for port transitions (default is 15).
        w_wg : float, optional
            External IO width in microns (default is 0.45).
        pX_type : str, optional
            Phase-section topology ("symmetric" or "asymmetric", default is "symmetric").
        port_symmetric : bool, optional
            Use mirrored port routing for both arms (default is True).
        sharp_patch : bool, optional
            Insert chamfer polygons to mitigate sharp tips (default is True).
    """
    
    def __init__(self,
            name = None,
            xs_wg:str='strip',
            Lc1:float=10,
            Lp1:float=5,
            Lc2:float=10,
            Lt:float=1,
            w_cp:float=0.5,
            dw:float=0.1,
            gap:float=0.2,
            R0:float=10,
            A:float=15,
            w_wg:float=0.45,
            pX_type:str="symmetric",
            port_symmetric:bool=True,
            sharp_patch:bool=True):
        
        self.name = name
        if (self.name==None):
            self.instantiate = False
        else :
            self.instantiate = True     
               
        self.xs_wg=xs_wg
        self.Lc1=Lc1
        self.Lp1=Lp1
        self.Lc2=Lc2
        self.Lt=Lt
        self.w_cp=w_cp
        self.dw=dw
        self.gap=gap
        self.R0=R0
        self.A=A
        self.w_wg=w_wg
        self.sharp_patch=sharp_patch
        self.pX_type=pX_type
        self.port_symmetric=port_symmetric
        cells = self.generate_gds(err=0)
        self.cell = cells[0]
        self.cellU = cells[2]
        self.cellD = cells[1]
        
        self.L = np.abs(self.cell.pin['a1'].x - self.cell.pin['b1'].x)
        self.length = self.L

    def generate_gds(self,err=0):
        if (self.name is not None):
            nameUP = self.name + "_up"
            nameDOWN = self.name + "_down"
        else:
            nameUP = None
            nameDOWN = None
            
        w_cp = self.w_cp + err
        gap = self.gap - err   
             
        with nd.Cell(instantiate=False) as CUP:

            ## first segment coupler
            cp_u = nd.strt(length=self.Lc1,width=w_cp,xs=self.xs_wg).put(0,  w_cp/2+gap/2,0)
            nd.Pin(name='a0').put(cp_u.pin['a0'])

            cp_u_r = nd.bend(radius=self.R0,angle=self.A,xs=self.xs_wg,width=w_cp).put(cp_u.pin['a0'],flip=1)
            cp_u_r = nd.bend(radius=self.R0,angle=self.A,xs=self.xs_wg,width=w_cp).put(flip=0)
            cp_u_r = nd.taper(width1=w_cp,width2=self.w_wg,xs=self.xs_wg,length=2).put()
                            
            nd.Pin(name='a1',pin=cp_u_r.pin['b0'],width=cp_u_r.pin['b0'].width).put()

            ## middle segment phase shifter
            if self.pX_type == "symmetric":
                cp_u = nd.taper(length=self.Lt,width1=self.w_cp,width2=self.w_cp+self.dw,shift=0,xs=self.xs_wg).put(cp_u.pin['b0'])
                cp_u = nd.strt(length=self.Lp1,width=w_cp+self.dw,xs=self.xs_wg).put()
                cp_u = nd.taper(length=self.Lt,width1=self.w_cp+self.dw,width2=self.w_cp,shift=0,xs=self.xs_wg).put()

            else:
                cp_u = nd.taper(length=self.Lt,width1=self.w_cp,width2=self.w_cp+self.dw,shift=self.dw/2,xs=self.xs_wg).put(cp_u.pin['b0'])
                cp_u = nd.strt(length=self.Lp1,width=w_cp+self.dw,xs=self.xs_wg).put()
                cp_u = nd.taper(length=self.Lt,width1=self.w_cp+self.dw,width2=self.w_cp,shift=-self.dw/2,xs=self.xs_wg).put()  
            ## second segment coupler
            cp_u = nd.strt(length=self.Lc2,width=w_cp,xs=self.xs_wg).put(cp_u.pin['b0'])

            cp_u_r = nd.bend(radius=self.R0,angle=self.A,xs=self.xs_wg,width=w_cp).put(cp_u.pin['b0'])
            cp_u_r = nd.bend(radius=self.R0,angle=self.A,xs=self.xs_wg,width=w_cp).put(flip=1)
            cp_u_r = nd.taper(width1=w_cp,width2=self.w_wg,xs=self.xs_wg,length=2).put()      
                      
            nd.Pin(name='b1',pin=cp_u_r.pin['b0'],width=cp_u_r.pin['b0'].width).put()

            nd.Pin(name='b0').put(cp_u.pin['b0'])
        
            
        with nd.Cell(instantiate=False) as CDOWN:            
            ## first segment coupler
            cp_d = nd.strt(length=self.Lc1,width=w_cp,xs=self.xs_wg).put(0,-(w_cp/2+gap/2),0)
            nd.Pin(name='a0').put(cp_d.pin['a0'])

            cp_d_r = nd.bend(radius=self.R0,angle=self.A,xs=self.xs_wg,width=w_cp).put(cp_d.pin['a0'],flip=0)
            
            if (self.port_symmetric):
                cp_d_r = nd.bend(radius=self.R0,angle=self.A,xs=self.xs_wg,width=w_cp).put(flip=1)
                cp_d_r = nd.taper(width1=w_cp,width2=self.w_wg,xs=self.xs_wg,length=2).put()
            else:
                cp_d_r = nd.bend(radius=self.R0,angle=self.A,xs=self.xs_wg,width=w_cp).put()
                # cp_d_r = nd.taper(width1=w_cp,width2=self.w_wg,xs=self.xs_wg,length=2).put()
                
            nd.Pin(name='a2',pin=cp_d_r.pin['b0'],width=cp_d_r.pin['b0'].width).put()

            ## middle segment phase shifter
            if self.pX_type == "symmetric":

                cp_d = nd.taper(length=self.Lt,width1=self.w_cp,width2=self.w_cp-self.dw,shift=0,xs=self.xs_wg).put(cp_d.pin['b0'])
                cp_d = nd.strt(length=self.Lp1,width=w_cp-self.dw,xs=self.xs_wg).put()               
                cp_d = nd.taper(length=self.Lt,width1=self.w_cp-self.dw,width2=self.w_cp,shift=0,xs=self.xs_wg).put()

            else:
                cp_d = nd.taper(length=self.Lt,width1=self.w_cp,width2=self.w_cp-self.dw,shift=-self.dw/2,xs=self.xs_wg).put(cp_d.pin['b0'])
                cp_d = nd.strt(length=self.Lp1,width=w_cp-self.dw,xs=self.xs_wg).put()
                cp_d = nd.taper(length=self.Lt,width1=self.w_cp-self.dw,width2=self.w_cp,shift=self.dw/2,xs=self.xs_wg).put()
                
            ## second segment coupler
            cp_d = nd.strt(length=self.Lc2,width=w_cp,xs=self.xs_wg).put(cp_d.pin['b0'])

            cp_d_r = nd.bend(radius=self.R0,angle=self.A,xs=self.xs_wg,width=w_cp).put(cp_d.pin['b0'],flip=1)
            if (self.port_symmetric):
                cp_d_r = nd.bend(radius=self.R0,angle=self.A,xs=self.xs_wg,width=w_cp).put(flip=0)
                cp_d_r = nd.taper(width1=w_cp,width2=self.w_wg,xs=self.xs_wg,length=2).put()
            else:
                cp_d_r = nd.bend(radius=self.R0,angle=self.A,xs=self.xs_wg,width=w_cp).put(flip=1)
                
            nd.Pin(name='b2',pin=cp_d_r.pin['b0'],width=cp_d_r.pin['b0'].width).put()
            nd.Pin(name='b0').put(cp_d.pin['b0'])


        with nd.Cell(instantiate=self.instantiate,name=self.name) as C:
            wgUp = CUP.put(0,(w_cp/2+gap/2),0)
            wgDown = CDOWN.put(0,-(w_cp/2+gap/2),0)
            
            wgUp.raise_pins(['a1','b1'],['a1','b1'])
            wgDown.raise_pins(['a2','b2'],['a2','b2'])
            nd.Pin(name='a0').put((self.Lc1+self.Lc2+self.Lp1+self.Lt*2)/2,0,180)
            nd.Pin(name='b0').put((self.Lc1+self.Lc2+self.Lp1+self.Lt*2)/2,0,0)

        return (C,CDOWN,CUP)

    def generate_test_gds(self,gc,dX_gc2gc=300,dY_gc2gc=40,sharp_patch=True):
        with nd.Cell(name=self.cell.cell_name+"_test", instantiate=False) as C:
            
            gc_cell = __cell_arg__(arg=gc,arg_name="gc",func_name="mxpic::DC_pX_3sg::generate_test_gds")

            # Put DC

            # GC_IU = gc_cell.put('g1',-dX_gc2gc/2,dY_gc2gc/2,180)
            # GC_ID = gc_cell.put('g1',-dX_gc2gc/2,-dY_gc2gc/2,180)
            # GC_OU = gc_cell.put('g1', dX_gc2gc/2,dY_gc2gc/2,0)
            # GC_OD = gc_cell.put('g1', dX_gc2gc/2,-dY_gc2gc/2,0)
            
            gc_ID = gc_cell.put('g1',0,-dY_gc2gc,180)
            gc_IU = gc_cell.put('g1',0,0,180)
            gc_OU = gc_cell.put('g1',dX_gc2gc,-dY_gc2gc,0)
            gc_OD = gc_cell.put('g1',dX_gc2gc,0,0)
            # Put DC
            dL_DC = self.cell.pin['b1'].x - self.cell.pin['a1'].x
            # inst = self.cell.put('a1',-dL_DC/2+dX_gc2gc/2,self.cell.pin['a1'].y-dY_gc2gc/2,0)
            DC_pX3 = self.cell.put('a1',-dL_DC/2+dX_gc2gc/2,self.cell.pin['a1'].y-dY_gc2gc/2,0)

            # Connect all the ports 
            stripe=Route(radius=10, width=self.w_wg, xs="strip") 
            stripe.sbend_p2p(pin1=gc_IU.pin['g1'],pin2=DC_pX3.pin['a1'],arrow=False,original_function=not sharp_patch).put() 
            stripe.sbend_p2p(pin1=gc_ID.pin['g1'],pin2=DC_pX3.pin['a2'],arrow=False,original_function=not sharp_patch).put()
            stripe.sbend_p2p(pin1=gc_OD.pin['g1'],pin2=DC_pX3.pin['b1'],arrow=False,original_function=not sharp_patch).put()
            stripe.sbend_p2p(pin1=gc_OU.pin['g1'],pin2=DC_pX3.pin['b2'],arrow=False,original_function=not sharp_patch).put() 
        return C