import machine
import time
import dht
import neopixel
from machine import ADC

trigger_pin = machine.Pin(5, machine.Pin.OUT)
echo_pin = machine.Pin(14, machine.Pin.IN)
servo_pwm = machine.PWM(machine.Pin(25), freq=50)

encoder_clk = machine.Pin(32, machine.Pin.IN, machine.Pin.PULL_UP)
encoder_dt = machine.Pin(19, machine.Pin.IN, machine.Pin.PULL_UP)

print_btn = machine.Pin(4, machine.Pin.IN, machine.Pin.PULL_UP)

dht_sensor = dht.DHT22(machine.Pin(15))
pir_sensor = machine.Pin(12, machine.Pin.IN)
mq_adc = machine.ADC(machine.Pin(34))
mq_adc.atten(ADC.ATTN_11DB)
mq_adc.width(ADC.WIDTH_12BIT)
ldr_adc = machine.ADC(machine.Pin(35))

parking_light_pin = machine.Pin(16, machine.Pin.OUT)

neopixel_pin = machine.Pin(33, machine.Pin.OUT)
np = neopixel.NeoPixel(neopixel_pin, 1)
buzzer_pin = machine.Pin(17, machine.Pin.OUT)

occupancy = 0
max_capacity = 8
lot_full = False

last_clk = encoder_clk.value()
last_encoder_time = 0

last_sub1_time = 0
last_sub3_time = 0
last_print_btn_time = 0

valid_distance_count = 0
vehicle_detected = False
barrier_open = False
barrier_open_time = 0

temperature = 0.0
gas_readings = []
gas_level_avg = 0
light_level = 0
air_quality_status = "NORMAL"
temp_status = "NORMAL"
light_status = "BRIGHT"

parking_lights_on = False
motion_detected = False
lights_on_until = 0

vent_level = "OFF"
prev_temp_status = temp_status
prev_air_quality_status = air_quality_status

hazard_temp = False
hazard_air = False
hazard_occupancy = False
active_hazard_count = 0
safety_level = "NORMAL"
prev_safety_level = "NORMAL"

led_state_on = False
last_led_toggle_time = 0
buzzer_state_on = False
last_buzzer_toggle_time = 0

waiting_for_vehicle_to_leave = False
access_denied = False

motion = 0
last_motion = 0

segment_pins = [
    machine.Pin(18, machine.Pin.OUT),
    machine.Pin(13, machine.Pin.OUT),
    machine.Pin(21, machine.Pin.OUT),
    machine.Pin(22, machine.Pin.OUT),
    machine.Pin(23, machine.Pin.OUT),
    machine.Pin(27, machine.Pin.OUT),
    machine.Pin(26, machine.Pin.OUT)
]

segments = {
    0: [1,1,1,1,1,1,0],
    1: [0,1,1,0,0,0,0],
    2: [1,1,0,1,1,0,1],
    3: [1,1,1,1,0,0,1],
    4: [0,1,1,0,0,1,1],
    5: [1,0,1,1,0,1,1],
    6: [1,0,1,1,1,1,1],
    7: [1,1,1,0,0,0,0],
    8: [1,1,1,1,1,1,1]
}

LED_TOGGLE_INTERVAL = 500   
BUZZER_ON_INTERVAL = 250  
BUZZER_OFF_INTERVAL = 250 

def set_servo_angle(angle):
    duty = int(26 + (angle / 180) * 102)
    servo_pwm.duty(duty)

def calculate_vent_level():
    if temp_status == "NORMAL":
        if air_quality_status == "GOOD":
            return "OFF"
        elif air_quality_status == "MODERATE":
            return "LOW"
        else:
            return "HIGH"
    elif temp_status == "HIGH":
        if air_quality_status == "GOOD":
            return "LOW"
        elif air_quality_status == "MODERATE":
            return "MEDIUM"
        else:
            return "HIGH"
    else:
        return "HIGH"

def display_number(num):
    for i in range(7):
        segment_pins[i].value(segments[num][i])


