import grpc
import time
import threading
from protos import alpha_speaker_pb2
from protos import alpha_speaker_pb2_grpc


class AlphaSpeakerClient:
    def __init__(self, host='192.168.0.102', port=50051, speaker_id="alpha_smart_assistant_02"):
        self.channel = grpc.insecure_channel(f'{host}:{port}')
        self.stub = alpha_speaker_pb2_grpc.AlphaSpeakerServiceStub(self.channel)
        self.speaker_id = speaker_id
        self.error_connect = False
        self.send_initial_state = True

    def register(self, speaker_name="Альфа приватная умная колонка", speaker_type="alpha_private", firmware_version="1.0.2026"):
        """Регистрация колонки на сервере"""
        request = alpha_speaker_pb2.SpeakerRegistration(
            speaker_id=self.speaker_id,
            speaker_name=speaker_name,
            speaker_type=speaker_type,
            firmware_version=firmware_version,
            capabilities=["tts", "voice_control", "state_monitoring", "audio_streaming"],
            settings={
                 "voice": "female",
                 "language": "ru",
                 "volume": "80",
                 "audio_device": "default"
             }
        )
        try:
            response = self.stub.RegisterAlphaSpeaker(request)
            print(f"Регистрация: {response.success}, Сообщение: {response.message}")
            return response.session_id
        except grpc.RpcError as e:
            print(f"Ошибка регистрации: {e}")

    def listen_for_tts(self, callback):
        """Прослушивание потока команд TTS от HA (Server Streaming)"""
        request = alpha_speaker_pb2.StateStreamRequest(speaker_id=self.speaker_id)
        print("Ожидание TTS команд от сервера...")

        try:
            # Этот цикл будет висеть и ждать новых сообщений от сервера
            for command in self.stub.StreamTTSCommands(request):
                if command.text:
                   print(f"--- Новая команда TTS ---")
                   print(f"Текст: {command.text}")
                   print(f"Голос: {command.voice}, Громкость: {command.volume}")
                   
                   # Имитация выполнения и отправка ответа
                   self.send_tts_report(command.message_id, True)
                   callback(command.text, command.voice)
        except grpc.RpcError as e:
            print(f"Поток TTS прерван: {e}")

    def send_tts_report(self, message_id, success):
        """Отправка подтверждения о воспроизведении текста"""
        report = alpha_speaker_pb2.SpeakTextResponse(
            speaker_id=self.speaker_id,
            success=success,
            message="Воспроизведено успешно" if success else "Ошибка",
            message_id=message_id,
            timestamp=int(time.time())
        )
        self.stub.SendTTSResponse(report)

    def send_command(self, text):
        """Отправка команды в HA"""
        cmd = alpha_speaker_pb2.AlphaCommand(
            speaker_id=self.speaker_id,
            command_type="voice_action",
            voice_command=text,
            timestamp=int(time.time())
        )
        response = self.stub.SendAlphaCommand(cmd)
        print(f"Результат команды: {response.success}, {response.message}")

    def start_keepalive(self, callback, reconnect_status):
        """Фоновая отправка Ping для поддержания соединения"""
        self.error_connect = reconnect_status

        def ping_loop():
            while self.error_connect != True:
                try:
                    self.stub.KeepAlive(alpha_speaker_pb2.PingRequest(speaker_id=self.speaker_id))
                    time.sleep(15)
                except:
                    self.error_connect = True
                    callback(self.error_connect)
                    print("Ошибка отправки пинга.")
                    time.sleep(5)
                


        threading.Thread(target=ping_loop, daemon=True).start()
    
    # ВЗАИМОДЕЙСТВИЕ С УСТРОЙСТВАМИ HA (Команды)
    def control_device(self, entity_id, action, params=None):
        """Отправка команды в HA (например, включить свет)"""
        command = alpha_speaker_pb2.AlphaCommand(
            speaker_id=self.speaker_id,
            command_type=action,  # "turn_on", "set_temperature"
            entity_id=entity_id,
            #parameters=params or {},
            timestamp=int(time.time())
        )
        try:
            response = self.stub.SendAlphaCommand(command)
            print(f"HA Response: {response.message} (Event ID: {response.event_id})")
            return response
        except grpc.RpcError as e:
            print(f"Ошибка управления HA: {e}")

    #  МОНИТОРИНГ СОСТОЯНИЙ (Streaming)
    def watch_states(self, callback, filters=None, initial_state = True):
        """Получение обновлений состояний устройств из HA в реальном времени"""
        request = alpha_speaker_pb2.StateStreamRequest(
            speaker_id=self.speaker_id,
            entity_filters=filters or ["switch.dvukhkanalnoe_rele_kanal_1"],
            send_initial_state=initial_state
        )
        print("Подписка на обновления состояний HA...")
        #while self.error_connect != True:
        try:
            req = self.stub.StreamDeviceStates(request)
            initial_state = False
            for state in req:
                #print(f"Изменение: {state.friendly_name} ({state.entity_id}) -> {state.state}")
                callback(state.friendly_name, state.entity_id, state.state)
            #time.sleep(12)
        except grpc.RpcError as e:
                print(f"Поток состояний прерван: {e}")
                time.sleep(2)


    # ПОЛУЧЕНИЕ СПИСКА УСТРОЙСТВ
    def get_ha_devices(self, domains=None):
        """Запрос списка всех доступных устройств в HA"""
        req = alpha_speaker_pb2.DeviceListRequest(
            speaker_id=self.speaker_id,
            domains=domains)
        res = self.stub.GetAvailableDevices(req)
        print(f"Найдено устройств: {res.total_count}")
        for dev in res.devices:
            print(f"- {dev.friendly_name} [{dev.entity_id}]")
    

    def close(self):
        self.channel.close()

