import fileinput
#import regex as re
#from regex import finditer
# We use Python3 and we had to eliminate option overlapped from finditer method of re
# As Daniel created this Python script in Python 2.7, he used overlapped, but in
# Python 3 this option was eliminated.
import re
from re import finditer
import sys
import os
import json

if (len(sys.argv) != 8):
    sys.stderr.write("E: usage: " + sys.argv[
        0] + " <input_path> <input_file> <output_path> <output_file> <normalized_Effects> <entity_path> <entity_file>\n")
    sys.stderr.flush();
    exit(2);

# LEER ARCHIVO INPUT
# Original Daniel: text_file = open( sys.argv[1], "r" )
# Original Daniel: dato = text_file.read()
# Original Daniel: text_file.close()
filename = sys.argv[2]
input_file = open(os.path.join(sys.argv[1], filename), "r")
#print("Input file: {}".format(os.path.join(sys.argv[1], sys.argv[2])))
dato = input_file.read()
input_file.close()

# Loading normalized effects
# print('Loading normalized effects...')
with open(os.path.join(sys.argv[5])) as diccFile:
    hashNormalizedEffects = json.load(diccFile)

# USING ALREADY TAGGED ENTITIES OF THE FILE (in filter sentence step)
#<entity_path> <entity_file>
# READ DICTIONARY WITH ALREADY TAGGED ENTITIES
entity_path = sys.argv[6]
entity_file = sys.argv[7]
print('Loading dictionaries with already tagged entities...')
with open(os.path.join(entity_path, entity_file)) as entFile:
    hashDicc = json.load(entFile)
print('   Loading dictionaries with already tagged entities... Done!')
# CREATE LISTS WITH ALREADY TAGGED ENTITIES OF THE FILE
regexNumFile = re.compile(r'_([0-9]+)[.-]')
result = regexNumFile.search(filename)
numFile = ""
inumFile = 0
if result:
    inumFile = int(result.group(1))
    numFile = str(inumFile)
    print("Numfile: {}".format(numFile))
else:
    print("WARNING: numfile not found in filename")

ATEREG1 = []
PTEREG1GENE = []
PTEREG1TU = []
listEffects = []

if numFile in hashDicc:
    hashTemp = hashDicc[numFile]
    # print("hashDicc[numFile]: {}".format(hashTemp))
    for k, v in hashTemp.items():
        if v == "TF":
            # print("Verifiying TF")
            if k not in ATEREG1:
                # print(" TF {}".format(k))
                ATEREG1.append(k)
        elif v == "GENE":
            if k not in PTEREG1GENE:
                PTEREG1GENE.append(k)
        elif v == "TU":
            if k not in PTEREG1TU:
                PTEREG1TU.append(k)
        elif v == "EFFECT":
            if k not in listEffects:
                listEffects.append(k)
        else:
            print("WARNING: entity not found in dictionaries")
else:
    print("WARNING: numfile not found in dictionaries")

# QUITA EXTENSION DE NOMBRE DE ARCHIVO
# Original Daniel: split_line = sys.argv[2]
output_path = sys.argv[3]
# Original Daniel: split_line = split_line[:-4]
# Original Daniel: file_name = split_line + ".a2"
input_file_name = sys.argv[2]
# Original Daniel: open( file_name , 'w').close()
file_name_entities_complete = os.path.join(output_path, "complete-ris", input_file_name[:-4] + ".a1")
file_name_interactions_complete = os.path.join(output_path, "complete-ris", input_file_name[:-4] + ".a2")
file_name_entities_incomplete = os.path.join(output_path, "incomplete-ris", input_file_name[:-4] + ".a1")
file_name_interactions_incomplete = os.path.join(output_path, "incomplete-ris", input_file_name[:-4] + ".a2")

file_name_text_complete = os.path.join(output_path, "complete-ris", input_file_name[:-4] + ".txt")
file_name_text_incomplete = os.path.join(output_path, "incomplete-ris", input_file_name[:-4] + ".txt")

open(file_name_entities_complete, 'w').close()
open(file_name_interactions_complete, 'w').close()
# Original Daniel: open( file_name , 'w').close()
open(file_name_entities_incomplete, 'w').close()
open(file_name_interactions_incomplete, 'w').close()

