/* [Siren General Parameters] */
siren_diameter = 121;         // Base diameter - 121 for rotor to fit original siren 
siren_height = 60;            // Height of the rotor - 60 for rotor to fit original siren
number_of_ports = 6;    // Number of ports
tolerance = 2;          // Tolerance between stator and rotor
pressure_zone = 0.5;    // Percentage of diameter
round_radius = 4;       // Rounding of top/bottom
$fn = $preview ? 32 : 128;   // Number of fragments

/* [Stator Parameters] */
stator_wall_thickness = 8;      // Stator wall thickness
number_of_mounting_holes = 4;   // Number of mounting holes
screw_diameter = 3.2;           // Diameter of screws - M3 clearance hole (3.2mm diameter)
screw_bore_diameter = 6.5;
screw_insert_diameter = 4.5;
screw_bore_depth = 2.5;
screw_length = 10 - (stator_wall_thickness - screw_bore_depth);
stator_screw_offset = siren_diameter/2 - stator_wall_thickness/2;    //distance to screws

/* [Rotor Parameters] */
rotor_wall_thickness = 3;   // Rotor wall thickness
hub_height = 3;
hub_diameter = 12;
blade_angle = 8;
port_height = siren_height - (rotor_wall_thickness * 2) - (tolerance * 2);       // Height of the port

/* [Motor Parameters] */
motor_shaft_diameter = 8;       // Diameter of the motor body
motor_frame_diameter = 60; 
motor_diameter = 28;            // Diameter of the motor body
motor_height = 24;
magnet_diameter = 7;
motor_screw_x_offset = 9.5;
motor_screw_y_offset = 8;
motor_screw_offset = 8;
motor_frame_screw_offset = motor_frame_diameter/2 - stator_wall_thickness/2;    //distance to screws

/* [Base Parameters] */
leg_screw_offset = motor_frame_diameter / 2 + 5;
leg_height = motor_height + 10;

/* [Iris Parameters] */
iris_blade_arc_angle = 135;
number_of_iris_blades = 8;

// helper functions
module ports(diameter, height, ports, r_offset = 0) {
    radius = diameter / 2;
    angle = (180 / ports) - (r_offset * 6);
    
    rotate([0, 0, 180 / ports])
    for (i = [0:360/ports:360]) {
        rotate([0, 0, i + (r_offset * 6 / 2)])
        linear_extrude(height)
        polygon(concat(
            [[0, 0]],  // Center point
            [for (j = [0 : $fn]) 
                [radius * cos(angle * j / $fn), 
                 radius * sin(angle * j / $fn)]]
        ));
    }
}

module column(outer_diameter, inner_diameter, height, z_offset = 0) {
    difference(){
        // Outer cylinder
        cylinder(d = outer_diameter, h = height);
        // Subtract inner cylinder
        translate([0, 0, z_offset])
        cylinder(d = inner_diameter, h = height - z_offset);
    }
}

module rounded_column(outer_diameter, inner_diameter, height, z_offset = 0){
    difference() {
        // Rounded top
        intersection() {
        // Unrounded full cylinder
            cylinder(d = outer_diameter, h = height);
            
            // Add Minkowski rounded version
            minkowski() {
                cylinder(h = height - round_radius, d = outer_diameter - round_radius * 2);
                sphere(r = round_radius);
            }
        }
        
        // Subtract inner cylinder
        translate([0, 0, z_offset])
        cylinder(d = inner_diameter, h = height);
    }
}

module counter_bored_holes(screw_offset){
    // Subtract mounting holes for stator
    for (i = [0:360/number_of_mounting_holes:360]) {
        // Subtract screw hole
        rotate([0, 0, i])
        translate([screw_offset, 0, -1]) // Adjusted position
        cylinder(d = screw_diameter, h = stator_wall_thickness + 2);
        
        // Subtract counterbore
        rotate([0, 0, i])
        translate([screw_offset, 0, stator_wall_thickness - screw_bore_depth]) // Adjusted position
        cylinder(d = screw_bore_diameter, h = stator_wall_thickness);
    }
}

module mounting_holes(screw_offset){
    for (i = [0:360/number_of_mounting_holes:360]) {
        rotate([0, 0, i])
        translate([screw_offset, 0, 0])
        cylinder(d = screw_insert_diameter, h = screw_length);
    }
}

// Linear Interpolation
function lerp(a, b, t) = a * (1 - t) + b * t;

// Arc between points function
function arc_between_points(p1, p2, height, steps=20) = 
    [for(t = [0:1/steps:1]) 
        let(
            x = lerp(p1.x, p2.x, t),
            y = lerp(p1.y, p2.y, t),
            // Parabolic arc height calculation
            arc_height = height * (1 - pow(2*t-1, 2))
        ) 
        [x, y + arc_height]
    ];

