extends Node

# ЯУ-07 Блок
var unit = Yau07.YaU07.new('ЯУ-07Б')
#var unit_fs_1 = Fs.FGOS.new()
var unit_fs_2 = Fs.FGOS.new()
var soc_unicast: Socket
var soc_brodcast: Socket
var ip_address_yau: String = Constants.ADDRESSES[0][1]
var ip_port_yau: int = Constants.ADDRESSES[0][2]
var timeout: float = Yau07.ONLINE_TIMEOUT
var last_update_time_yau07: float = 0.0
var last_update_time_fs: float = 0.0
var broadcast_packet: PackedByteArray
var state = Constants.STATE.WAIT
var send_array: Array = []

# ФС Блок
var client_fs_1: StreamPeer
var ip_fs_1: String = Constants.ADDRESSES[0][4]
var peerstream_fs_1: PacketPeer
var state_fs = Constants.STATE.IDLE
var command_stack: Array

## 2 ФС
var client_fs_2: StreamPeer
var ip_fs_2: String = Constants.ADDRESSES[0][5]
var peerstream_fs_2: PacketPeer
var state_fs_2 = Constants.STATE.IDLE
var command_stack_2: Array

# Яу-07б
signal yau_status_line(_status)  ## Вызывается когда меняется состояние связи с ячейкой
signal yau_receive(_data_from_yau)
signal yau_read_isa(_unit_isa_ports)
# ФС модуль
signal data_from_fs_1(data:PackedByteArray)
signal data_from_fs_2(data:PackedByteArray)
signal port_fs_opened_1(port_name: String)
signal port_fs_opened_2(port_name: String)
signal port_closed(port_name: String)
signal port_error(error_str: String)


## Класс для отправки данных в сокет
class Socket extends PacketPeerUDP:
    func send_to(addr: String, port: int, data: PackedByteArray):
        self.set_dest_address(addr, port)
        self.put_packet(data)


func poll_receive_yau07(sock: Socket) -> bool:  ## Приёмник
    if timeout - last_update_time_yau07 > 0:
        while sock.get_available_packet_count() > 0:
            broadcast_packet = sock.get_packet()
            var addr_receive = sock.get_packet_ip()
            var port_receive = sock.get_packet_port()
            
            if (ip_address_yau == addr_receive) and (ip_port_yau == port_receive):
                last_update_time_yau07 = 0.0
                unit.parse(broadcast_packet)
                var data_from_yau_07 = unit.status
                emit_signal('yau_receive', data_from_yau_07)
    else:
        if sock.get_available_packet_count():
            last_update_time_yau07 = 0.0
    return false


func poll_receive_fs(client: StreamPeerTCP, peerstream: PacketPeer, ip_fs: String):
    client.poll()
    var peer = peerstream.get_stream_peer()
    # Проверяем, существует ли соединение
    if not peer:
        emit_signal("port_error", ip_fs)
        return
    # Проверяем состояние подключения
    if client.get_status() != StreamPeerTCP.STATUS_CONNECTED:
        emit_signal("port_closed", ip_fs)
        return
    
    if peer.get_available_bytes() > 0:
        var rx_data: PackedByteArray
        rx_data.append_array(peer.get_data(peer.get_available_bytes())[1])
        emit_signal("data_from_fs_1", rx_data)
        #emit_signal("data_from_fs_2", rx_data)
        emit_signal("port_fs_opened_1", ip_fs)
        if state_fs == Constants.STATE.SEND:
            state_fs = Constants.STATE.DONE


func _ready() -> void:
    # Привязка для принятия широковещательного канала
    soc_brodcast = Socket.new()
    var rc = soc_brodcast.bind(Constants.BROADCAST_PORT, '*')
    if rc != OK:
        print_debug('Ошибка: Неудачная привязка широковещательного адреса')
    
    soc_unicast = Socket.new()
    rc = soc_unicast.bind(Constants.UNICAST_PORT, Constants.UNICAST_ADDRESS)
    if rc != OK:
        print_debug('Ошибка: неудачная привязка адреса: ', ip_address_yau)   

    unit.connect('line_changed', Callable(self, 'on_line_changed'))
    unit.connect('command_fail', Callable(self, 'on_command_fail'))
    #connect_fs_1()
    connect_fs_2()
    read_port_isa([0x106, 0x108])


