---

# ==============================================================================
# ИМПОРТ СТАНДАРТНЫХ И ВНЕШНИХ БИБЛИОТЕК
# ==============================================================================
import random
import time
from machine import Pin, SPI, PWM, time_pulse_us
import bluetooth
from ble_simple_peripheral import BLESimplePeripheral
import dht

try:
    from ili9341 import Display, color565
    TEXT_LIB_AVAILABLE = True
except ImportError:
    TEXT_LIB_AVAILABLE = False
    print("Внимание: Библиотека ili9341.py не найдена. Текст выводиться не будет.")


# ==============================================================================
# БЛОК 1: БЫСТРЫЙ ДРАЙВЕР ДЛЯ АНИМАЦИЙ (ILI9341Direct)
# ==============================================================================
class ILI9341Direct:
    """
    Сверхбыстрый драйвер для вывода 1-битных анимаций.
    Работает напрямую с регистрами дисплея.
    """
    def __init__(self, spi, cs_pin, dc_pin, rst_pin):
        self.spi = spi
        self.cs = Pin(cs_pin, Pin.OUT)
        self.dc = Pin(dc_pin, Pin.OUT)
        self.rst = Pin(rst_pin, Pin.OUT)
        self.reset()
        self.init_display()

    def reset(self):
        """Аппаратный сброс дисплея."""
        self.rst.value(0)
        time.sleep_ms(50)
        self.rst.value(1)
        time.sleep_ms(100)

    def write_cmd(self, cmd):
        """Отправка команды в дисплей."""
        self.dc.value(0)
        self.cs.value(0)
        self.spi.write(bytearray([cmd]))
        self.cs.value(1)

    def write_data(self, data):
        """Отправка данных в дисплей."""
        self.dc.value(1)
        self.cs.value(0)
        self.spi.write(data)
        self.cs.value(1)

    def init_display(self):
        """Инициализация дисплея базовыми командами."""
        self.write_cmd(0x01)
        time.sleep_ms(100)
        self.write_cmd(0x11)
        time.sleep_ms(120)
        self.write_cmd(0x3A)
        self.write_data(b'\x55')
        self.write_cmd(0x36)
        self.write_data(b'\x28')
        self.write_cmd(0x29)
        time.sleep_ms(50)

    def set_window(self, x0, y0, x1, y1):
        """Установка области отрисовки."""
        self.write_cmd(0x2A)
        self.write_data(bytes([(x0 >> 8) & 0xFF, x0 & 0xFF, (x1 >> 8) & 0xFF, x1 & 0xFF]))
        self.write_cmd(0x2B)
        self.write_data(bytes([(y0 >> 8) & 0xFF, y0 & 0xFF, (y1 >> 8) & 0xFF, y1 & 0xFF]))
        self.write_cmd(0x2C)

    def clear(self, color=0x0000):
        """Полная очистка экрана."""
        self.set_window(0, 0, 319, 239)
        row_buf = color.to_bytes(2, 'big') * 320
        for _ in range(240):
            self.write_data(row_buf)


# ==============================================================================
# БЛОК 2: ДЕКОДЕР КАРТИНОК (VIPER)
# ==============================================================================
@micropython.viper
def decode_chunk_normal(raw_ptr: ptr8, rgb_ptr: ptr8, num_bytes: int, fg_h: int, fg_l: int, bg_h: int, bg_l: int):
    out_idx = 0
    for i in range(num_bytes):
        b = raw_ptr[i]
        for bit in range(7, -1, -1):
            if (b >> bit) & 1:
                rgb_ptr[out_idx] = fg_h
                rgb_ptr[out_idx + 1] = fg_l
            else:
                rgb_ptr[out_idx] = bg_h
                rgb_ptr[out_idx + 1] = bg_l
            out_idx += 2