# declara variables
# Original Daniel: impresion = []
impresionEntities = []
impresionInteractionsComplete = []
impresionInteractionsIncomplete = []
salida_a2 = []
salida_a2_trimmed = []
salida_a2_str = []
q2line = ()
listadeRIs = []
posiblesminimos = [[], []]
posiblesmaximos = [[], []]
listasecundaria = []
listasecundaria_trimmed = []
impresionEntities = []
impresionInteractionsComplete = []
impresionInteractionsIncomplete = []

# Effects
for i in range(len(listEffects)):
    if listEffects[i] in dato:
        for match in finditer(r'\b(' + listEffects[i] + r')\b(\s\b(of|at|for)\b)', dato):  # "of","for" o "at" a la derecha de EFF
        # Original Daniel: for match in finditer(r'\b(' + listEffects[i] + r')\b(\s\b(of|at)\b)', dato,
        # Original Daniel:                       overlapped=True):  # "of" o "at" a la derecha de EFF
            spantup = match.span(1)
            # Original Daniel: a2line = ('deverbal_effect', spantup[0], spantup[1], match.group(1))
            if match.group(1).lower() in hashNormalizedEffects:
                effect = "EFFECT." + hashNormalizedEffects[match.group(1).lower()]
            else:
                effect = "EFFECT." + "deverbal_effect"
            # Original Daniel: a2line = (effect, spantup[0], spantup[1], match.group(1))
            a2line = (effect, spantup[0], spantup[1] - 1, match.group(1))
            #print("Append effect a2line: {}".format(a2line))
            salida_a2.append(a2line)
        for match in finditer(r'\b(' + listEffects[i] + r')\b(\s\bby\b)', dato):  # "by" a la derecha de EFF
            # Original Daniel: for match in finditer(r'\b(' + listEffects[i] + r')\b(\s\bby\b)', dato,
            # Original Daniel:                       overlapped=True):  # "by" a la derecha de EFF
            spantup = match.span(1)
            # Original Daniel: a2line = ('deverbal_effect', spantup[0], spantup[1], match.group(1))
            if match.group(1).lower() in hashNormalizedEffects:
                effect = "EFFECT." + hashNormalizedEffects[match.group(1).lower()]
            else:
                effect = "EFFECT." + "deverbal_effect"
            # Original Daniel: a2line = (effect, spantup[0], spantup[1], match.group(1))
            a2line = (effect, spantup[0], spantup[1] - 1, match.group(1))
            salida_a2.append(a2line)
            #print("Append effect a2line: {}".format(a2line))
        for match in finditer(r'(is\sthe\s(\S+\s){0,1})\b(' + listEffects[i] + r')\b', dato):  # "is the" 0-1 palabras a la izquierda de EFF
            # Original Daniel: for match in finditer(r'(is\sthe\s(\S+\s){0,1})\b(' + listEffects[i] + r')\b', dato,
            # Original Daniel:                   overlapped=True):  # "is the" 0-1 palabras a la izquierda de EFF
            spantup = match.span(3)
            # Original Daniel: a2line = ('deverbal_effect', spantup[0], spantup[1], match.group(3))
            if match.group(1).lower() in hashNormalizedEffects:
                effect = "EFFECT." + hashNormalizedEffects[match.group(1).lower()]
            else:
                effect = "EFFECT." + "deverbal_effect"
            # Original Daniel: a2line = (effect, spantup[0], spantup[1], match.group(3))
            a2line = (effect, spantup[0], spantup[1] - 1, match.group(3))
            salida_a2.append(a2line)
            #print("Append effect a2line: {}".format(a2line))
#print("Efectos salida_a2: {}".format(salida_a2))

# PTEREG1GENE regulados pacientes GENE
for i in range(len(PTEREG1GENE)):
    if PTEREG1GENE[i] in dato:
        # print(PTEREG1GENE[i])
        for match in finditer(r'\b(of|at|for)\b\s+(\w\s){0,1}\b(' + PTEREG1GENE[i] + r')\b', dato):  # "of", "for" o "at" 0-1 palabras a la izq de regulado
            # Original Daniel: for match in finditer(r'\b(of|at)\b\s+(\w\s){0,1}\b(' + PTEREG1GENE[i] + r')\b', dato,
            # Original Daniel:                   overlapped=True):  # "of" o "at" 0-1 palabras a la izq de regulado
            spantup = match.span(3)
            # print("match {} spantup {}".format(match.group(3), match.span(3)))
            # Original Daniel: a2line = ('regulated', spantup[0], spantup[1], match.group(3))
            a2line = ('GENE', spantup[0], spantup[1] - 1, match.group(3))
            salida_a2.append(a2line)
            # print("Append regulados a2line: {}".format(a2line))
        for match in finditer(r'\b(' + PTEREG1GENE[i] + r')\b', dato):  # regulados sin patron
            # Original Daniel: for match in finditer(r'\b(' + PTEREG1GENE[i] + r')\b', dato, overlapped=True):  # regulados sin patron
            spantup = match.span(1)
            # print("match {} spantup {}".format(match.group(1), match.span(1)))
            # Original Daniel: a2line = ('regulated', spantup[0], spantup[1], match.group(1))
            a2line = ('GENE', spantup[0], spantup[1] - 1, match.group(1))
            listasecundaria.append(a2line)