from smart_connect import AlphaSpeakerClient
from ha_device_manager import DeviceStateManager

ha_manager = DeviceStateManager()

status_smart_connect = True # Мониторим статус подключения к HA   
client = None
errors_alarm = ""

def status_connect_ac(Status: bool):
    print(Status)
    alpha_c_init()

def alpha_connect_init():
    global status_smart_connect
    global client
    global errors_alarm
    
    count_trys = 0
    
    # Безопасно закрываем старый клиент
    if client:
        try:
            client.close()
        except Exception:
            pass  # Игнорируем ошибки закрытия старого линка
        client = None
        
    try:
        # Инициализируем gRPC клиент
        client = AlphaSpeakerClient(
            host='192.168.0.102', # Адрес HomeAsisstant
            port=50051,
            speaker_id="alpha_smart_assistant_01" # Идентификатор колонки (должен быть уникальный)
        )
    
        time.sleep(2)  
        
        # Цикл регистрации
        while True:
            try:
                status_connet_grpc = client.register(
                    speaker_name="Альфа с нейрочипом",
                    speaker_type=config.prototype_name,
                    firmware_version=config.version
                )
            except Exception as register_error:
                # Если сам метод .register() падает из-за отсутствия сети
                print(f"Попытка {count_trys + 1}: Ошибка вызова register: {register_error}")
                status_connet_grpc = False

            time.sleep(3)
            count_trys += 1
            
            if status_connet_grpc or count_trys >= 50: 
                break
                
        # Запускаем пинг в фоне или обрабатываем ошибку
        if status_connet_grpc:
            status_smart_connect = True  # Флаг успеха
            client.start_keepalive(status_connect_ac, False)
        else:
            status_smart_connect = False
            print("Ошибка: не удалось зарегистрироваться на gRPC сервере за 50 попыток")
            errors_alarm += "Ошибка подключения к Альфа коннект; "
    
    except Exception as e: # Перехватываем только системные исключения, сохраняя Ctrl+C
        print(f"Критическая ошибка инициализации умного дома: {e}")
        errors_alarm += f"Ошибка подключения к умному дому ({e}); "
        status_smart_connect = False


# Функция-фидбека TTS
def say_tts(phrase: str, voice: str):
    if phrase:
        if voice == "default":
            va_speak(phrase)
        else:
            va_speak(phrase, voice)

def tts_worker():
    client.listen_for_tts(callback=say_tts)

def ha_dev_status(frandly_name, devices, status):
    if devices:
        print(f"{frandly_name} {devices}, {status}")
        ha_manager.check_and_update(devices, status)
        print(ha_manager.get_state(devices))


def alpha_c_init():
    alpha_connect_init()

    if status_smart_connect:
        # Получаем статусы устройств
        # Запускаем наш воркер в отдельном потоке
        tts_thread = threading.Thread(target=tts_worker, daemon=True)
        tts_thread.start()

        # Запускаем воркер для получение статуса в отдельном потоке
        ha_states_thread = threading.Thread(target=get_ha_states, daemon=True)
        ha_states_thread.start()
        # Отправляем тестовую команду в Home Assistant
        client.send_command("Alpha is live!")

def get_ha_states():
    print("Чтение статусов: ")
    # Подписка на обновление датчиков, переключатели и т.п. (устройсвт HA)
    client.watch_states(filters=["light.", "switch.", "sensor.meteostantsiia", "button."], callback=ha_dev_status, initial_state=True)
    time.sleep(2)
    client.watch_states(filters=["light.", "switch.", "sensor.meteostantsiia", "button."], callback=ha_dev_status, initial_state=False)

alpha_c_init()

