// inputs, delay line config
// will have to scale approperly
$fa = 1;
$fs = 0.01;

SCRIPT_VERSION="0.0.1";
FONT="Ubuntu Sans Mono:style=Regular";
// lambda = 7.5;

substrate = "SI";
test_number = 1;
// linbo
c = 3992.0;
// si
// c = 3159.0;
freq = 50.0e6;

// $fs = (c/freq);

// inout distance
distance = 50;

// number of finger
n_fingers = 50;

// should be 50-70
finger_length = 60; 

// for tweaking the design
gap = 0;

// for tweaking the design
thickness = 0;

// scale in m
scale_unit = 1e3;

leg_length = 0.003;
leg_width = 0.00001875;
leg_angle = 10;
size = 0.002;
bond_pad_shape = "square";


info_block_offset_x=7;
info_block_offset_y=30;
info_block_scale=0.3;
title_text_size = 4;
prop_text_size = 2.5;
id_text_size = 2;

number_of_idts_per_quadrent=4;
idt_x_spacing = 10;
idt_y_spacing = 7;

wafer_size_inch = 4;

function length(point_1, point_2) = sqrt(
    (point_1-point_2).x^2 +
    (point_1-point_2).y^2 +
    (point_1-point_2).z^2
);


// creates 1 side of the idt
module delay_line(lambda = 1, n_fingers = 1, finger_length = 50, gap = 0, thickness = 0) {
    // code
    l45 =lambda*5/4;
    l2 = lambda/2;
    l4 = lambda/4;
    l8 = lambda/8;
    b = l4 + thickness;
    f = l4 + finger_length*lambda;

    points_cap = [
        [0, 0],
        [0, l2],
        [-b-f, l2],
        [-b-f, l4],
        [-b, l4],
        [-b, 0]
    ];

    points = [
        [0, 0],
        [b, 0],
        [b, l2],
        [b+f, l2],
        [b+f, l2+l4],
        [b, l2+l4],
        [b, l4*5-l4],
        [0, l4*5-l4]
    ];
    // union () {

    translate([0, l2, 0]){
            for(i = [0:n_fingers]){
                translate([0, i*(l45-l4), 0]) {
                polygon(points);
                }
            }

        color("red") {
            rotate([0, 0, 180])
            translate([0, 0, 0]) {
                polygon(points_cap);
            }

            translate([f+l2+gap+thickness, -l2, 0]) {
                square(size=[l4+thickness, l4]);
            }
        }

        
            union() {
                for(i = [0:n_fingers]){
                    translate([2*b+f+gap+l4, i*(l45-l4)+l2+l4 , 0]) 
                    rotate([0, 0, 180])
                    polygon(points);
                }
            }
        
        color("red") {
            translate([2*b+f+gap+l4, n_fingers*lambda+lambda-l4, 0]) {
                polygon(points_cap);
            }
            translate([0, n_fingers*lambda+lambda, 0]) {
                square(size=[l4+thickness, l4]);
            }
        }

    }
}


// todo fix this
// units in m, the size is the min bond pad size
module bond_pad(
    leg_length = 0.000075, 
    leg_width = 0.00001875,
    leg_length_tweak = 0,
    leg_angle = 45, 
    size = 0.000075, 
    bond_pad_shape = "square", 
    post_scale = false
) {
    if (post_scale) {
        circle(r=leg_width*post_scale);

        rotate([0, 0, leg_angle+180]) {
            translate([-leg_length*post_scale-leg_length_tweak, -leg_width*post_scale/2, 0]) {
                // color([0, 255/255, 255/255]) {
                    // arm
                    square(size=[(leg_length)*post_scale+leg_length_tweak, leg_width*post_scale]);                
                // }
            }
        }
        // pad
        translate([post_scale*leg_length*cos(leg_angle), post_scale*leg_length*sin(leg_angle), 0]) {
            square(size=[size*post_scale, size*post_scale], center=true);
        }

        // echo(str("x = ", post_scale*leg_length*cos(leg_angle+180)));
        // echo(str("y = ", post_scale*leg_length*sin(leg_angle+180)));

    
    } else {
        rotate([0, 0, leg_angle+180]) {
            translate([-leg_length/2, -leg_width, 0]) {
                // color([0, 255/255, 255/255]) {
                    square(size=[leg_length, leg_width]);                
                // }
            }
        }
        square(size=[size, size], center=true);
    }
}