function bezier_curve(t, p0, p1, p2, p3, p4) = 
    pow(1-t, 4) * p0 + 
    4 * pow(1-t, 3) * t * p1 + 
    6 * pow(1-t, 2) * pow(t, 2) * p2 +
    4 * (1-t) * pow(t, 3) * p3 +
    pow(t, 4) * p4;

function curved_polygon(points, steps, x_shift, y_shift) = 
    let(
        left_curve = [for (t = [0 : 1/steps : 1])
            bezier_curve(t, points[0], points[1], points[2], points[3], points[4])
        ],
        right_curve = [for (pt = left_curve)
            [pt[0] + x_shift, pt[1] + y_shift]
        ]
    )
    concat(left_curve, [for (i = [len(right_curve)-1 : -1 : 0]) right_curve[i]]);
        
module stator_top() {
    difference(){
        rounded_column(
            siren_diameter, 
            siren_diameter * pressure_zone, 
            stator_wall_thickness
        );
        
        counter_bored_holes(stator_screw_offset);
    }
}
        
    
module iris_top() {
    
    outer_diameter = stator_screw_offset * 2 - 5;
    inner_diameter = siren_diameter * pressure_zone + 5;
    blade_height = 0.5;
    
    center = (inner_diameter / 2) + ((outer_diameter - inner_diameter) / 4);
    
    difference(){
        column(
            outer_diameter, 
            inner_diameter,
            3
        );
        
        translate([0, 0, 2])
        linear_extrude(){
            for (i = [0:360/8:360]) {
                rotate([0, 0, i])
                translate([center, 0, 0])
                rotate([0, 0, 90])
                square([5, 25], center = true);
            }
        }
    }
    
    column(outer_diameter + 0.5, outer_diameter - 0.5, 5);
}

module iris_bottom() {
    
    outer_diameter = stator_screw_offset * 2 - 5;
    inner_diameter = siren_diameter * pressure_zone + 5;
    //blade_height = 0.5;
    
    center = (inner_diameter / 2) + ((outer_diameter - inner_diameter) / 4);
    
    difference(){
        column(
            siren_diameter, 
            siren_diameter * pressure_zone,
            3
        );
        
        translate([0, 0, 2])
        linear_extrude(){
            for (i = [0:360/8:360]) {
                rotate([0, 0, i])
                translate([center, 0, 0])
                circle(2.5);
            }
        }
        
        counter_bored_holes(stator_screw_offset);
        
        translate([0, 0, 1])
        column(outer_diameter + 1, outer_diameter - 1, 10);
    }
}

module iris_blade() {
    outer_diameter = stator_screw_offset * 2 - 10;
    inner_diameter = siren_diameter * pressure_zone + 10;
    blade_height = 0.5;
    
    center = (inner_diameter / 2) + ((outer_diameter - inner_diameter) / 4);
    
    linear_extrude(blade_height){
        difference(){
            for (i = [0:iris_blade_arc_angle/$fn:iris_blade_arc_angle]) {
                rotate([0, 0, i])
                translate([center, 0, 0])
                circle((outer_diameter - inner_diameter) / 4);
            }
            
            translate([center, 0, 0])
            circle(2.5);
            
            rotate([0, 0, iris_blade_arc_angle])
            translate([center, 0, 0])
            circle(2.5);
            }
    }
}

//color("blue")
iris_bottom();

translate([0, 0, 2])
color("red")
iris_blade();
translate([0, 0, 10])
iris_top();



/*
iris_blade_arc_angle = 135;
number_of_iris_blades = 8;

outer_diameter = stator_screw_offset * 2 - tolerance;
inner_diameter = siren_diameter * pressure_zone + tolerance;
center = (inner_diameter / 2) + ((outer_diameter - inner_diameter) / 4);

rotate([0, 0, 0])
color("blue")
square([5, 200]);
//iris_top();
rotate([0, 0, -45])
for(i = [0:360/8:360/8 * 0]){
    //this point is the radial translation of the rh pin based on angle of the blade
    pin_angle = -70;
    echo(center * cos(pin_angle), center * sin(pin_angle));
    //echo((center * cos(pin_angle)) + pin_angle);
    //rotate([0, 0, -10])
    rotate([0, 0, i])
    translate([(center  + 0) * cos(pin_angle), (center + 0) * sin(pin_angle), i/50])
    rotate([0, 0, -35])
    //rotate([0, 0, -0 + (pin_angle / ((iris_blade_arc_angle / -(pin_angle)) + 1))])
    translate([-center, 0, 0])

    color("red")
    iris_blade();
}
translate([0, 0, -10])
circle(d = center * 2);
*/