// Adapter Parameters
inlet_outer_dia = 40; // mm
inlet_inner_dia = 35; // mm
outlet_inner_start = 30; // mm (tapered from 35)
outlet_inner_end = 32.1; // mm
total_length = 70; // mm horizontal length after elbow
vertical_leg_height = 15; // mm height of the vertical inlet section
elbow_radius = 15; // mm radius for the right-angle turn

// Wall thickness check:
// At outlet end, outer dia needs to be at least 32.1 + 2*3 = 38.1mm.
// We will taper from 40mm down to ~38.5mm to ensure >3mm walls everywhere.

outlet_outer_start = 40; // mm (at elbow start)
outlet_outer_end = 38.5; // mm (at end, ensures ~3.2mm wall thickness)

// Function to calculate linear taper diameter
function taper_dia(d1, d2, pos, start_pos, end_pos) =
    let(
        ratio = clamp((pos - start_pos) / (end_pos - start_pos), 0, 1)
    )
    d1 + (d2 - d1) * ratio;

// Module for the vertical inlet leg
module vertical_leg() {
    // Outer cylinder
    cylinder(h = vertical_leg_height, r = inlet_outer_dia / 2, center = false);
   
    // Inner bore (35mm ID)
    translate([0, 0, 0])
        cylinder(h = vertical_leg_height + 1, r = inlet_inner_dia / 2, center = false);
}

// Module for the horizontal outlet leg
module horizontal_leg() {
    // We build this by combining tapered sections
   
    // Section 1: Taper from 35mm ID to 30mm ID (first 10mm)
    // Outer taper starts at elbow radius and goes slightly down
    // Let's define outer taper for first 10mm: from ~38mm to ~37.5mm?
    // Actually, let's keep outer simple: linear taper from 40 to 38.5 over full length.
   
    // Inner Bore Construction
    union() {
        // Part A: First 10mm - Taper 35 -> 30
        for(i = [0:0.5:10]) {
            let(
                r_in = taper_dia(inlet_inner_dia/2, outlet_inner_start/2, i, 0, 10) / 2, // Wait, taper_dia returns diameter? No, I defined it as linear interp.
                // Let's fix the function usage: taper_dia takes diameters.
                r_in = taper_dia(inlet_inner_dia, outlet_inner_start, i, 0, 10) / 2
            ) {
                translate([i, 0, 0])
                    cylinder(h = 0.5, r = r_in, center = false);
            }
        }
       
        // Part B: Middle section (30mm ID constant) from X=10 to X=10
        // Actually, the taper ends at 10mm. Then it stays 30mm until where?
        // "gradually widens over the last 60mm to an opening width of 32.1 mm"
        // So from X=10 to X=70, it widens.
       
        // Part C: Widening section (30 -> 32.1) over 60mm
        for(i = [10:0.5:70]) {
            let(
                r_in = taper_dia(outlet_inner_start, outlet_inner_end, i, 10, 70) / 2
            ) {
                translate([i, 0, 0])
                    cylinder(h = 0.5, r = r_in, center = false);
            }
        }
    }
   
    // Outer Shell Construction
    union() {
        for(i = [0:0.5:70]) {
            let(
                r_out = taper_dia(outlet_outer_start, outlet_outer_end, i, 0, 70) / 2
            ) {
                translate([i, 0, 0])
                    cylinder(h = 0.5, r = r_out, center = false);
            }
        }
    }
}

// Module for the elbow connector
module elbow() {
    // We create a smooth transition using a lofted approach or simple geometry.
    // A simple way is to use a cylinder rotated 90 degrees and intersected,
    // but for smooth walls, let's use a custom shape.
   
    // Let's model the elbow as a quarter-torus-like shape with variable radii.
    // Or simpler: Use a cube with rounded edges? No.
   
    // Best approach for OpenSCAD without complex CSG:
    // Create a cylinder along X, then rotate and intersect?
    // Instead, let's just build the elbow as a separate piece that bridges the two legs.
   
    // We'll create a block that covers the corner and then hollow it out.
   
    // Outer Elbow Shape:
    // It connects Z=0 to X=elbow_radius, and Y=0.
    // Let's use a cylinder of radius elbow_radius, rotated 90 deg around Y?
    // No, let's just make a custom solid.
   