class DeviceStateManager:
    def __init__(self):
        # Инициализируем словарь для хранения состояний устройств
        self.state = {}
    
    def update_state(self, key, value):
        """Обновляет состояние устройства по ключу"""
        old_value = self.state.get(key)
        self.state[key] = value
        
        if old_value is not None:
            print(f"Обновлено: {key}: {old_value} -> {value}")
        else:
            print(f"Добавлено: {key}: {value}")
    
    def get_state(self, key):
        """Возвращает текущее состояние устройства по ключу"""
        return self.state.get(key, None)
    
    def add_data(self, data_list):
        """Добавляет или обновляет данные из списка кортежей (ключ, значение)"""
        for key, value in data_list:
            self.update_state(key, value)
    
    def get_all_states(self):
        """Возвращает все текущие состояния в виде списка кортежей"""
        return [(k, v) for k, v in self.state.items()]
    
    def check_and_update(self, key, new_value):
        """
        Проверяет наличие ключа и обновляет его значение.
        Если ключа нет - добавляет его.
        
        Args:
            key: ключ устройства
            new_value: новое значение
        
        Returns:
            tuple: (old_value, was_updated)
                   old_value: старое значение или None если ключа не было
                   was_updated: True если ключ существовал, False если добавлен новый
        """
        old_value = self.state.get(key)
        was_updated = old_value is not None
        
        self.state[key] = new_value
        
        if was_updated:
            print(f"Ключ '{key}' обновлен: {old_value} -> {new_value}")
        else:
            print(f"Ключ '{key}' добавлен: {new_value}")
        
        return old_value, was_updated
    
    def check_exists(self, key):
        """Проверяет наличие ключа в менеджере состояний"""
        exists = key in self.state
        if exists:
            print(f"Ключ '{key}' существует: {self.state[key]}")
        else:
            print(f"Ключ '{key}' не существует")
        return exists
    
    def remove_state(self, key):
        """Удаляет ключ из менеджера состояний"""
        if key in self.state:
            value = self.state.pop(key)
            print(f"Ключ '{key}' удален (было: {value})")
            return value
        else:
            print(f"Ключ '{key}' не найден для удаления")
            return None

Теперь «Альфа» может в реальном времени напрямую получать статусы устройств, без создания дополнительных сценариев в Home Assistant.Теперь «Альфа» может в реальном времени напрямую получать статусы устройств, без создания дополнительных сценариев в Home Assistant.

import random


def meteo():
    led_on()
    try:
        # Список приветственных фраз
        start_phrases = [
            'На свя+зи ваш метеоролог!',
            'Данные вашей метеостанции.',
            'Прослушайте метеосводку.',
            'Вот данные с вашей метеостанции!'
        ]

        # Инициализируем текст случайным приветствием
        speech = random.choice(start_phrases) + " ...."

        # Получаем данные датчиков и приводим к числу с плавающей точкой
        temp = float(ha_manager.get_state('sensor.meteostantsiia_temperatura_2'))
        hum = float(ha_manager.get_state('sensor.meteostantsiia_vlazhnost_2'))
        pres = float(ha_manager.get_state('sensor.meteostantsiia_atmosfernoe_davlenie_2'))
        v_bat = float(ha_manager.get_state('sensor.meteostantsiia_zariad_batarei_2'))

        # Словари единиц измерения для функции decimal2text
        units_f = (('целая', 'целых', 'целых'), 'f')
        units_m = (('процент', 'процента', 'процентов'), 'm')
        
        deg_exp = (('сотая градуса', 'сотых градуса', 'сотых градусов'), 'f')
        mm_exp = (('сотая миллиметра', 'сотых миллиметров', 'сотых миллиметров'), 'f')
        volt_exp = (('сотая вольта', 'сотых вольта', 'сотых вольт'), 'f')

        # Формируем озвучку температуры
        speech += " Температура воздуха: "
        speech += decimal2text(temp, int_units=units_f, exp_units=deg_exp)
        speech += " цельсия. "

        # Формируем озвучку влажности
        speech += "  Относительная влажность: "
        speech += num2text(hum, units_m)

        # Формируем озвучку давления
        speech += "... Атмосферное давление: "
        speech += decimal2text(pres, int_units=units_f, exp_units=mm_exp)
        speech += " ртутного столба. "

        # Формируем озвучку заряда батареи
        speech += ".... Заряд батареи метеостанции: "
        speech += decimal2text(v_bat, int_units=units_f, exp_units=volt_exp)
        speech += " "

        # Отправляем итоговый текст в голосовой ассистент
        va_speak(speech)

        # Сохраняем
        global last_speech
        last_speech = speech

    except Exception as e:
        print(f"Ошибка в meteo: {e}")
        va_speak("Кажется я глюкнула! Возникла ошибка подключения к умному дому!")