def get_stack(
    yaml_path: str | Path | None = None,
    **kwargs,
) -> LayerStack:
    """Get layer stack from active PDK or YAML file.

    Args:
        yaml_path: Path to custom YAML stack file. If None, uses active PDK.
        **kwargs: Additional args passed to extract_layer_stack:
            - substrate_thickness: Thickness below z=0 in um (default: 2.0)
            - air_above: Air box height above top metal in um (default: 200)
            - include_substrate: Include lossy silicon substrate (default: False).
              When False, matches gds2palace "nosub" behavior for RF simulation.

    Returns:
        LayerStack object

    Examples:
        # From active PDK (after PDK.activate()) - no substrate (recommended for RF)
        stack = get_stack()

        # With lossy substrate (for substrate coupling studies)
        stack = get_stack(include_substrate=True)

        # From YAML file
        stack = get_stack(yaml_path="custom_stack.yaml")

        # With custom settings
        stack = get_stack(air_above=300, substrate_thickness=5.0)
    """
    if yaml_path is not None:
        return load_stack_yaml(yaml_path)

    pdk = gf.get_active_pdk()
    if pdk is None:
        raise ValueError("No active PDK found. Call PDK.activate() first.")

    return extract_from_pdk(pdk, **kwargs)

def load_stack_yaml(yaml_path: str | Path) -> LayerStack:
    """Load layer stack from YAML file.

    Args:
        yaml_path: Path to YAML file

    Returns:
        LayerStack object
    """
    yaml_path = Path(yaml_path)
    with open(yaml_path) as f:
        data = yaml.safe_load(f)

    # Reconstruct LayerStack from dict
    stack = LayerStack(
        pdk_name=data.get("pdk", "unknown"),
        units=data.get("units", "um"),
    )

    # Load materials
    stack.materials = data.get("materials", {})

    # Load layers
    for name, layer_data in data.get("layers", {}).items():
        stack.layers[name] = Layer(
            name=name,
            gds_layer=tuple(layer_data["gds_layer"]),
            zmin=layer_data["zmin"],
            zmax=layer_data["zmax"],
            thickness=layer_data.get(
                "thickness", layer_data["zmax"] - layer_data["zmin"]
            ),
            material=layer_data["material"],
            layer_type=layer_data["type"],
            mesh_resolution=layer_data.get("mesh_resolution", "medium"),
        )

    # Load dielectrics
    stack.dielectrics = data.get("dielectrics", [])

    # Load simulation settings
    stack.simulation = data.get("simulation", {})

    return stack

def extract_from_pdk(
    pdk_module,
    output_path: Path | None = None,
    **kwargs,
) -> LayerStack:
    """Extract layer stack from a PDK module or PDK object.

    Args:
        pdk_module: PDK module (e.g., ihp, sky130) or gdsfactory Pdk object
        output_path: Optional path to write YAML file
        **kwargs: Additional arguments passed to extract_layer_stack

    Returns:
        LayerStack object for Palace simulation
    """
    pdk_name = "unknown"

    if hasattr(pdk_module, "name") and isinstance(pdk_module.name, str):
        pdk_name = pdk_module.name
    elif hasattr(pdk_module, "PDK") and hasattr(pdk_module.PDK, "name"):
        pdk_name = pdk_module.PDK.name
    elif hasattr(pdk_module, "__name__"):
        pdk_name = pdk_module.__name__

    gf_layer_stack = None

    if hasattr(pdk_module, "layer_stack") and pdk_module.layer_stack is not None:
        gf_layer_stack = pdk_module.layer_stack
    elif hasattr(pdk_module, "LAYER_STACK"):
        gf_layer_stack = pdk_module.LAYER_STACK
    elif hasattr(pdk_module, "get_layer_stack"):
        gf_layer_stack = pdk_module.get_layer_stack()
    elif hasattr(pdk_module, "PDK") and hasattr(pdk_module.PDK, "layer_stack"):
        gf_layer_stack = pdk_module.PDK.layer_stack

    if gf_layer_stack is None:
        raise ValueError(f"Could not find layer stack in PDK: {pdk_module}")

    stack = extract_layer_stack(gf_layer_stack, pdk_name=pdk_name, **kwargs)

    if output_path:
        stack.to_yaml(output_path)

    return stack