    // Simplest robust method:
    // 1. Make a cube for the corner.
    // 2. Subtract cylinders to round it? Too messy.
   
    // Let's use the 'hull' or 'minkowski'? No.
   
    // Let's stick to basic CSG:
    // The elbow is essentially a cylinder of radius R_elbow, but with varying cross-section.
    // To keep it simple and printable, we will model the outer shell as a
    // quarter-cylinder (radius = elbow_radius + wall_thickness)
    // and the inner bore as a quarter-cylinder (radius = inner_bore_radius).
   
    // However, the walls must be continuous.
   
    // Let's define the elbow as:
    // Outer: A cylinder of radius (elbow_radius + 3mm) rotated 90 deg?
    // Actually, let's just use a standard elbow geometry:
   
    // We will create two cylinders intersecting at 90 degrees.
    // But we need the inner bore to be smooth.
   
    // Approach:
    // 1. Create outer block: A cube of size [elbow_radius*2, elbow_radius*2, elbow_radius*2]
    //    with rounded corners?
    // 2. Subtract inner paths.
   
    // Let's try a different approach:
    // The elbow is just the space between X=0..15 and Z=0..15.
    // We will define the outer boundary as a cylinder of radius R_outer_elbow
    // centered at (elbow_radius, 0, elbow_radius)? No.
   
    // Let's use the 'cylinder' module to create the elbow walls.
    // Imagine a pipe bent at 90 degrees. The centerline is an arc.
    // But we want a sharp right angle? "makes a right turn" usually means 90 deg corner,
    // but for fluid flow and printing, a filleted corner is better.
    // The prompt says "makes a right turn", I'll assume a 90-degree corner with a small radius fillet.
   
    // Let's model the elbow as:
    // Outer: A cylinder of radius R_outer = elbow_radius + wall_thickness,
    //        but only the quarter section?
    // No, let's just build it from basic shapes.
   
    // We'll create a block that covers the corner [0..elbow_radius, 0..elbow_radius, 0..elbow_radius]
    // Then subtract the inner voids.
   
    // Inner Void:
    // - Vertical leg continues up to Z=vertical_leg_height? No, elbow is at Z=0.
    // - The vertical leg ends at Z=0.
    // - The horizontal leg starts at X=0.
    // - The elbow connects them.
   
    // Let's define the inner void of the elbow as:
    // A cylinder along Z, radius = inlet_inner_dia/2, but truncated?
    // And a cylinder along X, radius = outlet_inner_start/2?
    // This would create a sharp internal corner which is bad for flow and printing.
   
    // Better: Use a 'loft' or 'hull' of circles? OpenSCAD doesn't have loft.
   
    // Alternative: Use the 'cylinder' with a rotated difference?
   
    // Let's go with a simple filleted corner using Minkowski sum?
    // No, let's just use a cylinder for the elbow that is rotated 45 degrees?
    // No, it's a 90 degree turn.
   
    // I will model the elbow as a quarter-torus segment.
    // Outer Radius: R_out = elbow_radius + wall_thickness (approx 3mm) -> ~18mm
    // Inner Radius: R_in = elbow_radius - wall_thickness?
    // Wait, the inner bore diameter is 35mm. So inner radius is 17.5mm.
    // If the centerline of the pipe has radius R_center, then:
    // Inner surface radius = R_center - (ID/2)
    // Outer surface radius = R_center + (OD/2)
   
    // Let's assume the centerline of the elbow has a radius of 15mm.
    // Then Inner Radius = 15 - 17.5 = -2.5? That doesn't work. The pipe is too wide for a tight elbow.
   
    // Since the ID is 35mm, the minimum elbow radius (centerline) must be > 17.5mm.
    // Let's set Elbow Centerline Radius = 20mm.
    // Then Inner Radius of elbow = 20 - 17.5 = 2.5mm.
    // Outer Radius of elbow = 20 + 20 = 40mm (since OD is 40).
   
    // So, we can model the elbow as a torus segment!
   
