'''
Create a Modbus TCP server (slave) which can be requested for data or set with
specific values by a client device.
'''

from test_memo import free

# system packages
import time
import network

# import modbus server classes
from tcp import ModbusTCP

# ===============================================
# connect to a network
station = network.WLAN(network.STA_IF)
if station.active() and station.isconnected():
    station.disconnect()
    time.sleep(1)
station.active(False)
time.sleep(1)
station.active(True)

# station.connect('SSID', 'PASSWORD')
station.connect('Wokwi-GUEST', '')
time.sleep(1)

while True:
    print('Waiting for WiFi connection...')
    if station.isconnected():
        print('Connected to WiFi.')
        print(station.ifconfig())
        break
    time.sleep(2)

# ===============================================
# TCP Slave setup
tcp_port = 502
local_ip = station.ifconfig()[0]

# ModbusTCP can get TCP requests from a host device to provide/set data
server = ModbusTCP()
is_bound = False

# check whether server has been bound to an IP and port
is_bound = server.get_bound_status()

if not is_bound:
    server.bind(local_ip=local_ip, local_port=tcp_port)

letras = ["A", "B", "C", "D", "E"]
# define register values as a dictionary
register_definitions = {
    "HREGS": {
        "PlantSIMULATE": {
            "register": 0,
            "val": [0]*12,
            "key": (
                ["PM", "PP", "PA"] +
                ["Set Receta"] +
                [f"Receta Tipo {letra}" for letra in letras[1:]] +
                [f"Receta Numero {letra}" for letra in letras[1:]]
            )
        }
    },
    "IREGS": {
        "PlantSIMULATE": {
            "register": 0,
            "val": (
                [0, 0] +
                [0, 0, 0, 0, 0] +
                [1, 1, 1, 1, 1] +
                [1, 0, 0] +
                [0, 0, 0, 0, 0] +
                [0, 0, 0, 0] +
                [255] + 
                [2, 2, 4, 4] +
                [1, 3, 3, 1] +
                [0, 0, 0, 0]
            ),
            "key": (
                ["Marcha", "Emerge"] +
                [f"Reed {letra}+" for letra in letras] +
                [f"Reed {letra}-" for letra in letras] +
                [f"LED {num}" for num in range(1, 4)] +
                [f"Cilindro {letra}+" for letra in letras] +
                [f"LED {letra}" for letra in letras[1:]] +
                ["Tipo A"] +
                [f"Receta Tipo {letra}" for letra in letras[1:]] +
                [f"Receta Numero {letra}" for letra in letras[1:]] +
                [f"Display {letra}" for letra in letras[1:]]
            )
        }
    }
}

hregs_def = register_definitions["HREGS"]["PlantSIMULATE"]
iregs_def = register_definitions["IREGS"]["PlantSIMULATE"]
registers = {
    "HREGS": {},
    "IREGS": {key: val for key, val in zip(iregs_def['key'], iregs_def['val'])}
}


# leer hregs
def read_hregs():
    keys = hregs_def['key']
    hreg_dict = register_dict['HREGS']
    registers['HREGS'] = {
        key: hreg_dict[index]['val'] 
        for index, key in enumerate(keys)
    }


# escribir iregs
def write_iregs():
    keys = iregs_def['key']
    ireg_dict = register_dict['IREGS']
    iregs = registers['IREGS']
    for index, key in enumerate(keys):
        ireg_dict[index]['val'] = iregs[key]


print('Setting up registers ...')
# use the defined values of each register type provided by register_definitions
server.setup_registers(registers=register_definitions)
# alternatively use dummy default values (True for bool regs, 999 otherwise)
# server.setup_registers(registers=register_definitions, use_default_vals=True)
print('Register setup done')
print('Serving as TCP server on {}:{}'.format(local_ip, tcp_port))
register_dict = server._register_dict  # Referencia al dict real de los registros

tCiclo = 100
cuenta = 0
cuentaMax = 100

ticksIni = time.ticks_ms()
while True:
    try:
        result = server.process()
    except KeyboardInterrupt:
        print('KeyboardInterrupt, stopping TCP server...')
        break
    except Exception as e:
        print('Exception during execution: {}'.format(e))
    read_hregs()
    write_iregs()
    if cuenta % cuentaMax == 0:
        cuenta = 0
        # print(registers)
        print(free())
    cuenta += 1

    deadline = time.ticks_add(ticksIni, tCiclo)
    ticksIni = deadline
    while time.ticks_diff(deadline, time.ticks_ms()) > 0:
        pass