def extract_layer_stack(
    gf_layer_stack: GfLayerStack,
    pdk_name: str = "unknown",
    substrate_thickness: float = 2.0,
    air_above: float = 200.0,
    boundary_margin: float = 30.0,
    include_substrate: bool = False,
) -> LayerStack:
    """Extract layer stack from a gdsfactory LayerStack.

    Args:
        gf_layer_stack: gdsfactory LayerStack object
        pdk_name: Name of the PDK (for documentation)
        substrate_thickness: Thickness of substrate in um (default: 2.0)
        air_above: Height of air box above top metal in um (default: 200)
        boundary_margin: Lateral margin from GDS bbox in um (default: 30)
        include_substrate: Whether to include lossy substrate (default: False)

    Returns:
        LayerStack object for Palace simulation
    """
    stack = LayerStack(pdk_name=pdk_name)

    z_min_overall = float("inf")
    z_max_overall = float("-inf")
    materials_used: set[str] = set()

    for layer_name, layer_level in gf_layer_stack.layers.items():
        zmin = layer_level.zmin if layer_level.zmin is not None else 0.0
        thickness = layer_level.thickness if layer_level.thickness is not None else 0.0
        zmax = zmin + thickness
        material = layer_level.material if layer_level.material else "unknown"
        gds_layer = _get_gds_layer_tuple(layer_level)
        layer_type = _classify_layer_type(layer_name, material)

        if layer_type == "substrate" and not include_substrate:
            continue

        layer = Layer(
            name=layer_name,
            gds_layer=gds_layer,
            zmin=zmin,
            zmax=zmax,
            thickness=thickness,
            material=material,
            layer_type=layer_type,
        )

        stack.layers[layer_name] = layer
        materials_used.add(material)

        if layer_type != "substrate":
            z_min_overall = min(z_min_overall, zmin)
            z_max_overall = max(z_max_overall, zmax)

    for material in materials_used:
        props = get_material_properties(material)
        if props:
            stack.materials[material] = props.to_dict()
        else:
            stack.materials[material] = {
                "type": "unknown",
                "note": "Material not in database, please add properties manually",
            }

    if "air" not in stack.materials:
        stack.materials["air"] = MATERIALS_DB["air"].to_dict()

    if "SiO2" not in stack.materials:
        stack.materials["SiO2"] = MATERIALS_DB["SiO2"].to_dict()

    if include_substrate:
        stack.dielectrics.append(
            {
                "name": "substrate",
                "zmin": -substrate_thickness,
                "zmax": 0.0,
                "material": "silicon",
            }
        )
        if "silicon" not in stack.materials:
            stack.materials["silicon"] = MATERIALS_DB["silicon"].to_dict()
        oxide_zmin = 0.0
    else:
        oxide_zmin = -substrate_thickness

    stack.dielectrics.append(
        {
            "name": "oxide",
            "zmin": oxide_zmin,
            "zmax": z_max_overall,
            "material": "SiO2",
        }
    )

    passive_thickness = 0.4
    stack.dielectrics.append(
        {
            "name": "passive",
            "zmin": z_max_overall,
            "zmax": z_max_overall + passive_thickness,
            "material": "passive",
        }
    )
    if "passive" not in stack.materials:
        stack.materials["passive"] = MATERIALS_DB["passive"].to_dict()

    stack.dielectrics.append(
        {
            "name": "air_box",
            "zmin": z_max_overall + passive_thickness,
            "zmax": z_max_overall + passive_thickness + air_above,
            "material": "air",
        }
    )

    stack.simulation = {
        "boundary_margin": boundary_margin,
        "air_above": air_above,
        "substrate_thickness": substrate_thickness,
        "include_substrate": include_substrate,
    }

    return stack

def parse_layer_stack(layer_stack: GfLayerStack) -> list[StackLayer]:
    """Parse a gdsfactory LayerStack into a list of StackLayer objects.

    Args:
        layer_stack: gdsfactory LayerStack object

    Returns:
        List of StackLayer objects sorted by zmin (ascending)
    """
    layers = []

    for name, level in layer_stack.layers.items():
        zmin = level.zmin if level.zmin is not None else 0.0
        thickness = level.thickness if level.thickness is not None else 0.0
        zmax = zmin + thickness
        material = level.material if level.material else None
        gds_layer = _get_gds_layer_number(level)
        layer_type = _classify_layer(name)

        layers.append(
            StackLayer(
                name=name,
                zmin=zmin,
                zmax=zmax,
                thickness=thickness,
                material=material,
                gds_layer=gds_layer,
                layer_type=layer_type,
            )
        )

    # Sort by zmin ascending
    layers.sort(key=lambda layer: layer.zmin)
    return layers

def get_material_properties(material_name: str) -> MaterialProperties | None:
    """Look up material properties by name.

    Args:
        material_name: Material name from PDK (e.g., "aluminum", "tungsten")

    Returns:
        MaterialProperties if found, None otherwise
    """
    name_lower = material_name.lower().strip()

    # Check direct match
    if name_lower in MATERIALS_DB:
        return MATERIALS_DB[name_lower]

    # Check aliases
    if name_lower in MATERIAL_ALIASES:
        return MATERIALS_DB[MATERIAL_ALIASES[name_lower]]

    # Check case-insensitive match in DB
    for db_name, props in MATERIALS_DB.items():
        if db_name.lower() == name_lower:
            return props

    return None