#print("Efectos regulados gene listasecundaria: {}".format(listasecundaria))

# CMC: ADDED TO SEPARTE REGULATED GENE AND TU
# PTEREG1TU regulados pacientes TU
for i in range(len(PTEREG1TU)):
    if PTEREG1TU[i] in dato:
        # print(PTEREG1TU[i])
        for match in finditer(r'\b(of|at|for)\b\s+(\w\s){0,1}\b(' + PTEREG1TU[i] + r')\b', dato):  # "of","for" o "at" 0-1 palabras a la izq de regulado
            # Original Daniel: for match in finditer(r'\b(of|at)\b\s+(\w\s){0,1}\b(' + PTEREG1TU[i] + r')\b', dato,
            # Original Daniel:                   overlapped=True):  # "of" o "at" 0-1 palabras a la izq de regulado
            spantup = match.span(3)
            # print("match: " + match.group(3))
            # Original Daniel: a2line = ('regulated', spantup[0], spantup[1], match.group(3))
            a2line = ('TU', spantup[0], spantup[1] - 1, match.group(3))
            salida_a2.append(a2line)
            # print("Append regulados a2line: {}".format(a2line))
        for match in finditer(r'\b(' + PTEREG1TU[i] + r')\b', dato):  # regulados sin patron
        # for match in finditer(r'\b(' + PTEREG1TU[i] + r')\b', dato, overlapped=True):  # regulados sin patron
            spantup = match.span(1)
            # Original Daniel: a2line = ('regulated', spantup[0], spantup[1], match.group(1))
            a2line = ('TU', spantup[0], spantup[1] - 1, match.group(1))
            listasecundaria.append(a2line)
#print("Efectos regulados tu listasecundaria: {}".format(listasecundaria))

# ATEREG1 reguladores agentes
for i in range(len(ATEREG1)):
    if ATEREG1[i] in dato:
        # print(ATEREG1[i])
        for match in finditer(r'\bby\b\s+(\w\s){0,1}\b(' + ATEREG1[i] + r')\b', dato):  # "by" 0-1 palabras a la izq de regulado
            # Original Daniel: for match in finditer(r'\bby\b\s+(\w\s){0,1}\b(' + ATEREG1[i] + r')\b', dato,
            # Original Daniel:                   overlapped=True):  # "by" 0-1 palabras a la izq de regulado
            spantup = match.span(2)
            # print("match: " + match.group(2))
            # print("match {} spantup {}".format(match.group(2), match.span(2)))
            # Original Daniel: a2line = ('regulator', spantup[0], spantup[1], match.group(2))
            a2line = ('TF', spantup[0], spantup[1] - 1, match.group(2))
            salida_a2.append(a2line)
            #print("Append regulator a2line: {}".format(a2line))
        for match in finditer(r'\b(' + ATEREG1[i] + r')\b', dato):  # reguladores sin patron
        # for match in finditer(r'\b(' + ATEREG1[i] + r')\b', dato, overlapped=True):  # reguladores sin patron
            spantup = match.span(1)
            # print("match {} spantup {}".format(match.group(1), match.span(1)))
            # Original Daniel: a2line = ('regulator', spantup[0], spantup[1], match.group(1))
            a2line = ('TF', spantup[0], spantup[1] - 1, match.group(1))
            listasecundaria.append(a2line)
            #print("Append regulator a2line: {}".format(a2line))
#print("Reguladores agentes salida_a2: {}".format(salida_a2))
#print("Reguladores agentes listasecundaria: {}".format(listasecundaria))