func _process(delta: float) -> void:

    last_update_time_yau07 += delta
    last_update_time_fs += delta
    
    if client_fs_1:
        poll_receive_fs(client_fs_1, peerstream_fs_1, ip_fs_1)
    if client_fs_2:
        poll_receive_fs_2(client_fs_2, peerstream_fs_2, ip_fs_2)
    
    poll_receive_yau07(soc_brodcast)
    poll_receive_yau07(soc_unicast)
    
    state_machine_yau07()
    #state_machine_fs()
    state_machine_fs_2()
    
    match unit.process(delta):
        Error.OK: soc_unicast.send_to(ip_address_yau, ip_port_yau, unit.tx_data.slice(0, unit.tx_len))
        Error.FAILED: print_debug('Ошибка отправки данных')


func state_machine_yau07():
    var fl_done = (unit.cmd_state == unit.CmdState.DONE or unit.cmd_state == unit.CmdState.FAIL)
    ## Режим ожидания
    match  state:
        Constants.STATE.WAIT:
            if fl_done and send_array.size():
                    state =  Constants.STATE.READ_ISA if send_array[0][0] == 'rd' else Constants.STATE.WRITE_ISA
        ## Режим чтения из ИСА
        Constants.STATE.READ_ISA:
            if fl_done:
                var ports_read = send_array.pop_front()
                unit.send_isa(unit.CmdCode.READ_ISA, ports_read[1])
                state = Constants.STATE.DONE
        ## Режим записи в ИСА
        Constants.STATE.WRITE_ISA:
            if fl_done:
                var ports_write = send_array.pop_front()
                var key = ports_write[1].keys()
                unit.send_isa(unit.CmdCode.WRITE_ISA, [key[0], ports_write[1][key[0]]])
                state = Constants.STATE.WAIT
        Constants.STATE.DONE:
            if fl_done:
                emit_signal('yau_read_isa', unit.isa_ports)
                state = Constants.STATE.WAIT


# Записать команду в ИСА 
func read_port_isa(read_ports: Array) -> void:
    send_array.append(['rd', read_ports])


# Прочитать данные из порта от ИСА 
func write_port_isa(port_isa: int, data_isa: int) -> void:
    var write_data: Dictionary = {port_isa: data_isa}
    send_array.append(['wr', write_data])


func on_line_changed(_unit) -> void:
    emit_signal('yau_status_line',  unit.online)


## Ессли отсутствует подключение к ячейке ЯУ-07
func on_command_fail(_unit) -> void:
    print_debug('Command send fail')


func on_command_change_device(meta_device):
    ip_address_yau = meta_device[0]
    ip_port_yau = meta_device[1]
    ip_fs_1 = meta_device[3]
    ip_fs_2 = meta_device[4]
    #ip_fs_3 = meta_device[5]
    #connect_fs_1()
    connect_fs_2()


func state_machine_fs():
    if client_fs_1:
        ## State fs machine
        if (state_fs == Constants.STATE.IDLE) or (state_fs == Constants.STATE.DONE):
            if command_stack:
                var pack: Array = command_stack.pop_front()
                send_fs_data_1(pack)
                state_fs = Constants.STATE.SEND


# Подключится к модулю ФС
func connect_fs_1():
    if client_fs_1:
        disconnect_fs(client_fs_1)
    
    client_fs_1 = StreamPeerTCP.new()
    peerstream_fs_1 = PacketPeerStream.new()
    var rc = client_fs_1.connect_to_host(ip_fs_1, Constants.PORT_FS)
    if rc!= Error.OK:
        emit_signal("port_error", ip_fs_1)
    else:
        peerstream_fs_1.set_stream_peer(client_fs_1)