def print_dashboard():
    print("\n========== SMART MALL STATUS ==========")
    print(f"Entrance State      : {'VEHICLE_DETECTED' if vehicle_detected else 'NO_VEHICLE_DETECTED'}")
    print(f"Barrier             : {'OPEN' if barrier_open else 'CLOSED'}")
    print(f"Parking             : {occupancy} / {max_capacity}")
    print(f"Temperature         : {temperature:.1f}C ({temp_status})")
    print(f"Air Quality         : {air_quality_status}")
    print(f"Ambient Light       : {light_status}")
    print(f"Parking Lights      : {'ON' if parking_lights_on else 'OFF'}")
    print(f"Ventilation         : {vent_level}")
    print(f"Safety Level        : {safety_level}")
    print("=========================================\n")

def print_emergency_dashboard():
    print("\n********** EMERGENCY **********")
    print(f"Safety Level        : {safety_level}")
    print(f"Temperature         : {temp_status}")
    print(f"Air Quality         : {air_quality_status}")
    print(f"Parking             : {occupancy} / {max_capacity}")
    print(f"Barrier             : {'OPEN' if barrier_open else 'CLOSED'}")
    print("*********************************\n")


def evaluate_safety():
    global hazard_temp, hazard_air, hazard_occupancy
    global active_hazard_count, safety_level, prev_safety_level

    hazard_temp = (temp_status == "CRITICAL")
    hazard_air = (air_quality_status == "POOR")
    hazard_occupancy = (occupancy >= 6)

    active_hazard_count = sum([hazard_temp, hazard_air, hazard_occupancy])

    if active_hazard_count == 0:
        safety_level = "NORMAL"
    elif active_hazard_count == 1:
        safety_level = "WARNING"
    else:
        safety_level = "EMERGENCY"

    if safety_level != prev_safety_level:
        print(f"SAFETY_LEVEL={safety_level}")
        if hazard_temp:
            print("HAZARD=CRITICAL_TEMPERATURE")
        if hazard_air:
            print("HAZARD=POOR_AIR_QUALITY")
        if hazard_occupancy:
            print("HAZARD=PARKING_NEAR_OR_AT_MAX_CAPACITY")

        if safety_level == "EMERGENCY":
            print_emergency_dashboard()

        prev_safety_level = safety_level


def update_safety_outputs(current_time):
    global led_state_on, last_led_toggle_time
    global buzzer_state_on, last_buzzer_toggle_time

    if safety_level == "NORMAL":
        np[0] = (0, 20, 0)  
        np.write()
        buzzer_pin.off()
        led_state_on = False
        buzzer_state_on = False

    elif safety_level == "WARNING":
        np[0] = (20, 20, 0) 
        np.write()
        buzzer_pin.off()
        led_state_on = False
        buzzer_state_on = False

    else:  
        if time.ticks_diff(current_time, last_led_toggle_time) >= LED_TOGGLE_INTERVAL:
            last_led_toggle_time = current_time
            led_state_on = not led_state_on
            np[0] = (20, 0, 0) if led_state_on else (0, 0, 0)
            np.write()

        buzzer_interval = BUZZER_ON_INTERVAL if buzzer_state_on else BUZZER_OFF_INTERVAL
        if time.ticks_diff(current_time, last_buzzer_toggle_time) >= buzzer_interval:
            last_buzzer_toggle_time = current_time
            buzzer_state_on = not buzzer_state_on
            if buzzer_state_on:
                buzzer_pin.on()
            else:
                buzzer_pin.off()


set_servo_angle(90)