# Elimina etiquetados repetidos o que estan incluidos en otros
if salida_a2:
    salida_a2.sort(key=lambda tup: tup[1])
    salida_a2_trimmed.append(salida_a2[0])
    for i in range(len(salida_a2)):
        copiar = True
        for j in range(len(salida_a2_trimmed)):
            if ((salida_a2[i][1] >= salida_a2_trimmed[j][1]) and (salida_a2[i][2] <= salida_a2_trimmed[j][2])):
                copiar = False
        if copiar:
            salida_a2_trimmed.append(salida_a2[i])
if listasecundaria:
    listasecundaria.sort(key=lambda tup: tup[1])
    listasecundaria_trimmed.append(listasecundaria[0])
    for i in range(len(listasecundaria)):
        copiar = True
        for j in range(len(listasecundaria_trimmed)):
            if ((listasecundaria[i][1] >= listasecundaria_trimmed[j][1]) and (
                listasecundaria[i][2] <= listasecundaria_trimmed[j][2])):
                copiar = False
        if copiar:
            listasecundaria_trimmed.append(listasecundaria[i])
# print("Sin repeticiones salida_a2_trimmed: {}".format(salida_a2_trimmed))
#print("Sin repeticiones listasecundaria_trimmed: {}".format(listasecundaria_trimmed))

# Asigna identificadores (TX) a entidades (eff, regulador, regulado)
lastID = 0
for i in range(len(salida_a2_trimmed)):
    # if sys.argv[2].find('355') > -1:
    #    print("i : {}".format(i))
    salida_a2_trimmed[i] = list(salida_a2_trimmed[i])
    ID = "T" + str(i + 1)
    salida_a2_trimmed[i].insert(0, ID)
    lastID = i + 1
    # if sys.argv[2].find('355') > -1:
    #    print("lastID : {}".format(lastID))

for i in range(len(listasecundaria_trimmed)):
    # if sys.argv[2].find('355') > -1:
    #    print("i : {}".format(i))
    #    print("lastID : {}".format(lastID))
    listasecundaria_trimmed[i] = list(listasecundaria_trimmed[i])
    ID = "T" + str(i + 1 + lastID)
    listasecundaria_trimmed[i].insert(0, ID)

# print("Con identificadores salida_a2_trimmed: {}".format(salida_a2_trimmed))
#print("Con identificadores listasecundaria_trimmed: {}".format(listasecundaria_trimmed))

#print("salida_a2_trimmed")  #########################
#print(salida_a2_trimmed)  #########################
#print("listasecundaria_trimmed")
#print(listasecundaria_trimmed)