# ==============================================================================
# БЛОК 3: ФУНКЦИЯ ПРОИГРЫВАНИЯ АНИМАЦИИ
# ==============================================================================
def play_animation(tft, filename, width=240, height=240, fps=30, fg_color=0xFFFF, bg_color=0x0000):
    """Воспроизводит бинарный файл как анимацию."""
    bytes_per_row = width // 8
    frame_bytes = bytes_per_row * height
    raw_buf = bytearray(frame_bytes)
    chunk_rows = 20
    chunk_raw_bytes = bytes_per_row * chunk_rows
    chunk_rgb = bytearray(width * chunk_rows * 2)

    fg_h = (fg_color >> 8) & 0xFF
    fg_l = fg_color & 0xFF
    bg_h = (bg_color >> 8) & 0xFF
    bg_l = bg_color & 0xFF

    x_offset = (320 - width) // 2
    y_offset = (240 - height) // 2 - 10
    
    delay_ms = int(1000 / fps) if fps > 0 else 0

    try:
        with open(filename, 'rb') as f:
            while True:
                read_bytes = f.readinto(raw_buf)
                if read_bytes < frame_bytes:
                    break
                
                t_start = time.ticks_ms()
                tft.set_window(x_offset, y_offset, x_offset + width - 1, y_offset + height - 1)
                
                for offset in range(0, frame_bytes, chunk_raw_bytes):
                    chunk_mem = memoryview(raw_buf)[offset : offset + chunk_raw_bytes]
                    decode_chunk_normal(chunk_mem, chunk_rgb, chunk_raw_bytes, fg_h, fg_l, bg_h, bg_l)
                    tft.write_data(chunk_rgb)
                
                if delay_ms > 0:
                    elapsed = time.ticks_diff(time.ticks_ms(), t_start)
                    sleep_time = delay_ms - elapsed
                    if sleep_time > 0:
                        time.sleep_ms(sleep_time)
    except OSError:
        print(f"Файл {filename} не найден")


# ==============================================================================
# БЛОК 4: МАШИНА СОСТОЯНИЙ (STATE MACHINE)
# ==============================================================================
# Определяем возможные состояния робота
STATE_IDLE = 0         # Стоим, ждем.
STATE_MOVING = 1       # Едем.
STATE_LOOKING = 2      # Крутим головой.
STATE_EMERGENCY = 3    # Экстренный разворот.