    let(
        R_center = 20, // Centerline radius of the elbow
        R_inner = R_center - inlet_inner_dia/2, // 2.5mm
        R_outer = R_center + outlet_outer_start/2 // 20 + 20 = 40mm
    ) {
        // Create a full torus and cut it to 90 degrees
        rotate([0, 0, 0])
            intersection() {
                // Torus outer shape
                cylinder(h = R_outer*2, r = R_outer, center = true);
                rotate([90, 0, 0])
                    cylinder(h = R_outer*2, r = R_outer, center = true);
               
                // This creates a block. We need to hollow it out.
            }
    }
}

// Let's restart the elbow modeling with a cleaner approach.
// We will model the entire adapter as one piece using difference().

module full_adapter() {
    union() {
        // 1. Vertical Leg (Outer)
        translate([0, 0, 0])
            cylinder(h = vertical_leg_height, r = inlet_outer_dia/2, center = false);
           
        // 2. Horizontal Leg (Outer)
        translate([0, 0, 0])
            rotate([0, 90, 0]) // Rotate to lie along X? No, let's keep it aligned.
            // My horizontal_leg module builds along X.
            horizontal_leg();
           
        // 3. Elbow (Outer)
        // We need to bridge the gap between Z=vertical_leg_height and X=0.
        // Actually, the vertical leg goes from Z=0 to Z=15.
        // The horizontal leg starts at X=0, Z=0?
        // Let's adjust coordinates:
        // Vertical Leg: Z from 0 to 15.
        // Horizontal Leg: X from 0 to 70, Z=0.
        // Elbow connects (X=0, Z=15) to (X=15, Z=0)?
        // No, a right angle turn usually means the pipe bends at a corner.
       
        // Let's redefine coordinates for clarity:
        // Inlet: Vertical, pointing UP. Base at Z=0. Top at Z=vertical_leg_height.
        // Outlet: Horizontal, pointing RIGHT. Start at X=0, Z=vertical_leg_height?
        // No, standard elbow:
        // Pipe comes up, turns right. The centerline goes Up, then Right.
       
        // Let's place the corner at (0, 0, vertical_leg_height).
        // Vertical Leg: Cylinder from Z=0 to Z=vertical_leg_height.
        // Horizontal Leg: Cylinder from X=0 to X=70, at Z=vertical_leg_height.
        // Elbow: Connects them.
       
        // But the prompt says "goes up a few mm then makes a right turn".
        // This implies the vertical part is short.
       
        // Let's stick to:
        // Vertical Leg: Z: 0 -> 15. Center (0,0).
        // Horizontal Leg: X: 0 -> 70. Center (0,0) in XZ plane?
        // Let's put the horizontal leg at Z=0, but shifted?
       
        // Actually, let's just build it with the elbow at the origin for simplicity.
        // Vertical Leg: Up from Origin.
        // Horizontal Leg: Right from Origin.
        // Elbow: The corner.
       
        // I already built vertical_leg and horizontal_leg assuming they start at 0.
        // But they don't connect properly.
       
        // Let's rebuild the geometry with a unified coordinate system.
    }
}

// Final Clean Implementation
module adapter() {
    union() {
        // --- OUTER SHAPE ---
       
        // 1. Vertical Inlet Leg (Outer)
        translate([0, 0, 0])
            cylinder(h = vertical_leg_height, r = inlet_outer_dia/2, center = false);
           
        // 2. Horizontal Outlet Leg (Outer)
        // Starts at X=elbow_radius, Z=0? No, let's put the elbow at the origin.
        // Let's define the elbow as a quarter-torus centered at (0,0,0).
        // Vertical leg goes UP from Z=0.
        // Horizontal leg goes RIGHT from X=0.
       
        // Outer Elbow: Quarter Torus
        let(
            R_center_outer = 20, // Centerline radius
            R_tube_outer = inlet_outer_dia/2 // 20mm
        ) {
            rotate([0, 0, 0])
                intersection() {
                    // Outer boundary of the elbow
                    cylinder(h = (R_center_outer + R_tube_outer)*2, r = R_center_outer + R_tube_outer, center = true);
                    rotate([90, 0, 0])
                        cylinder(h = (R_center_outer + R_tube_outer)*2, r = R_center_outer + R_tube_outer, center = true);
                }
        }
       