# Arma Interacciones Regulatorias
i = 0
while i < int(len(salida_a2_trimmed)):
    if "EFFECT" in salida_a2_trimmed[i][1]:
        # BUSCA REGULADO A LA DERECHA
        nuevaRI = [salida_a2_trimmed[i][0], "", ""]  # efecto, tema, causa
        ref = ""
        posiblesminimos = [[], []]
        j = 0
        while j < int(len(salida_a2_trimmed)):
            # Original Daniel: if ("regulated" in salida_a2_trimmed[j][1]) and (salida_a2_trimmed[i][3] < salida_a2_trimmed[j][2]):
            if ("GENE" in salida_a2_trimmed[j][1] or "TU" in salida_a2_trimmed[j][1]) and (salida_a2_trimmed[i][3] < salida_a2_trimmed[j][2]):
                posiblesminimos[0].append(salida_a2_trimmed[j][2])
                posiblesminimos[1].append(salida_a2_trimmed[j][0])
            j = j + 1
        if posiblesminimos[0]:
            refpointer = posiblesminimos[0].index(min(posiblesminimos[0]))
            ref = posiblesminimos[1][refpointer]
        # si no encuentra, BUSCA REGULADO A LA IZQUIERDA
        if not ref:
            posiblesmaximos = [[], []]
            j = 0
            while j < int(len(salida_a2_trimmed)):
                # Original Daniel: if ("regulated" in salida_a2_trimmed[j][1]) and (salida_a2_trimmed[i][2] > salida_a2_trimmed[j][3]):
                if ("GENE" in salida_a2_trimmed[j][1] or "TU" in salida_a2_trimmed[j][1]) and (salida_a2_trimmed[i][2] > salida_a2_trimmed[j][3]):
                    posiblesmaximos[0].append(salida_a2_trimmed[j][3])
                    posiblesmaximos[1].append(salida_a2_trimmed[j][0])
                j = j + 1
            if posiblesmaximos[0]:
                refpointer = posiblesmaximos[0].index(max(posiblesmaximos[0]))
                ref = posiblesmaximos[1][refpointer]
        nuevaRI[1] = ref
        # BUSCA REGULADOR A LA DERECHA
        ref = ""
        posiblesminimos = [[], []]
        j = 0
        while j < int(len(salida_a2_trimmed)):
            # Original Daniel: if ("regulator" in salida_a2_trimmed[j][1]) and (salida_a2_trimmed[i][3] < salida_a2_trimmed[j][2]):
            if ("TF" in salida_a2_trimmed[j][1]) and (salida_a2_trimmed[i][3] < salida_a2_trimmed[j][2]):
                posiblesminimos[0].append(salida_a2_trimmed[j][2])
                posiblesminimos[1].append(salida_a2_trimmed[j][0])
            j = j + 1
        if posiblesminimos[0]:
            refpointer = posiblesminimos[0].index(min(posiblesminimos[0]))
            ref = posiblesminimos[1][refpointer]
        # si no encuentra, BUSCA REGULADOR A LA IZQUIERDA
        if not ref:
            posiblesmaximos = [[], []]
            j = 0
            while j < int(len(salida_a2_trimmed)):
                # Original Daniel: if ("regulator" in salida_a2_trimmed[j][1]) and (salida_a2_trimmed[i][2] > salida_a2_trimmed[j][3]):
                if ("TF" in salida_a2_trimmed[j][1]) and (salida_a2_trimmed[i][2] > salida_a2_trimmed[j][3]):
                    posiblesmaximos[0].append(salida_a2_trimmed[j][3])
                    posiblesmaximos[1].append(salida_a2_trimmed[j][0])
                j = j + 1
            if posiblesmaximos[0]:
                refpointer = posiblesmaximos[0].index(max(posiblesmaximos[0]))
                ref = posiblesmaximos[1][refpointer]
        nuevaRI[2] = ref
        listadeRIs.append(nuevaRI)
    i = i + 1

# SEGUNDA FASE DE BUSQUEDA DE REGULADORES Y REGULADOS
i = 0
while i < int(len(listadeRIs)):
    if not listadeRIs[i][1]:  # no regulado
        ref = ""
        posiblesminimos = [[], []]
        # BUSCA REGULADO A LA DERECHA
        j = 0
        while j < int(len(listasecundaria_trimmed)):
            for k in range(len(salida_a2_trimmed)):
                if listadeRIs[i][0] == salida_a2_trimmed[k][0]:
                    ind = k
            # Original Daniel: if ("regulated" in listasecundaria_trimmed[j][1]) and (salida_a2_trimmed[ind][3] < listasecundaria_trimmed[j][2]):
            if ("GENE" in listasecundaria_trimmed[j][1] or "TU" in listasecundaria_trimmed[j][1]) and (salida_a2_trimmed[ind][3] < listasecundaria_trimmed[j][2]):
                posiblesminimos[0].append((listasecundaria_trimmed[j][2] - salida_a2_trimmed[ind][3]))
                posiblesminimos[1].append(listasecundaria_trimmed[j][0])
            j = j + 1
        # BUSCA REGULADO A LA IZQUIERDA
        j = 0
        while j < int(len(listasecundaria_trimmed)):
            for k in range(len(salida_a2_trimmed)):
                if listadeRIs[i][0] == salida_a2_trimmed[k][0]:
                    ind = k
            # Original Daniel: if ("regulated" in listasecundaria_trimmed[j][1]) and (salida_a2_trimmed[ind][2] > listasecundaria_trimmed[j][3]):
            if ("GENE" in listasecundaria_trimmed[j][1] or "TU" in listasecundaria_trimmed[j][1]) and (salida_a2_trimmed[ind][2] > listasecundaria_trimmed[j][3]):
                posiblesminimos[0].append((salida_a2_trimmed[ind][2] - listasecundaria_trimmed[j][3]))
                posiblesminimos[1].append(listasecundaria_trimmed[j][0])
            j = j + 1
        # ELIGE EL REGULADO MAS CERCANO
        if posiblesminimos[0]:
            refpointer = posiblesminimos[0].index(min(posiblesminimos[0]))
            ref = posiblesminimos[1][refpointer]
        # print(ref)
        listadeRIs[i][1] = ref
    if not listadeRIs[i][2]:  # no regulador
        ref = ""
        posiblesminimos = [[], []]
        # BUSCA REGULADO A LA DERECHA
        j = 0
        while j < int(len(listasecundaria_trimmed)):
            for k in range(len(salida_a2_trimmed)):
                if listadeRIs[i][0] == salida_a2_trimmed[k][0]:
                    ind = k
            # Original Daniel: if ("regulator" in listasecundaria_trimmed[j][1]) and (salida_a2_trimmed[ind][3] < listasecundaria_trimmed[j][2]):
            if ("TF" in listasecundaria_trimmed[j][1]) and (salida_a2_trimmed[ind][3] < listasecundaria_trimmed[j][2]):
                posiblesminimos[0].append((listasecundaria_trimmed[j][2] - salida_a2_trimmed[ind][3]))
                posiblesminimos[1].append(listasecundaria_trimmed[j][0])
            j = j + 1
        # BUSCA REGULADO A LA IZQUIERDA
        j = 0
        while j < int(len(listasecundaria_trimmed)):
            for k in range(len(salida_a2_trimmed)):
                if listadeRIs[i][0] == salida_a2_trimmed[k][0]:
                    ind = k
            # Original Daniel: if ("regulator" in listasecundaria_trimmed[j][1]) and (salida_a2_trimmed[ind][2] > listasecundaria_trimmed[j][3]):
            if ("TF" in listasecundaria_trimmed[j][1]) and (salida_a2_trimmed[ind][2] > listasecundaria_trimmed[j][3]):
                posiblesminimos[0].append((salida_a2_trimmed[ind][2] - listasecundaria_trimmed[j][3]))
                posiblesminimos[1].append(listasecundaria_trimmed[j][0])
            j = j + 1
        # ELIGE EL REGULADO MAS CERCANO
        if posiblesminimos[0]:
            refpointer = posiblesminimos[0].index(min(posiblesminimos[0]))
            ref = posiblesminimos[1][refpointer]
        # print(ref)
        listadeRIs[i][2] = ref
    i = i + 1