// creates the input and output ids
module delay_line_idt(
    c, 
    f, 
    n_fingers, 
    distance = 100, 
    finger_length = 50, 
    gap = 0, 
    thickness = 0, 
    impedance = 50, 
    has_bond_pads = false,
    bond_pad_leg_length = 0.00005, 
    bond_pad_leg_width = 0.00001875, 
    bond_pad_size = 0.000075,
    bond_pad_angle = 45,
    bond_pad_bond_pad_shape = "square",
    post_scale = false,
    id_number = 0,
    has_id = true
) {

    local_scale = 0;
    // echo("===== DELAY LINE IDT INFO ===== ");

    if (post_scale) {
        lambda = c/f * post_scale;
        // dont worry about these magic fractions
        length_of_input = n_fingers*lambda+1.74*lambda;
        // n_fingers*lambda+lambda/2;
        
        
        echo(str("lambda = ", lambda));
        // echo(str("lambda/4 = ", lambda/4));
        // echo(str("lambda_scale = ", post_scale));
        delay_line(lambda, n_fingers, finger_length, gap, thickness);



        if (has_id) {
            color([255/255, 0/255, 255/255]) 
            translate([finger_length*lambda/2, has_bond_pads ? -(bond_pad_leg_length * post_scale * cos(bond_pad_angle)) : -lambda*finger_length/2, 0])
            text(str(id_number), size=id_text_size, halign="center");
        }

        color([0/255, 255/255, 128/255]) {
            translate([0, distance*lambda+length_of_input, 0]) {
                delay_line(lambda, n_fingers, finger_length, gap, thickness);
            }
        }

        // near ori
        rotate([0, 0, -90]) {
            if (has_bond_pads) {
                color([255/255, 255/255, 255/255]) {
                    bond_pad(
                        leg_length_tweak = lambda/4,
                        leg_width=c/f/4, 
                        leg_length=length(
                            [0,0,0], 
                            [bond_pad_leg_length, bond_pad_leg_length, 0]
                        ), 
                        leg_angle = -bond_pad_angle,
                        size = bond_pad_size, 
                        post_scale=scale_unit
                    );
                }
            }
        }
        // near side
        
        translate([lambda*finger_length+gap+thickness*2+lambda, 0, 0]) {
            rotate([0, 0, -90]) {
                    if (has_bond_pads) {
                        bond_pad(
                            leg_length_tweak = lambda/5,
                            leg_width=c/f/4, 
                            leg_length=length(
                                [0,0,0], 
                                [bond_pad_leg_length, bond_pad_leg_length, 0]
                            ), 
                            leg_angle = bond_pad_angle,
                            size = bond_pad_size, 
                            post_scale=scale_unit
                        );
                }
            }
        }

        // far side
        translate([0, length_of_input+distance*lambda+length_of_input, 0]) {   
                rotate([0, 0, 90]) {                    
                    if (has_bond_pads) {
                        bond_pad(
                            leg_length_tweak = lambda/5,
                            leg_width=c/f/4, 
                            leg_length=length(
                                [0,0,0], 
                                [bond_pad_leg_length, bond_pad_leg_length, 0]
                            ), 
                            leg_angle = bond_pad_angle,
                            size = bond_pad_size, 
                            post_scale=scale_unit
                        );
                    }
                }
                // furthest side
                translate([lambda*finger_length+gap+thickness*2+lambda, 0, 0]) {
                    rotate([0, 0, 90]) {                    
                            if (has_bond_pads) {
                                bond_pad(
                                    leg_length_tweak = lambda/4,
                                    leg_width=c/f/4, 
                                    leg_length=length(
                                        [0,0,0], 
                                        [bond_pad_leg_length, bond_pad_leg_length, 0]
                                    ), 
                                    leg_angle = -bond_pad_angle,
                                    size = bond_pad_size, 
                                    post_scale=scale_unit
                                );
                        }
                    }
                }
        } 
    } else {
        lambda = 1;
        length_of_input = n_fingers*lambda*15/8;
        echo(str("lambda = ", lambda));
        echo(str("lambda_scale = ", 1));
        delay_line(lambda, n_fingers, finger_length, gap, thickness);
        translate([0, length_of_input+distance*lambda, 0])
        delay_line(lambda, n_fingers, finger_length, gap, thickness);
    }

    // echo(str("impedance = ", impedance));

    // echo(str("total capacitance = ", 1/(2*PI*f*impedance)));

    // echo("===== DELAY LINE IDT INFO ===== ");
}

module wafer(d) {
    color([128/255, 128/255, 128/255]) {
        translate([0, 0, -1]) {
            circle(r=d/2);
        }
    }
}