while True:
    current_time = time.ticks_ms()

    display_number(occupancy)
    clk_state = encoder_clk.value()

    if clk_state != last_clk:
        if time.ticks_diff(current_time, last_encoder_time) > 50:

            if encoder_dt.value() != clk_state:
                if occupancy < max_capacity:
                    occupancy += 1
                    print("VEHICLE_ENTERED")
                    print("PARKING_COUNT:", occupancy, "/", max_capacity)
            else:
                if occupancy > 0:
                    occupancy -= 1
                    print("VEHICLE_EXITED")
                    print("PARKING_COUNT:", occupancy, "/", max_capacity)

            last_encoder_time = current_time

    last_clk = clk_state

    motion = pir_sensor.value()

    if motion == 1 and last_motion == 0:
        motion_detected = True
    last_motion = motion

    if time.ticks_diff(current_time, last_sub1_time) >= 200:
        last_sub1_time = current_time

        trigger_pin.off()
        time.sleep_us(2)
        trigger_pin.on()
        time.sleep_us(10)
        trigger_pin.off()

        duration = machine.time_pulse_us(echo_pin, 1, 30000)
        if duration > 0:
            distance = (duration * 0.0343) / 2
            if distance > 100:
                waiting_for_vehicle_to_leave = False

            if distance > 0 and distance <= 400:
                if distance <= 100:
                    valid_distance_count += 1
                else:
                    valid_distance_count = 0
                    vehicle_detected = False
                    access_denied = False

                if valid_distance_count == 2 and not barrier_open and not waiting_for_vehicle_to_leave:
                    vehicle_detected = True
                    if occupancy < max_capacity:
                        set_servo_angle(0)
                        barrier_open = True
                        barrier_open_time = current_time
                        print("VEHICLE_DETECTED")
                        print("ACCESS_GRANTED")
                        print("BARRIER=OPEN")
                    else:
                        valid_distance_count = 0

                if barrier_open and (occupancy == max_capacity or valid_distance_count < 2):
                    set_servo_angle(90)
                    barrier_open = False
                    valid_distance_count = 0
                    print("BARRIER=CLOSED")

                if valid_distance_count == 2 and occupancy == max_capacity and not access_denied:
                    vehicle_detected = True
                    print("VEHICLE_DETECTED")
                    print("ACCESS_DENIED")
                    access_denied = True
    
    if barrier_open and time.ticks_diff(current_time, barrier_open_time) >= 30000:
        set_servo_angle(90)
        barrier_open = False
        valid_distance_count = 0
        waiting_for_vehicle_to_leave = True

    if time.ticks_diff(current_time, last_sub3_time) >= 500:
        last_sub3_time = current_time
        try:
            dht_sensor.measure()
            temperature = dht_sensor.temperature()
            light_level = ldr_adc.read()

            gas_readings.append(mq_adc.read())

            if len(gas_readings) > 5:
                gas_readings.pop(0)

            gas_level_avg = sum(gas_readings) / len(gas_readings)

            if gas_level_avg < 1200:
                air_quality_status = "GOOD"
            elif gas_level_avg < 2200:
                air_quality_status = "MODERATE"
            else:
                air_quality_status = "POOR"
            
            if temperature < 35.0:
                temp_status = "NORMAL"
            elif temperature < 45.0:
                temp_status = "HIGH"
            else:
                temp_status = "CRITICAL"

            if light_level < 1000:
                light_status = "BRIGHT"
            elif light_level < 2000:
                light_status = "DIM"
            else:
                light_status = "DARK"

            if temp_status != prev_temp_status or air_quality_status != prev_air_quality_status:
                vent_level = calculate_vent_level()
                print("VENTILATION_LEVEL:", vent_level)
                prev_temp_status = temp_status
                prev_air_quality_status = air_quality_status

        except Exception as e:
            print("Error reading sensors:", e)

    if motion_detected and (light_status == "DIM" or light_status == "DARK"):
        if not parking_lights_on:
            parking_lights_on = True
            parking_light_pin.on()
            motion_detected = False
            lights_on_until = current_time + 20000
            print("MOTION_DETECTED")
            print("PARKING_LIGHTS: ON")

    if time.ticks_diff(current_time, lights_on_until) >= 0:
        if parking_lights_on:
            parking_light_pin.off()
            parking_lights_on = False
            print("PARKING_LIGHTS: OFF")

    evaluate_safety()
    update_safety_outputs(current_time)

    if print_btn.value() == 0:
        if time.ticks_diff(current_time, last_print_btn_time) > 100:
            last_print_btn_time = current_time
            print_dashboard()