# ==============================================================================
# БЛОК 5: ГЛАВНЫЙ КЛАСС УПРАВЛЕНИЯ (ROBOT CONTROLLER)
# ==============================================================================
class RobotController:
    """
    Управляет всем железом, используя строгую машину состояний.
    Это гарантирует, что робот не начнет новое действие, пока не закончит старое.
    """
    def __init__(self):
        # Настройка пинов дисплея
        self.spi = SPI(2, baudrate=40000000, sck=Pin(18), mosi=Pin(23), miso=Pin(19))
        self.tft = ILI9341Direct(self.spi, cs_pin=5, dc_pin=2, rst_pin=4)
        self.tft.clear(0x0000)
        
        self.display = None
        if TEXT_LIB_AVAILABLE:
            try:
                self.display = Display(self.spi, dc=Pin(2), cs=Pin(5), rst=Pin(4), width=320, height=240, rotation=90)
            except:
                pass
                
        # Настройка периферии
        self.servo = PWM(Pin(25), freq=50)
        self.dht_sensor = dht.DHT11(Pin(33))
        self.trig = Pin(16, Pin.OUT)
        self.echo = Pin(35, Pin.IN)
        
        # Моторы
        self.M_A_1A = Pin(26, Pin.OUT)
        self.M_A_1B = Pin(27, Pin.OUT)
        self.M_B_1A = Pin(13, Pin.OUT)
        self.M_B_1B = Pin(14, Pin.OUT)
        
        # Переменные для работы
        self.current_state = STATE_IDLE
        self.state_timer = time.ticks_ms()
        self.action_timer = 0
        self.last_distance = 999
        self.last_dht_time = time.ticks_ms()
        
        # Генерация первого случайного времени
        self.wait_time = random.randint(10, 17) * 1000
        
        # Флаги
        self.looked_around = False
        self.has_blinked = False
        self.action_type = ''

    def set_servo_angle(self, angle):
        duty = int(4000 + (angle / 180) * 4000)
        self.servo.duty_u16(duty)

    def measure_distance(self):
        self.trig.value(0)
        time.sleep_us(2)
        self.trig.value(1)
        time.sleep_us(10)
        self.trig.value(0)
        try:
            duration = time_pulse_us(self.echo, 1, 30000)
            if duration > 0:
                return (duration * 0.0343) / 2
            return 999
        except OSError:
            return 999

    def check_edge(self):
        dist = self.measure_distance()
        # Если расстояние было маленьким, а стало большим - это обрыв
        if self.last_distance < 10 and dist > 20:
            return True
        self.last_distance = dist
        return False

    def stop_motors(self):
        self.M_A_1A.value(0)
        self.M_A_1B.value(0)
        self.M_B_1A.value(0)
        self.M_B_1B.value(0)

    def move_forward(self):
        self.M_A_1A.value(1)
        self.M_A_1B.value(0)
        self.M_B_1A.value(1)
        self.M_B_1B.value(0)

    def move_backward(self):
        self.M_A_1A.value(0)
        self.M_A_1B.value(1)
        self.M_B_1A.value(0)
        self.M_B_1B.value(1)

    def turn_left(self):
        self.M_A_1A.value(0)
        self.M_A_1B.value(1)
        self.M_B_1A.value(1)
        self.M_B_1B.value(0)

    def turn_right(self):
        self.M_A_1A.value(1)
        self.M_A_1B.value(0)
        self.M_B_1A.value(0)
        self.M_B_1B.value(1)

    def turn_around_180(self):
        self.turn_left()
        time.sleep(0.7)
        self.stop_motors()
        
    def update_display_text(self, t, h):
        if self.display:
            self.display.fill_rectangle(0, 220, 320, 20, color565(0, 0, 0)) 
            self.display.draw_text8x8(10, 225, f"T: {t}C  H: {h}%", color565(255, 255, 255), color565(0,0,0), 0)

    def show_text_on_screen(self, text):
        if self.display:
            self.display.fill_rectangle(0, 20, 320, 240, color565(0, 0, 0))
            self.display.draw_text8x8(10, 100, text, color565(255, 255, 255), color565(0,0,0), 0)

    def execute_emergency(self):
        """Экстренная остановка и разворот."""
        print("!!! КРАЙ СТОЛА !!!")
        self.stop_motors()
        self.turn_around_180()
        self.move_forward()
        time.sleep(1.5)
        self.stop_motors()
        
        # Переходим в состояние ожидания и генерируем НОВОЕ время
        self.current_state = STATE_IDLE
        self.state_timer = time.ticks_ms()
        self.wait_time = random.randint(10, 17) * 1000
        self.looked_around = False
        self.has_blinked = False

    def start_new_cycle(self):
        """Начинает новый цикл: генерирует время и сбрасывает флаги."""
        self.wait_time = random.randint(10, 17) * 1000
        self.state_timer = time.ticks_ms()
        self.current_state = STATE_IDLE
        self.looked_around = False
        self.has_blinked = False
        self.action_type = ''

    def run(self):
        print("Робот LOIK запущен! (Режим State Machine)")
        
        while True:
            now = time.ticks_ms()

            # --- 1. Обновление DHT11 (Фоновый процесс) ---
            if time.ticks_diff(now, self.last_dht_time) > 3000:
                try:
                    self.dht_sensor.measure()
                    t = self.dht_sensor.temperature()
                    h = self.dht_sensor.humidity()
                    self.update_display_text(t, h)
                except OSError:
                    pass
                self.last_dht_time = now

            # --- 2. ГЛОБАЛЬНАЯ ПРОВЕРКА КРАЯ (Высший приоритет) ---
            # Если мы не в состоянии экстренной остановки, проверяем датчик
            if self.current_state != STATE_EMERGENCY:
                if self.check_edge():
                    self.execute_emergency()
                    continue # Пропускаем всё остальное, начинаем цикл заново

            # --- 3. МАШИНА СОСТОЯНИЙ ---
            
            # --- СОСТОЯНИЕ: ОЖИДАНИЕ ---
            if self.current_state == STATE_IDLE:
                elapsed = time.ticks_diff(now, self.state_timer)
                
                # 3.1. Моргание раз в 10 секунд
                if elapsed >= 10000 and not self.has_blinked:
                    print("[IDLE] Моргаем...")
                    play_animation(self.tft, 'BLINK.bin', fps=30)
                    self.has_blinked = True
                
                # 3.2. Осмотр ровно на 10-й секунде
                if elapsed >= 10000 and not self.looked_around:
                    wait_seconds = self.wait_time // 1000
                    if wait_seconds > 14:
                        print(f"[IDLE] Осматриваемся (ждем {wait_seconds} сек)...")
                        self.set_servo_angle(180); time.sleep(2)
                        self.set_servo_angle(0); time.sleep(4)
                        self.set_servo_angle(90); time.sleep(1)
                    self.looked_around = True
                
                # 3.3. Начало движения (если время вышло)
                if elapsed >= self.wait_time:
                    print(f"[IDLE] Время вышло. Начинаем движение.")
                    # Выбираем случайное действие
                    action = random.choice(['forward', 'forward', 'forward', 'left', 'right'])
                    duration = random.uniform(1.0, 2.5) 
                    
                    self.action_type = action
                    self.action_timer = time.ticks_add(now, int(duration * 1000))
                    self.current_state = STATE_MOVING
                    print(f"[MOVE] Едем {action} ({duration:.1f} сек)")

            # --- СОСТОЯНИЕ: ДВИЖЕНИЕ ---
            elif self.current_state == STATE_MOVING:
                # Проверяем, не пора ли остановиться
                if time.ticks_diff(now, self.action_timer) >= 0:
                    self.stop_motors()
                    print("[MOVE] Остановка. Уходим в ожидание.")
                    # Перезапускаем цикл: новое время, ожидание.
                    self.start_new_cycle()
                else:
                    # Если еще едем, подаем команды на моторы
                    # ВАЖНО: Едем маленькими шагами, чтобы проверка края не спала!
                    if self.action_type == 'forward':
                        self.move_forward()
                        time.sleep_ms(50) # Даем время датчику
                        self.stop_motors()
                    elif self.action_type == 'left':
                        self.turn_left()
                        time.sleep_ms(50)
                        self.stop_motors()
                    elif self.action_type == 'right':
                        self.turn_right()
                        time.sleep_ms(50)
                        self.stop_motors()

            # --- 4. Фоновая задержка ---
            time.sleep_ms(10)


