extends Node2D

var TableNode = preload("res://table/node.tscn")

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

var node_select: Node
var timer = Timer.new()
var soc_unicast: Socket = Socket.new()
var soc_brodcast: Socket = Socket.new()
var unit = yau07.YaU07.new('ЯУ07')
var state: int = 0                  # Флаг для машины состояния
var flag_online: bool = false       # Флаг для подключения
var flag_interval: bool = false     # Флаг для включения непрерывной передачи с интервалом
var ports_wr: Dictionary   # Словарь с портами для записи
var port_select: int = Constants.BASE_ADDR  # Выбранный порд для чтения/записи
var port: int
var dt: float      # Дельта
var address: String
var rx_data: PackedByteArray             # Буфер принятый
var addr_receive: String                 # Адрес обращения к ПРД                       
var port_receive: int                    # Порт обращения к ПРД
var ROWS_REGS_DATA: Array = [
                    [TableNode, TableNode, TableNode, TableNode, TableNode],
                    [TableNode, TableNode, TableNode, TableNode, TableNode],
                    [TableNode, TableNode, TableNode, TableNode, TableNode]]


func _ready():
    self.add_child(timer)
    timer.connect('timeout', Callable(self, 'on_timer'))
    # Таблица 1
    node_select = $scroll1/table1
    draw_tabl(node_select, ROWS_REGS_DATA, ROWS_REGS_DATA.size())
    node_select.set_columns_min_size([250, 150, 150, 200, 150])
    node_select.set_node_text(0, 0, 'НЕТ СВЯЗИ С ЯУ-07')
    node_select.set_node_text(1, 0, '  IP-АДРЕС')
    node_select.set_node_text(2, 0, '10.1.1.70')
    node_select.set_node_text(3, 0, '  IP-ПОРТ')
    node_select.set_node_text(4, 0, '50070')
    node_select.set_node_text(0, 1, 'ПОРТ ЯЧЕЙКИ (hex)')
    node_select.set_node_text(1, 2, 'ИНТЕРВАЛ')

    # Поле для ввода (запись IP-адреса)
    var edit_ip = node_select.get_node2(2, 0)
    edit_ip.editable = true
    edit_ip.placeholder_text = 'Ввод значения'
    var edit_port = node_select.get_node2(4, 0)
    edit_port.editable = true
    edit_port.placeholder_text = 'Ввод значения'
    
    # Поле для ввода (запись в порт)
    var edit_node = node_select.get_node2(2, 1)
    edit_node.editable = true
    edit_node.placeholder_text = 'Ввод значения'
    edit_node.connect('text_submitted', Callable(self, '_on_written_text_submitted'))
    
    # Кнопка для включения
    $Turn_on.connect('toggled', Callable(self, '_on_button_pressed'))
    
    # Поле для ввода (базовый порт)
    var edit_addr = node_select.get_node2(0, 2)
    edit_addr.editable = true
    edit_addr.placeholder_text = '%x' % port_select
    edit_addr.connect('text_submitted', Callable(self, '_on_written_addres'))
    
    # Поле для ввода (интервал непрерывной записи)
    var edit_interval = node_select.get_node2(2, 2)
    edit_interval.editable = true
    edit_interval.placeholder_text = 'Ввод значения'
    edit_interval.connect('text_submitted', Callable(self, '_on_written_interval'))
    
    # Привязка для принятия широковещательного канала
    var rc = soc_brodcast.bind(Constants.BROADCAST_PORT, '*')
    if rc != OK:
        print('Ошибка: Неудачная привязка широковещательного адреса')
    
    ports_wr[port_select] = 0
    unit.connect('line_changed', Callable(self, 'on_line_changed'))
    unit.connect('command_fail', Callable(self, 'on_command_fail'))
    unit.connect('command_done', Callable(self, 'on_command_done'))


## Рисует таблицу
func draw_tabl(tbl, row: Array, count_row: int):
    for i_row in count_row:
        tbl.add_row(row[i_row])


func poll_receive(sock: Socket, _unit, addr: String, _port: int) -> bool:  ## Приёмник
    while sock.get_available_packet_count() > 0:
        rx_data = sock.get_packet()
        addr_receive = sock.get_packet_ip()
        port_receive = sock.get_packet_port()
        if (addr == addr_receive) and (port == port_receive):
            unit.parse(rx_data)
    return false