#print("ListadeRIs: {}".format(listadeRIs))

# Elige reguladores y regulados de la listasecundaria para ser impresos
setmem = []
k = 0
while k < int(len(listadeRIs)):
    j = 0
    copysec = False
    #while j < int(len(listasecundaria_trimmed)):
    while j < len(listasecundaria_trimmed):
        # print("listasecundaria_trimmed {} and listadeRIs {}".format(listasecundaria_trimmed, listadeRIs))
        # Original Daniel: if listasecundaria_trimmed[j][0] == listadeRIs[k][1]:
        if listasecundaria_trimmed[j][0] == listadeRIs[k][2]:
            # print("listasecundaria_trimmed[j][0] {} == listadeRIs[k][2] {}".format(listasecundaria_trimmed[j][0],
            #                                                                        listadeRIs[k][2]))
            copysec = True
            # print("j: {}".format(j))
            indj = j
        j = j + 1
    if copysec:
        setmem.append(listasecundaria_trimmed[indj])
        # print("setmen: {}".format(setmem))

    #### CMC: AGREGO ESTE CODIGO PARA BUSCAR REGULADOS YA QUE EL CODIGO ANTERIOR BUSCA REGULADORES
    j = 0
    copysec = False
    #while j < int(len(listasecundaria_trimmed)):
    while j < len(listasecundaria_trimmed):
        # print("listasecundaria_trimmed {} and listadeRIs {}".format(listasecundaria_trimmed, listadeRIs))
        # Original Daniel: if listasecundaria_trimmed[j][0] == listadeRIs[k][1]:
        if listasecundaria_trimmed[j][0] == listadeRIs[k][1]:
            # print("listasecundaria_trimmed[j][0] {} == listadeRIs[k][1] {}".format(listasecundaria_trimmed[j][0],
            #                                                                       listadeRIs[k][1]))
            copysec = True
            # print("j: {}".format(j))
            indj = j
        j = j + 1
    if copysec:
        setmem.append(listasecundaria_trimmed[indj])
        # print("setmen: {}".format(setmem))

    k = k + 1
setmem = sorted(setmem)
# print("setmen: {}".format(setmem))
dedup = [setmem[i] for i in range(len(setmem)) if i == 0 or setmem[i] != setmem[i - 1]]
# print("dedup: {}".format(dedup))
salida_a2_trimmed.extend(dedup)
#print("salida_a2_trimmed after listasecundaria_trimmed: {}".format(salida_a2_trimmed))

