extends Node

var unit = Yau07.YaU07.new('ЯУ07')
var soc_unicast: Socket
var soc_brodcast: Socket
var ip_address: String = Constants.ADDRESSES[0][1]
var ip_port: int = Constants.ADDRESSES[0][2]
var timeout: float = Yau07.ONLINE_TIMEOUT
var last_update_time: float = 0.0
var broadcast_packet: PackedByteArray
var state = Constants.STATE.WAIT
var send_array: Array = []

signal yau_status_line(_status)  ## Вызывается когда меняется состояние связи с ячейкой
signal yau_receive(_data_from_yau)  ## 
signal yau_read_isa(_unit_isa_ports)

## Класс для отправки данных в сокет
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(sock: Socket) -> bool:  ## Приёмник
    if timeout - last_update_time > 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 == addr_receive) and (ip_port == port_receive):
                last_update_time = 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 = 0.0
    return false


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)   
    
    unit.connect('line_changed', Callable(self, 'on_line_changed'))
    unit.connect('command_fail', Callable(self, 'on_command_fail'))


func _process(delta: float) -> void:
    last_update_time += delta
    poll_receive(soc_brodcast)
    poll_receive(soc_unicast)
    state_machine()
    match unit.process(delta):
        Error.OK: soc_unicast.send_to(ip_address, ip_port, unit.tx_data.slice(0, unit.tx_len))
        Error.FAILED: print_debug('Ошибка отправки данных')


func state_machine():
    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_command_change_device(meta_device):
    ip_address = meta_device[0]
    ip_port = meta_device[1]


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')