func _process(delta):
    if flag_online:
        if flag_interval == false:
            poll_receive(soc_brodcast, unit, address, port)
            var fl_done = unit.cmd_state == unit.CmdState.DONE
            if state == 1 and fl_done:  ## Чтение из ИСА
                unit.send_isa(unit.CmdCode.READ_ISA, [port_select])
                node_select.set_node_text(3, 1, 'ПРОЧИТАНО ИЗ %x' % port_select)
                state = 2
            elif state == 2 and fl_done:  ## Запись в ИСА
                unit.send_isa(unit.CmdCode.WRITE_ISA, [port_select, ports_wr[port_select]])
                
                if unit.isa_ports.has(port_select):
                    node_select.set_node_text(4, 1, '%x' % unit.isa_ports[port_select])
                    var isa: Array
                    for i in unit.isa_ports:
                        isa.append('%x: %x' % [i, unit.isa_ports[i]])
                    node_select.set_node_text(1, 1, 'ЗАПИСАТЬ В %x' % port_select)    
                    $ISA.text = 'ISA: ' + str(isa)
                state = 1
            
            var rc = unit.process(delta)
            if rc == Error.OK:
                soc_unicast.send_to(address, port, unit.tx_data.slice(0, unit.tx_len))
    dt = delta 


func on_timer():
    if flag_online:
        if flag_interval == true:
            poll_receive(soc_brodcast, unit, address, port)
            var fl_done = unit.cmd_state == unit.CmdState.DONE
            if state == 1 and fl_done:  ## Чтение из ИСА
                unit.send_isa(unit.CmdCode.READ_ISA, [port_select, ports_wr[port_select]])
                state = 2
            elif state == 2 and fl_done:  ## Запись в ИСА
                unit.send_isa(unit.CmdCode.WRITE_ISA, [port_select, ports_wr[port_select]])
            
                if unit.isa_ports.has(port_select):
                    node_select.set_node_text(4, 1, '%x' % unit.isa_ports[port_select])
                state = 1
            var rc = unit.process(dt)
            if rc == Error.OK:
                soc_unicast.send_to(address, port, unit.tx_data.slice(0, unit.tx_len))


func on_line_changed(_unit):
    print_debug()


## Ессли отсутствует подключение к ячейке ЯУ-07
func on_command_fail(_unit):
    var line_yau07_control = node_select.get_node2(0, 0)
    line_yau07_control.text = 'НЕТ СВЯЗИ С ЯУ-07'
    line_yau07_control.modulate = Color(1, 0, 0, 1)
    flag_online = false
    soc_unicast = Socket.new()


## Индикация чтения портов
func on_command_done(_unit):
    if flag_online:
        var line_yau07_control = node_select.get_node2(0, 0)
        line_yau07_control.text = 'ЯУ-07 НА СВЯЗИ'
        line_yau07_control.modulate = Color(0, 1, 0, 1)

## Выставить адресс для записи
func _on_written_addres(write_addres):
    port_select = write_addres.hex_to_int()
    ports_wr[port_select] = 0
    node_select.set_node_text(0, 2, '%x' % port_select)


## Запись числа порт
func _on_written_text_submitted(write_addres_data):
    var is_hex = true
    for chr in write_addres_data:
        if chr.to_upper() < '0' or chr.to_upper() > 'F':
            is_hex = false
            break   
    ports_wr[port_select] = write_addres_data.hex_to_int() if is_hex else 0xffff
    state = 2  # Запись


func _on_written_interval(write_interval):
    timer.start(float(write_interval))
    flag_interval = true
    var light_interval = node_select.get_node2(1, 2)
    light_interval.modulate = Color(0, 1, 0, 1)


## Подключение
func _on_button_pressed(turn_on):
    if turn_on:
        address = node_select.get_node2(2,0).text
        port = int(node_select.get_node2(4,0).text)
        var rc = soc_unicast.bind(Constants.UNICAST_PORT, Constants.UNICAST_ADDRESS)
        if rc != OK:
            print('Ошибка: неудачная привязка адреса: ', address)
            soc_unicast = Socket.new()
            flag_online = false
        else:
            state = 1   # Чтение
            flag_online = true
    else:
        var line_yau07_control = node_select.get_node2(0, 0)
        line_yau07_control.text = 'НЕТ СВЯЗИ С ЯУ-07'
        line_yau07_control.modulate = Color(1, 0, 0, 1)
        var light_interval = node_select.get_node2(1, 2)
        light_interval.modulate = Color(0.5, 0.5, 0.5, 1)
        soc_unicast = Socket.new()
        flag_online = false
        flag_interval = false