# ==============================================================================
# БЛОК 6: НАСТРОЙКА BLUETOOTH И ОБРАБОТЧИК КОМАНД
# ==============================================================================
robot = RobotController()
ble = bluetooth.BLE()
sp = BLESimplePeripheral(ble, name="LOIK")

def on_rx(data):
    try:
        cmd = data.decode('utf-8').strip().lower()
        print(f"BT Команда: {cmd}")
        
        # --- Принудительное движение по Bluetooth ---
        if cmd == 'y': 
            # Проверяем край перед поездкой
            if robot.check_edge():
                robot.execute_emergency()
            else:
                robot.current_state = STATE_MOVING
                robot.action_type = 'forward'
                robot.action_timer = time.ticks_add(time.ticks_ms(), 1000)
                
        elif cmd == 'o': 
            robot.move_backward(); time.sleep(1); robot.stop_motors()
        elif cmd == 'r': 
            robot.turn_left(); time.sleep(0.5); robot.stop_motors()
        elif cmd == 't': 
            robot.turn_right(); time.sleep(0.5); robot.stop_motors()
            
        # --- Шея ---
        elif cmd == 'gleft': 
            robot.set_servo_angle(180); time.sleep(1.5); robot.set_servo_angle(90)
        elif cmd == 'gright': 
            robot.set_servo_angle(0); time.sleep(1.5); robot.set_servo_angle(90)
            
        # --- Анимации ---
        elif cmd == 'w': 
            play_animation(robot.tft, 'LOVE.bin', fps=30) 
        elif cmd == 'q': 
            play_animation(robot.tft, 'hello.bin', fps=30) 
            
        # --- Текст ---
        elif cmd.startswith('text:'):
            text_to_show = cmd.split(':')[1]
            robot.show_text_on_screen(text_to_show)
        
        # --- Моргание ---
        elif cmd.startswith('blink:'):
            try:
                count = int(cmd.split(':')[1])
                for _ in range(count):
                    play_animation(robot.tft, 'blink.bin', fps=30)
                    time.sleep(0.5)
            except ValueError:
                pass
            
        elif cmd == 'stop':
            robot.stop_motors()
            robot.start_new_cycle() # Сбрасываем таймеры при остановке
            
    except Exception as e:
        print("Ошибка команды:", e)

sp.on_write(on_rx)


# ==============================================================================
# БЛОК 7: ЗАПУСК ПРОГРАММЫ
# ==============================================================================
if __name__ == "__main__":
    robot.run()