        // Horizontal Leg Outer
        translate([elbow_radius + inlet_outer_dia/2, 0, 0])
            cylinder(h = total_length - (elbow_radius + inlet_outer_dia/2), r = outlet_outer_start/2, center = false);
            // Wait, the horizontal leg starts after the elbow.
            // The elbow ends at X=elbow_radius? No, the centerline of the elbow is an arc.
            // The end of the elbow (horizontal part) is at X = R_center_outer + R_tube_outer?
            // Let's simplify:
            // The horizontal leg starts at X=0, but we already have the elbow covering the corner.
            // We need to extend the horizontal leg from the end of the elbow.
           
            // Let's adjust:
            // Vertical Leg: Z: 0 -> vertical_leg_height
            // Horizontal Leg: X: 0 -> total_length, at Z=vertical_leg_height? No.
           
            // Let's use a simpler coordinate system:
            // Origin is the center of the elbow's inner corner?
           
            // I will provide the code based on this logic:
            // 1. Vertical Cylinder (Up)
            // 2. Horizontal Cylinder (Right)
            // 3. Elbow Block connecting them, with proper internal tapering.
           
            // To make it printable and simple, I'll use a 'difference' approach with basic shapes.
    }
}

// REVISED FINAL CODE STRUCTURE
// Coordinates:
// Vertical Leg: Z from 0 to vertical_leg_height (15mm). Center (0,0).
// Horizontal Leg: X from elbow_radius to total_length + elbow_radius?
// Let's set Elbow Radius = 20mm.
// The horizontal leg starts at X=20, Z=0? No, the pipe turns.
// Let's place the elbow such that:
// Vertical leg ends at Z=15.
// Horizontal leg starts at X=0, Z=15?
// No, a 90-degree turn means the horizontal leg is at a different height or offset.

// Standard Elbow Geometry:
// Centerline: Arc from (0,0,15) to (20,0,15)? No.
// Let's assume the pipe lies in the XZ plane.
// Vertical Leg: Z-axis.
// Horizontal Leg: X-axis.
// They meet at a corner.

// I will model it as:
// 1. Vertical Cylinder (Outer): Z:0..15, R=20
// 2. Horizontal Cylinder (Outer): X:0..70, Z=15? No, that's a T-junction.
// 3. Elbow: Connects them.

// Let's go with the Torus approach for the elbow, and extend cylinders from there.

// Outer Shell Construction
union() {
    // Vertical Leg
    translate([0, 0, 0])
        cylinder(h = vertical_leg_height, r = inlet_outer_dia/2, center = false);
       
    // Horizontal Leg
    // It starts at X=elbow_radius? No, let's put the elbow at (0,0,vertical_leg_height).
    // So Horizontal Leg is at Z=vertical_leg_height.
    translate([elbow_radius, 0, vertical_leg_height])
        cylinder(h = total_length - elbow_radius, r = outlet_outer_start/2, center = false);
       
    // Elbow (Outer)
    // Center of elbow rotation: (0, 0, vertical_leg_height)
    let(
        R_center = elbow_radius,
        R_tube = inlet_outer_dia/2
    ) {
        translate([0, 0, vertical_leg_height])
            rotate([0, 0, 0]) // Already aligned?
            intersection() {
                cylinder(h = (R_center + R_tube)*2, r = R_center + R_tube, center = true);
                rotate([90, 0, 0])
                    cylinder(h = (R_center + R_tube)*2, r = R_center + R_tube, center = true);
            }
    }
}

// Inner Void Construction
union() {
    // Vertical Leg Bore
    translate([0, 0, 0])
        cylinder(h = vertical_leg_height + 1, r = inlet_inner_dia/2, center = false);
       
    // Horizontal Leg Bore
    // Starts at X=elbow_radius? No, the bore must match the elbow.
    translate([elbow_radius, 0, vertical_leg_height])
        cylinder(h = total_length - elbow_radius, r = outlet_inner_start/2, center = false);
       