# Asigna identificadores (EX) a eventos (RIs)
for i in range(len(listadeRIs)):
    # Original Daniel: ID = "E" + str(i+1)
    ID = "R" + str(i + 1)
    listadeRIs[i].insert(0, ID)
#print("Con identificadores ListadeRIs: {}".format(listadeRIs))

# CREA LISTADO DE EVENTOS (EX) Y ENTIDADES (TX) EN FORMATO DE IMPESIÓN
for i in range(len(salida_a2_trimmed)):
    linea = str(salida_a2_trimmed[i][0]) + '	' + str(salida_a2_trimmed[i][1]) + ' ' + str(
        salida_a2_trimmed[i][2]) + ' ' + str(salida_a2_trimmed[i][3]) + '	' + str(salida_a2_trimmed[i][4])
    # Original Daniel: impresion.append(linea)
    impresionEntities.append(linea)

for i in range(len(listadeRIs)):
    if listadeRIs[i][2] and listadeRIs[i][3]:
        # Original Daniel: linea = str(listadeRIs[i][0]) + '	' + "deverbal_effect:" + str(listadeRIs[i][1]) + ' ' + 'Theme:' + str(listadeRIs[i][2]) + ' ' + 'Cause:' + str(listadeRIs[i][3])
        linea = str(listadeRIs[i][0]) + '	' + "Interaction." + str(listadeRIs[i][1]) + ' ' + 'Target:' + str(
            listadeRIs[i][2]) + ' ' + 'Agent:' + str(listadeRIs[i][3])
        # Original Daniel: elif listadeRIs[i][2]:
        # Original Daniel: linea = str(listadeRIs[i][0]) + '	' + "deverbal_effect:" + str(listadeRIs[i][1]) + ' ' + 'Theme:' + str(listadeRIs[i][2])
        # Original Daniel: elif listadeRIs[i][3]:
        # Original Daniel: linea = str(listadeRIs[i][0]) + '	' + "deverbal_effect:" + str(listadeRIs[i][1]) + ' ' + 'Cause:' + str(listadeRIs[i][3])
        # Original Daniel: else:
        # Original Daniel: linea = str(listadeRIs[i][0]) + '	' + "deverbal_effect:" + str(listadeRIs[i][1])
        # Original Daniel: impresion.append(linea)
        impresionInteractionsComplete.append(linea)
        #print("Interaction complete: {}".format(linea))
        linea = str(listadeRIs[i][0]) + '	' + "Interaction.regulator" + ' ' + 'Target:' + str(
            listadeRIs[i][2]) + ' ' + 'Agent:' + str(listadeRIs[i][3])
        impresionInteractionsIncomplete.append(linea)

#print("Entities: {}".format(impresionEntities))

# Escribir entidades interacciones completas en a1
for line in impresionEntities:
    # Original Daniel: save_file = open( file_name, "a" )
    save_file = open(file_name_entities_complete, "a")
    save_file.write(line)
    save_file.write("\n")
    save_file.close()

# Escribir entidades interacciones incompletas en a1
for line in impresionEntities:
    # Original Daniel: save_file = open( file_name, "a" )
    save_file = open(file_name_entities_incomplete, "a")
    save_file.write(line)
    save_file.write("\n")
    save_file.close()

# Escribir interacciones completas (regulator, effect, regulated)
# print("InteractionsComplete: {}".format(impresionInteractionsComplete))
for line in impresionInteractionsComplete:
    # Original Daniel: save_file = open( file_name, "a" )
    save_file = open(file_name_interactions_complete, "a")
    save_file.write(line)
    save_file.write("\n")
    save_file.close()

# Escribir interacciones incompletas (regulator, "regulator", regulated)
# print("InteractionsIncomplete: {}".format(impresionInteractionsIncomplete))
for line in impresionInteractionsIncomplete:
    # Original Daniel: save_file = open( file_name, "a" )
    save_file = open(file_name_interactions_incomplete, "a")
    save_file.write(line)
    save_file.write("\n")
    save_file.close()

with open(file_name_text_complete, mode="w") as txtFile:
    txtFile.write(dato)
with open(file_name_text_incomplete, mode="w") as txtFile:
    txtFile.write(dato)