extends Node

var counter: int = 0
const INDEX_SIZE = 0xC


func _ready() -> void:
    pass


func _process(_delta: float) -> void:
    pass


func _enter_tree() -> void:
    # Подключаем сигналы к методам
    Network.connect('data_send', _on_data_send)
    Network.connect('data_received', _on_data_received)
    Network.connect('port_opened', _on_port_changed.bind(Color.GREEN))
    Network.connect('port_closed', _on_port_changed.bind(Color.GRAY))
    Network.connect('port_error', _on_port_changed.bind(Color.RED))


func _on_port_changed(port_name: String, color: Color) -> void:
    $manage_panel/con/ip_connect.text = port_name
    $fs_connect.self_modulate = color


func _on_data_send():
    pass


func _on_data_received(data: PackedByteArray):
    var GRP = data.decode_u8(0x0)
    var CMD = data.decode_u8(0x1)
    match CMD:
        Constants.CMD.READ_CARRIER:
            if GRP == Constants.GROUP.BASE:
                $manage_panel/get_freq/freq_ind.text = str(data.decode_u64(0xC)) + ' Гц'
        Constants.CMD.READ_ATT:
            if GRP == Constants.GROUP.RF:
                $manage_panel/get_att/att_ind.text = '-' + str(data.decode_float(0x18)) + ' dB'
        Constants.CMD.READ_GEN_STATUS:
            if GRP == Constants.GROUP.GENERATOR:
                if data.decode_u32(0xC) == 0:
                    $manage_panel/get_gen_status/status_ind.text = 'Включен'
                    $manage_panel/get_gen_status/status_ind.modulate = Color.GREEN
                else:
                    $manage_panel/get_gen_status/status_ind.text = 'Выключен'
                    $manage_panel/get_gen_status/status_ind.modulate = Color.RED
        Constants.CMD.BASE_GET_CURRENT_TEMP:
            if GRP == Constants.GROUP.BASE:
                $temp_1.text = '%.2f' % data.decode_float(0xC) + ' C°'
                $temp_2.text = str(data.decode_float(0x10)) + ' C°'
                $temp_3.text = str(data.decode_float(0x14)) + ' C°'
    $read.text = str(data.hex_encode())


func _form_packet(group, cmd, data = null):
    var packet = PackedByteArray()
    packet.resize(INDEX_SIZE)
    packet.encode_u8(0, group)
    packet.encode_u8(1, cmd)
    packet.encode_u32(4, counter)
    counter += 1
    if data:
        packet.encode_float(8, data)
    var crc = crc32(packet)
    packet.resize(INDEX_SIZE + 4)
    packet.encode_u32(INDEX_SIZE, crc)
    return packet


func start_session():
    counter = 0
    var index_size = 0xC
    var GROUP = Constants.GROUP.BASE
    var CMD = Constants.CMD.START_SESSION
    var prep_pack: PackedByteArray = PackedByteArray()
    prep_pack.resize(index_size)
    prep_pack.encode_u8(0x0, GROUP)
    prep_pack.encode_u8(0x1, CMD)
    prep_pack.encode_u32(0x4, counter)
    counter += 1
    var crc = crc32(prep_pack)
    prep_pack.resize(index_size + 4)
    prep_pack.encode_u32(index_size, crc)
    Network.command_stack.append(prep_pack)
    get_gen_state()
    get_att_batch()
    get_carrier()


func set_gen_state(button_state: bool):
    var index_size = 0x1C
    var GROUP = Constants.GROUP.GENERATOR
    var CMD = Constants.CMD.SET_GEN_STATUS
    var prep_pack: PackedByteArray = PackedByteArray()
    prep_pack.resize(index_size)
    
    prep_pack.encode_u8(0x0, GROUP)
    prep_pack.encode_u8(0x1, CMD)
    prep_pack.encode_u32(0x4, counter)
    counter += 1
    prep_pack.encode_u16(0x8, 0x0010)
    prep_pack.encode_u32(0xC, button_state) ## MODE GEN STATUS
    var crc = crc32(prep_pack)
    prep_pack.resize(index_size + 4)
    prep_pack.encode_u32(index_size, crc)
    
    Network.command_stack.append(prep_pack)
    get_gen_state()


func set_carrier(wr_freq):
    var index_size = 0x1C
    var GROUP = Constants.GROUP.BASE
    var CMD = Constants.CMD.SET_CARRIER
    var prep_pack: PackedByteArray = PackedByteArray()
    prep_pack.resize(index_size)
    
    prep_pack.encode_u8(0x0, GROUP)
    prep_pack.encode_u8(0x1, CMD)
    prep_pack.encode_u32(0x4, counter)
    counter += 1
    prep_pack.encode_u16(0x8, 0x10)
    prep_pack.encode_u64(0xC, wr_freq) ## uint64_t freq low dword/high dword
    var crc = crc32(prep_pack)
    prep_pack.resize(index_size + 4)
    prep_pack.encode_u32(index_size, crc)
    
    Network.command_stack.append(prep_pack)


func set_att_batch(att):
    var index_size = 0x1C
    var GROUP = Constants.GROUP.RF
    var CMD = Constants.CMD.SET_ATT
    var prep_pack: PackedByteArray = PackedByteArray()
    prep_pack.resize(index_size)
    
    prep_pack.encode_u8(0x0, GROUP)
    prep_pack.encode_u8(0x1, CMD)
    prep_pack.encode_u32(0x4, counter)
    counter += 1
    prep_pack.encode_u16(0x8, 0x10)
    prep_pack.encode_float(0x18, att)

    var crc = crc32(prep_pack)
    prep_pack.resize(index_size + 4)
    prep_pack.encode_u32(index_size, crc)
    
    Network.command_stack.append(prep_pack)


func get_carrier():
    var packet = _form_packet(Constants.GROUP.BASE, Constants.CMD.READ_CARRIER)
    Network.command_stack.append(packet)


func get_att_batch():
    var packet = _form_packet(Constants.GROUP.RF, Constants.CMD.READ_ATT)
    Network.command_stack.append(packet)
    

func get_gen_state():
    var packet = _form_packet(Constants.GROUP.GENERATOR, Constants.CMD.READ_GEN_STATUS)
    Network.command_stack.append(packet)


func base_get_current_temp():
    var packet = _form_packet(Constants.GROUP.BASE, Constants.CMD.BASE_GET_CURRENT_TEMP)
    Network.command_stack.append(packet)


func crc32(data: PackedByteArray) -> int:
    var crc = Constants.INIT
    for byte in data:
        var index = (crc ^ byte) & 0xFF
        crc = (Constants.CRC32_TABLE[index] ^ (crc >> 8)) & 0xFFFFFFFF
    # Возвращаем только последние 4 байта в обратном порядке
    var final_crc = crc ^ Constants.FINAL_XOR_VALUE
    return final_crc


func _on_send_pressed() -> void:
    get_carrier()


func _on_get_att() -> void:
    get_att_batch()


func _on_start():
    #if ServerNode.connect_fs():
    start_session()
    base_get_current_temp()


func _on_get_status(toggled_btn):
    var inverted_state = not toggled_btn
    set_gen_state(inverted_state)
    get_gen_state()


func _on_set_ferq():
    var freq = int($set_space/write_to_set_freq.get_text()) * 1_000_000
    set_carrier(freq)


func _on_set_att():
    var att = float($set_space/write_to_set_att.get_text())
    set_att_batch(att)