    // Elbow Bore
    let(
        R_center = elbow_radius,
        R_tube_in = inlet_inner_dia/2
    ) {
        translate([0, 0, vertical_leg_height])
            intersection() {
                cylinder(h = (R_center + R_tube_in)*2, r = R_center + R_tube_in, center = true);
                rotate([90, 0, 0])
                    cylinder(h = (R_center + R_tube_in)*2, r = R_center + R_tube_in, center = true);
            }
    }
}

// Wait, the horizontal bore needs to taper!
// The simple cylinder above does not taper.
// I need to replace the horizontal leg bore with the tapered version.

// Let's assemble the final code properly.

module final_adapter() {
    difference() {
        union() {
            // --- OUTER SHELL ---
           
            // 1. Vertical Leg Outer
            translate([0, 0, 0])
                cylinder(h = vertical_leg_height, r = inlet_outer_dia/2, center = false);
               
            // 2. Horizontal Leg Outer
            // Starts after the elbow. Elbow radius is 20mm.
            // The horizontal leg starts at X=20? No, the elbow ends at X=20?
            // The torus intersection creates a shape that extends to R_center+R_tube = 40mm in X and Z.
            // So the horizontal leg should start at X=40?
            // No, let's adjust the horizontal leg position to connect seamlessly.
           
            // Let's define the elbow center at (0,0,vertical_leg_height).
            // The outer surface of the elbow extends to X = R_center + R_tube = 20+20=40.
            // So the horizontal leg should start at X=40?
            // But we want the total length to be 70mm from the "connection" point.
            // Let's say the connection is at the end of the adapter.
           
            // To simplify, let's make the horizontal leg start at X=0 and overlap the elbow?
            // No, difference() handles overlaps fine.
           
            // Let's place the horizontal leg at Z=vertical_leg_height, starting from X=0.
            translate([0, 0, vertical_leg_height])
                cylinder(h = total_length, r = outlet_outer_start/2, center = false);
               
            // Elbow Outer
            let(
                R_center = elbow_radius,
                R_tube = inlet_outer_dia/2
            ) {
                translate([0, 0, vertical_leg_height])
                    intersection() {
                        cylinder(h = (R_center + R_tube)*2, r = R_center + R_tube, center = true);
                        rotate([90, 0, 0])
                            cylinder(h = (R_center + R_tube)*2, r = R_center + R_tube, center = true);
                    }
            }
        }
       
        // --- INNER VOID ---
       
        union() {
            // 1. Vertical Leg Bore
            translate([0, 0, 0])
                cylinder(h = vertical_leg_height + 1, r = inlet_inner_dia/2, center = false);
               
            // 2. Horizontal Leg Bore (Tapered)
            // We need to create a tapered bore.
            // Let's build it with loops for precision.
            translate([0, 0, vertical_leg_height])
                union() {
                    // Section A: Taper from 35mm to 30mm over first 10mm
                    for(i = [0:0.5:10]) {
                        let(
                            r_in = taper_dia(inlet_inner_dia, outlet_inner_start, i, 0, 10) / 2
                        ) {
                            translate([i, 0, 0])
                                cylinder(h = 0.5, r = r_in, center = false);
                        }
                    }
                   
                    // Section B: Constant 30mm? No, it widens immediately?
                    // "gradually widens over the last 60mm to an opening width of 32.1 mm"
                    // So from X=10 to X=70, it widens.
                   
                    for(i = [10:0.5:70]) {
                        let(
                            r_in = taper_dia(outlet_inner_start, outlet_inner_end, i, 10, 70) / 2
                        ) {
                            translate([i, 0, 0])
                                cylinder(h = 0.5, r = r_in, center = false);
                        }
                    }
                }
               
            // 3. Elbow Bore
            let(
                R_center = elbow_radius,
                R_tube_in = inlet_inner_dia/2
            ) {
                translate([0, 0, vertical_leg_height])
                    intersection() {
                        cylinder(h = (R_center + R_tube_in)*2, r = R_center + R_tube_in, center = true);
                        rotate([90, 0, 0])
                            cylinder(h = (R_center + R_tube_in)*2, r = R_center + R_tube_in, center = true);
                    }
            }
        }
    }
}

// Render the adapter
final_adapter();

// Optional: Add a small lip or feature for alignment if needed.