module prameter_text() {
text(str("IDT ", substrate, "#", test_number), size=4, font=FONT);
translate([0, -title_text_size, 0])    
text(str("c              : ", c), size=prop_text_size, font=FONT);
translate([0, -title_text_size*2, 0])    
text(str("freq           : ", freq), size=prop_text_size, font=FONT);
translate([0, -title_text_size*3, 0])    
text(str("distance       : ", distance), size=prop_text_size, font=FONT);
translate([0, -title_text_size*4, 0])    
text(str("n_fingers      : ", n_fingers), size=prop_text_size, font=FONT);
translate([0, -title_text_size*5, 0])    
text(str("finger_length  : ", finger_length), size=prop_text_size, font=FONT);
translate([0, -title_text_size*6, 0])    
text(str("gap            : ", gap), size=prop_text_size, font=FONT);
translate([0, -title_text_size*7, 0])    
text(str("thickness      : ", thickness), size=prop_text_size, font=FONT);
translate([0, -title_text_size*8, 0])    
text(str("leg_length     : ", leg_length), size=prop_text_size, font=FONT);
translate([0, -title_text_size*9, 0])    
text(str("leg_angle      : ", leg_angle), size=prop_text_size, font=FONT);
translate([0, -title_text_size*10, 0])    
text(str("size           : ", size), size=prop_text_size, font=FONT);
translate([0, -title_text_size*11, 0])    
text(str("feat. size (mm): ", (c/freq)*1e3), size=prop_text_size, font=FONT);
translate([0, -title_text_size*12, 0])    
text(str("version        : ", SCRIPT_VERSION), size=prop_text_size, font=FONT);

}



translate([info_block_offset_x, -info_block_offset_y, 0]) {
rotate([0, 0, -90]) 
scale([info_block_scale, info_block_scale, info_block_scale]) {
    prameter_text();
}
}

rotate([0, 0, 180])
translate([info_block_offset_x, -info_block_offset_y, 0]) {
rotate([0, 0, -90]) 
scale([info_block_scale, info_block_scale, info_block_scale]) {
    prameter_text();
}
}

// delay_line_idt(
//     c, 
//     freq, 
//     n_fingers, 
//     distance, 
//     finger_length, 
//     gap, 
//     thickness, 
//     post_scale=scale_unit,
//     has_bond_pads = true,
//     bond_pad_angle = leg_angle,
//     bond_pad_leg_width = leg_width,
//     bond_pad_leg_length = leg_length,
//     bond_pad_size = size 
// );


// wafer(wafer_size_inch*25.4);
for (i=[0:number_of_idts_per_quadrent-1]) {
    translate([idt_x_spacing/4, 0, 0]) {
    translate([i * idt_x_spacing, idt_y_spacing, 0]) {
            delay_line_idt(
                c, 
                freq, 
                n_fingers, 
                distance, 
                finger_length, 
                gap, 
                thickness, 
                post_scale=scale_unit,
                has_bond_pads = true,
                bond_pad_angle = leg_angle,
                bond_pad_leg_width = leg_width,
                bond_pad_leg_length = leg_length,
                bond_pad_size = size 
            );
    }
    translate([i * idt_x_spacing, -idt_y_spacing, 0]) {
        scale([1, -1, 1]) {
            delay_line_idt(
                c, 
                freq, 
                n_fingers, 
                distance, 
                finger_length, 
                gap, 
                thickness, 
                post_scale=scale_unit,
                has_bond_pads = true,
                bond_pad_angle = leg_angle,
                bond_pad_leg_width = leg_width,
                bond_pad_leg_length = leg_length,
                bond_pad_size = size 
            );
        }
    }
    }

    scale([-1, 1, 1])
    translate([idt_x_spacing/4, 0, 0]) {
        
    translate([i * idt_x_spacing, idt_y_spacing, 0]) {
            delay_line_idt(
                c, 
                freq, 
                n_fingers, 
                distance, 
                finger_length, 
                gap, 
                thickness, 
                post_scale=scale_unit,
                has_bond_pads = true,
                bond_pad_angle = leg_angle,
                bond_pad_leg_width = leg_width,
                bond_pad_leg_length = leg_length,
                bond_pad_size = size 
            );
    }
    translate([i * idt_x_spacing, -idt_y_spacing, 0]) {
        scale([1, -1, 1]) {
            delay_line_idt(
                c, 
                freq, 
                n_fingers, 
                distance, 
                finger_length, 
                gap, 
                thickness, 
                post_scale=scale_unit,
                has_bond_pads = true,
                bond_pad_angle = leg_angle,
                bond_pad_leg_width = leg_width,
                bond_pad_leg_length = leg_length,
                bond_pad_size = size 
            );
        }
    }
    }
}

// bond_pad(
//     leg_length = 0.0075, 
//     leg_width = 0.00001875,
//     leg_angle = 20, 
//     size = 0.0075, 
//     bond_pad_shape = "square", 
//     post_scale = scale_unit
// );