def material_is_conductor(material_name: str) -> bool:
    """Check if a material is a conductor."""
    props = get_material_properties(material_name)
    return props is not None and props.type == "conductor"

def material_is_dielectric(material_name: str) -> bool:
    """Check if a material is a dielectric."""
    props = get_material_properties(material_name)
    return props is not None and props.type == "dielectric"

def plot_stack(pdk, width: float = 600, height: float = 800, to_scale: bool = False):
    """Create an interactive plotly visualization of the layer stack.

    Args:
        pdk: A PDK module with LAYER_STACK, or a LayerStack directly
        width: Figure width in pixels
        height: Figure height in pixels
        to_scale: If True, show actual z dimensions. If False (default),
                  use fixed height for all layers for better visibility.

    Returns:
        plotly Figure object (displays automatically in notebooks)

    Examples:
        ```python
        import ihp

        plot_stack(ihp)
        ```
    """
    # Extract LayerStack from PDK module if needed
    layer_stack = pdk.LAYER_STACK if hasattr(pdk, "LAYER_STACK") else pdk

    layers = parse_layer_stack(layer_stack)

    if not layers:
        fig = go.Figure()
        fig.add_annotation(text="No layers found", x=0.5, y=0.5, showarrow=False)
        return fig

    # Color scheme by layer type
    colors = {
        "conductor": "#4CAF50",  # Green for metals/actives
        "via": "#87CEEB",  # Sky blue for vias
        "substrate": "#D0D0D0",  # Light gray for substrate
        "dielectric": "#D0D0D0",  # Light gray for dielectrics
    }

    # Find overlapping groups
    overlap_groups = _find_overlap_groups(layers)

    # Calculate column assignments and positions for each layer
    layer_columns = {}  # layer.name -> (column_index, total_columns_in_group)
    for group in overlap_groups:
        for i, layer in enumerate(group):
            layer_columns[layer.name] = (i, len(group))

    # Sort layers by zmin for consistent ordering
    sorted_layers = sorted(layers, key=lambda layer: layer.zmin)

    # Calculate uniform positions (not to scale)
    # In uniform mode, simply stack all layers vertically
    uniform_height = 1.0
    uniform_positions = {}  # layer.name -> (y0, y1)
    current_y = 0
    for layer in sorted_layers:
        uniform_positions[layer.name] = (current_y, current_y + uniform_height)
        current_y += uniform_height

    fig = go.Figure()

    # Base box width and x-coordinates
    total_width = 4
    base_x0 = 0

    # Helper to calculate x-coordinates for a layer based on its column
    # (for to-scale view).
    def get_x_coords_scaled(layer_name):
        col_idx, num_cols = layer_columns[layer_name]
        col_width = total_width / num_cols
        x0 = base_x0 + col_idx * col_width
        x1 = x0 + col_width
        return x0, x1

    # Add shapes and traces for both views
    # We'll use visibility toggling with buttons
    for _i, layer in enumerate(sorted_layers):
        color = colors.get(layer.layer_type, "#CCCCCC")

        # In uniform view, use full width; in to-scale view, use columns
        if to_scale:
            x0, x1 = get_x_coords_scaled(layer.name)
        else:
            x0, x1 = base_x0, base_x0 + total_width

        # Uniform (not to scale) positions
        u_y0, u_y1 = uniform_positions[layer.name]

        # To-scale positions
        s_y0, s_y1 = layer.zmin, layer.zmax

        # Use initial positions based on to_scale parameter
        y0 = s_y0 if to_scale else u_y0
        y1 = s_y1 if to_scale else u_y1

        # Add rectangle shape
        fig.add_shape(
            type="rect",
            x0=x0,
            x1=x1,
            y0=y0,
            y1=y1,
            fillcolor=color,
            line=dict(color="black", width=1),
            layer="below",
            name=f"shape_{layer.name}",
        )

        # Add invisible scatter for hover info
        fig.add_trace(
            go.Scatter(
                x=[(x0 + x1) / 2],
                y=[(y0 + y1) / 2],
                mode="markers",
                marker=dict(size=20, opacity=0),
                hoverinfo="text",
                hovertext=(
                    f"<b>{layer.name}</b><br>"
                    f"GDS Layer: {layer.gds_layer or 'N/A'}<br>"
                    f"Type: {layer.layer_type}<br>"
                    f"Z: {layer.zmin:.2f} - {layer.zmax:.2f} µm<br>"
                    f"Thickness: {layer.thickness:.3f} µm<br>"
                    f"Material: {layer.material or 'N/A'}"
                ),
                showlegend=False,
                name=f"hover_{layer.name}",
            )
        )

        # Add layer label
        fig.add_annotation(
            x=(x0 + x1) / 2,
            y=(y0 + y1) / 2,
            text=f"<b>{layer.name}</b>",
            showarrow=False,
            font=dict(size=10),
            name=f"label_{layer.name}",
        )

        # Add GDS layer number on the right side of the box
        if layer.gds_layer is not None:
            fig.add_annotation(
                x=x1 - 0.1,
                y=(y0 + y1) / 2,
                text=f"{layer.gds_layer}",
                showarrow=False,
                font=dict(size=9, color="gray"),
                xanchor="right",
            )

    # Build button data for toggling between views
    def build_layout_update(use_scale):
        shapes = []
        annotations = []

        for layer in sorted_layers:
            color = colors.get(layer.layer_type, "#CCCCCC")

            # Uniform view: full width; To-scale view: columns for overlaps
            if use_scale:
                lx0, lx1 = get_x_coords_scaled(layer.name)
                y0, y1 = layer.zmin, layer.zmax
            else:
                lx0, lx1 = base_x0, base_x0 + total_width
                y0, y1 = uniform_positions[layer.name]

            shapes.append(
                dict(
                    type="rect",
                    x0=lx0,
                    x1=lx1,
                    y0=y0,
                    y1=y1,
                    fillcolor=color,
                    line=dict(color="black", width=1),
                    layer="below",
                )
            )

            annotations.append(
                dict(
                    x=(lx0 + lx1) / 2,
                    y=(y0 + y1) / 2,
                    text=f"<b>{layer.name}</b>",
                    showarrow=False,
                    font=dict(size=10),
                )
            )

            # Add GDS layer number on the right side
            if layer.gds_layer is not None:
                annotations.append(
                    dict(
                        x=lx1 - 0.1,
                        y=(y0 + y1) / 2,
                        text=f"{layer.gds_layer}",
                        showarrow=False,
                        font=dict(size=9, color="gray"),
                        xanchor="right",
                    )
                )

        y_title = "Z (µm)" if use_scale else "Layer (not to scale)"
        if use_scale:
            y_range = [
                min(layer.zmin for layer in sorted_layers) - 1,
                max(layer.zmax for layer in sorted_layers) + 1,
            ]
        else:
            y_range = [-0.5, len(sorted_layers) + 0.5]

        return dict(
            shapes=shapes,
            annotations=annotations,
            yaxis=dict(
                title=y_title,
                range=y_range,
                showgrid=False,
                zeroline=False,
                showticklabels=use_scale,
            ),
        )

    # Build scatter y-positions for each view
    def build_scatter_update(use_scale):
        updates = []
        for layer in sorted_layers:
            if use_scale:
                y0, y1 = layer.zmin, layer.zmax
            else:
                y0, y1 = uniform_positions[layer.name]
            updates.append([(y0 + y1) / 2])
        return updates

    uniform_scatter_y = build_scatter_update(False)
    scale_scatter_y = build_scatter_update(True)

    # Initial y-range
    if to_scale:
        y_range = [
            min(layer.zmin for layer in sorted_layers) - 1,
            max(layer.zmax for layer in sorted_layers) + 1,
        ]
    else:
        y_range = [-0.5, len(sorted_layers) + 0.5]

    # Layout with buttons
    fig.update_layout(
        title="Layer Stack",
        width=width,
        height=height,
        xaxis=dict(
            showgrid=False,
            zeroline=False,
            showticklabels=False,
            range=[-0.5, 4.5],
        ),
        yaxis=dict(
            title="Layer (not to scale)" if not to_scale else "Z (µm)",
            showgrid=False,
            zeroline=False,
            showticklabels=to_scale,
            range=y_range,
        ),
        plot_bgcolor="white",
        hoverlabel=dict(bgcolor="white"),
        updatemenus=[
            dict(
                type="buttons",
                direction="left",
                x=0.0,
                y=1.15,
                xanchor="left",
                yanchor="top",
                buttons=[
                    dict(
                        label="Uniform",
                        method="update",
                        args=[
                            {"y": uniform_scatter_y},
                            build_layout_update(False),
                        ],
                    ),
                    dict(
                        label="To Scale",
                        method="update",
                        args=[
                            {"y": scale_scatter_y},
                            build_layout_update(True),
                        ],
                    ),
                ],
            ),
        ],
    )

    return fig