# Отправить команду для ФС
func send_fs_data_1(data_to_sand: PackedByteArray):
    if client_fs_1.get_status() == 2:
        var peer = peerstream_fs_1.get_stream_peer()
        if peer:
            peer.put_data(data_to_sand)
            emit_signal("data_send") 


# Разорвать соединение с ФС
func disconnect_fs(client_for_leave):
    client_for_leave.disconnect_from_host()
    state_fs = Constants.STATE.IDLE
    command_stack = []

#
#func start_work_fs():
    #unit_fs_1.start_session()
    #unit_fs_1.base_get_current_temp()
#
#
#func get_fs_gen_status(state_gen):
    #unit_fs_1.set_gen_state(state_gen)
    #unit_fs_1.get_gen_state()
    #unit_fs_1.base_get_current_temp()
#
#
#func set_fs_ferq_carrier(freq: int):
    #unit_fs_1.set_carrier(freq)
    #unit_fs_1.base_get_current_temp()
    #unit_fs_1.get_carrier()
#
#
#func set_fs_attenuation(attenuation: float):
    #unit_fs_1.set_att_batch(attenuation)
    #unit_fs_1.get_att_batch()
    #unit_fs_1.base_get_current_temp()


## 2 ФС коннект
func connect_fs_2():
    if client_fs_2:
        disconnect_fs_2(client_fs_2)
    
    client_fs_2 = StreamPeerTCP.new()
    peerstream_fs_2 = PacketPeerStream.new()
    var rc = client_fs_2.connect_to_host(ip_fs_2, Constants.PORT_FS)
    if rc!= Error.OK:
        print_debug('Port error %s' % ip_fs_2)
        #emit_signal("port_error", ip_fs_2)
    else:
        peerstream_fs_2.set_stream_peer(client_fs_2)


# Разорвать соединение с ФС
func disconnect_fs_2(client_for_leave):
    client_for_leave.disconnect_from_host()
    state_fs_2 = Constants.STATE.IDLE
    command_stack_2 = []
    

# Отправить команду для ФС
func send_fs_data_2(data_to_sand: PackedByteArray):
    if client_fs_2.get_status() == 2:
        var peer = peerstream_fs_2.get_stream_peer()
        if peer:
            peer.put_data(data_to_sand)


func state_machine_fs_2():
    if client_fs_2:
        ## State fs_2 machine
        if (state_fs_2 == Constants.STATE.IDLE) or (state_fs_2 == Constants.STATE.DONE):
            if command_stack_2:
                var pack: Array = command_stack_2.pop_front()
                send_fs_data_2(pack)
                state_fs_2 = Constants.STATE.SEND


func poll_receive_fs_2(client: StreamPeerTCP, peerstream: PacketPeer, ip_fs: String):
    client.poll()
    var peer = peerstream.get_stream_peer()
    # Проверяем, существует ли соединение
    if not peer:
        emit_signal("port_error", ip_fs)
        return
    # Проверяем состояние подключения
    if client.get_status() != StreamPeerTCP.STATUS_CONNECTED:
        emit_signal("port_closed", ip_fs)
        return
    
    if peer.get_available_bytes() > 0:
        var rx_data: PackedByteArray
        rx_data.append_array(peer.get_data(peer.get_available_bytes())[1])
        emit_signal("data_from_fs_2", rx_data)
        emit_signal("port_fs_opened_2", ip_fs)
        if state_fs_2 == Constants.STATE.SEND:
            state_fs_2 = Constants.STATE.DONE


func start_work_fs_2():
    unit_fs_2.start_session()
    unit_fs_2.base_get_current_temp()


func get_fs_gen_status_2(state_gen):
    unit_fs_2.set_gen_state(state_gen)
    unit_fs_2.get_gen_state()
    unit_fs_2.base_get_current_temp()


func set_fs_ferq_carrier_2(freq: int):
    unit_fs_2.set_carrier(freq)
    unit_fs_2.base_get_current_temp()
    unit_fs_2.get_carrier()


func set_fs_attenuation_2(attenuation: float):
    unit_fs_2.set_att_batch(attenuation)
    unit_fs_2.get_att_batch()
    unit_fs_2.base_get_current_temp()