from solid.solidpython import *
from solid.utils import *

from . import parameters


gap = 0.5 # dissociate parts (do not add it in other calculations)


def motherboard_holes(datum=parameters.motherboard_datum):
    return [
        datum,
        [datum[0] + 45.72, datum[1]],
        [datum[0] + 203.2, datum[1] - 22.86],

        [datum[0] - 20.32, datum[1] - 154.94],
        # [datum[0], datum[1] - 154.94], # not on this motherboard
        [datum[0] + 45.72, datum[1] - 154.94],
        [datum[0] + 203.2, datum[1] - 154.94],

        [datum[0] + 45.72, datum[1] - 227.33],
        [datum[0] + 203.2, datum[1] - 227.33],
    ]


def motherboard_hole_objects(datum=parameters.motherboard_datum):
    height = parameters.motherboard_size[2] + gap
    return union()([
        translate([h[0], h[1], 0])(cylinder(h=height, r=3.96/2, center=True))
        for h in motherboard_holes(datum)
    ])


def motherboard():
    hole_objects = motherboard_hole_objects()
    size = parameters.motherboard_size
    board = cube(size, center=True)
    cooler = translate([-size[0]/2 + 100,
                        size[1]/2 - 120 - 30,
                        size[2]/2])(cube([120, 120, 65]))
    ramblock = translate([-size[0]/2 + 87,
                          -size[1]/2 + 30,
                          size[2]/2])(cube([145, 35, 30]))
    objects = board - hole_objects + cooler + ramblock
    return color(parameters.colors.motherboard)(render()(objects))


def motherboard_support():
    plan_size = parameters.motherboard_support_size
    support = cube(plan_size, center=True)
    hmount = parameters.motherboard_support_mount_height
    support_mounts = union()([
        translate([h[0], h[1], plan_size[2]/2 + hmount/2])(
            difference()(
                cylinder(h=hmount, r=2.5, center=True),
                cylinder(h=hmount + 1, r=1.5, center=True),
            )
        )
        for h in motherboard_holes()
    ])
    support = support + support_mounts
    return color(parameters.colors.metal)(render()(support))


def wood_rear_plate():
    thick = parameters.wood_thickness
    size = parameters.external_size
    connector_size = parameters.connector_panel_size
    rear_plate = cube([size[0] - 2*thick, thick, size[2]])
    tpsu = [gap, -gap, thick + gap + parameters.powersupply_offset_up]
    psu_hole = translate(tpsu)(
        cube([parameters.powersupply_size[2],
              thick + 2*gap,
              parameters.powersupply_size[0]])
    )
    vent_r = 10
    tvent = [size[0] - 2*thick - vent_r - 25,
             thick + gap,
             connector_size[2] + thick + vent_r + 20]
    vent_hole = translate(tvent)(
        rotate([90, 0, 0])(
            cylinder(r=vent_r, h=thick+2*gap)
        )
    )
    tconnector = [size[0] - 2*thick - 10 - connector_size[0], -gap, thick]
    connector_hole = translate(tconnector)(
        cube([connector_size[0], thick + 2*gap, connector_size[2]])
    )
    return rear_plate - psu_hole - vent_hole - connector_hole


def wood_front_plate():
    thick = parameters.wood_thickness
    size = parameters.external_size
    objects = cube([size[0], thick, size[2]])
    button = cylinder(r=parameters.button_diameter, h=thick+2*gap)
    objects += button
    return objects


def powersupply():
    size = parameters.powersupply_size
    psu = cube(size)
    psu -= translate([size[0]/2, size[1]/2, -gap])(
        cylinder(r=60, h=20)
    )
    return color(parameters.colors.psu)(render()(psu))


def wood_case():
    thick = parameters.wood_thickness
    size = parameters.external_size
    bottom_plate = translate([thick + gap, thick + gap, 0])(
        cube([size[0] - 2*thick, size[1] - 2*thick, thick])
    )
    right_left_plate = cube([thick, size[1] - thick, size[2]])
    right_plate = translate([size[0] - thick + 2*gap, thick + gap, 0])(
            right_left_plate
    )
    left_plate = translate([0, thick + gap, 0])(right_left_plate)
    rear_plate = translate([thick + gap, size[1] - thick + 2*gap, 0])(
        wood_rear_plate()
    )
    front_plate = wood_front_plate()
    all_plates = (
        bottom_plate + right_plate + left_plate + rear_plate + front_plate
    )
    return color(parameters.colors.wood)(render()(all_plates))


def main():
    thick = parameters.wood_thickness
    hup = parameters.motherboard_support_mount_height \
          + parameters.motherboard_support_size[2]/2 \
          + parameters.motherboard_size[2]/2
    motherboard_assembly = motherboard_support() + up(hup)(motherboard())
    d = wood_case()
    d += translate([thick + gap + parameters.powersupply_size[2],
                    thick + gap,
                    thick + gap])(
        translate([parameters.motherboard_support_size[0]/2,
                   parameters.motherboard_support_size[1]/2,
                   parameters.motherboard_support_size[2]/2])(
            motherboard_assembly
        )
    )
    psu = translate([parameters.powersupply_size[2] + thick + gap,
                     parameters.external_size[1] - thick - gap - parameters.powersupply_size[1],
                     thick + gap + parameters.powersupply_offset_up])(
        rotate([0, -90, 0])(powersupply())
    )
    d += psu
    #d = motherboard()
    #d = wood_rear_plate()
    d = wood_front_plate()
    #d = motherboard()
    scad_render_to_file(d, 'assembly.scad',
                        include_orig_code=False)