# %%
import sqlite3
import pandas as pd
import dtale
import unicodedata
from simple_query_test_pandas import ricercaforme, ricercalemmi, ricercaformelemmi, ricercalemmiforme, interpreter
from test_occorrenzario_pandas import findtexts, findcontexts, findbib, contestimultipli, get_tables_occ

#funzione di ricerca dei contesti singoli, con personalizzazione dell'ampiezza per parole o periodi, ha in input findcontexts e deve essere passata a findbib.
def singlecontexts(textlist, index, parole, periodi, brani, listOcc, path):
    context = textlist.iloc[index]
    contexts = []
    formats = []
    con = sqlite3.connect(f"file:{path}/test1.db?mode=ro", uri=True)
    sigla = textlist.loc[index, "sigla"]
    periodlocal = textlist.loc[index, "numperiod"]
    ntxlocal = textlist.loc[index, "ntx"]
    mappalocal = textlist.loc[index, "mappa"]
    linkslocal = textlist.loc[index, "links"]
    if parole != 0:
        pointerlist = pd.DataFrame()
        for table in listOcc:
            query = f"SELECT tab.pitxt, tab.elemlen FROM {table} AS tab WHERE tab.ntx = {ntxlocal} AND tab.mappa <= {mappalocal+int(parole/2)} AND tab.mappa >= {mappalocal-int(parole/2)}"
            queryresponse = pd.read_sql(query, con)
            pointerlist = pd.concat([pointerlist, queryresponse])
        with open(f"{path}/itxt/{sigla}", 'r', encoding="utf-32-le") as file1:
            file1.seek(4*pointerlist["pitxt"].min())
            cont = file1.read(pointerlist["pitxt"].max()-pointerlist["pitxt"].min())
            contexts.append(cont)
        with open(f"{path}/ftxt/{sigla}", 'rb') as file1:
            file1.seek(pointerlist["pitxt"].min()-1)
            formBytes = file1.read(pointerlist["pitxt"].max()-pointerlist["pitxt"].min())
            form = [byte for byte in formBytes]
            formats.append(form)
            context ['piniz'] = pointerlist["pitxt"].min()
            context ['pfin'] = pointerlist["pitxt"].max()
    elif periodi != 0:
        query = f"SELECT piniz, pfin FROM periodi WHERE ntx = {ntxlocal} AND numperiod <= {periodlocal+int(periodi/2)} AND numperiod >= {periodlocal-int(periodi/2)}"
        queryresponse = pd.read_sql(query, con)
        with open(f"{path}/itxt/{sigla}", 'r', encoding="utf-32-le") as file1:
            file1.seek(4*queryresponse["piniz"].min())
            cont = file1.read(queryresponse["pfin"].max()-queryresponse["piniz"].min())
            contexts.append(cont)
            context ['piniz'] = queryresponse["piniz"].min()
            context ['pfin'] = queryresponse["pfin"].max()
    elif brani != 0:
        if linkslocal == 0 or linkslocal == 1:
            return "Nessun brano associato a questo contesto"
        else:
            numbranolocal = textlist.loc[index, "numbrano"]
            query = f"SELECT piniz, pfin FROM linkbase WHERE {ntxlocal} = ntx AND tipo = 2 AND id BETWEEN {numbranolocal-int(brani/2)} AND {numbranolocal+int(brani/2)}"
            queryresponse = pd.read_sql(query, con)
            with open(f"{path}/itxt/{sigla}", 'r', encoding="utf-32-le") as file1:
                file1.seek(4*queryresponse["piniz"].min())
                cont = file1.read(queryresponse["pfin"].max()-queryresponse["piniz"].min())
                contexts.append(cont)
                context ['piniz'] = queryresponse["piniz"].min()
                context ['pfin'] = queryresponse["pfin"].max() 
    context['contesto'] = contexts [0]
    context['formattazione'] = formats
    return pd.DataFrame(context).T.reset_index(drop=True)


#%% funzione di ricerca dei brani associati. Ha in input singlecontexts.
def findlinks (context, path):
    con = sqlite3.connect(f"file:{path}/test1.db?mode=ro", uri=True)
    linkslocal = context.loc[0, "links"]
    siglalocal = context.loc[0, "sigla"]
    ntxlocal = context.loc[0, "ntx"]
    pitxtlocal = context.loc[0, "pitxt"]
    pinizlocal = context.loc[0, "piniz"]
    pfinlocal = context.loc[0, "pfin"]
    if linkslocal == 0:
        return context
    if linkslocal == 1:
        query = f"SELECT ta.ntx, ta.id, ta.piniz, ta.pfin, tb.mappain, tb.mappafin FROM linkbase AS tb INNER JOIN linknoteass AS ta ON tb.ntx = ta.ntx AND tb.id = ta.id WHERE (((tb.tipo= 1) AND (tb.ntx = {ntxlocal})) AND ((tb.piniz BETWEEN {pinizlocal} AND {pfinlocal}) OR ({pitxtlocal} BETWEEN tb.piniz AND tb.pfin)))"
        queryresponse = pd.read_sql(query, con)
        with open(f"{path}/itxt/{siglalocal}", 'r', encoding="utf-32-le") as file1:
                file1.seek(4*queryresponse["piniz"].min())
                cont = file1.read(queryresponse["pfin"].max()-queryresponse["piniz"].min()-2)
        context['nota'] = cont
        return context
    if linkslocal == 2:
        query = f"SELECT ta.ntx, ta.id, ta.piniz, ta.pfin, tb.mappain, tb.mappafin FROM linkbase AS tb INNER JOIN linknoteass AS ta ON tb.ntx = ta.ntx AND tb.id = ta.id WHERE (((tb.tipo= 2) AND (tb.ntx = {ntxlocal})) AND ((tb.piniz BETWEEN {pinizlocal} AND {pfinlocal}) OR ({pitxtlocal} BETWEEN tb.piniz AND tb.pfin)))"
        queryresponse = pd.read_sql(query, con)
        with open(f"{path}/itxt/{siglalocal}", 'r', encoding="utf-32-le") as file1:
                file1.seek(4*queryresponse["piniz"].min())
                cont = file1.read(queryresponse["pfin"].max()-queryresponse["piniz"].min()-2)
        context['testo associato'] = cont
    if linkslocal == 3:
        query = f"SELECT ta.ntx, ta.id, ta.piniz, ta.pfin, tb.piniz AS iniz, tb.pfin AS fin, tb.mappain, tb.mappafin FROM linkbase AS tb INNER JOIN linknoteass AS ta ON tb.ntx = ta.ntx AND tb.id = ta.id WHERE (((tb.tipo= 1) AND (tb.ntx = {ntxlocal})) AND ((tb.piniz BETWEEN {pinizlocal} AND {pfinlocal}) OR ({pitxtlocal} BETWEEN tb.piniz AND tb.pfin)))"
        queryresponse = pd.read_sql(query, con)
        with open(f"{path}/itxt/{siglalocal}", 'r', encoding="utf-32-le") as file1:
                file1.seek(4*queryresponse["piniz"].min())
                cont = file1.read(queryresponse["pfin"].max()-queryresponse["piniz"].min()-2)
        context['nota'] = cont
        query2 = f"SELECT ta.ntx, ta.id, ta.piniz, ta.pfin, tb.piniz AS iniz, tb.pfin AS fin, tb.mappain, tb.mappafin FROM linkbase AS tb INNER JOIN linknoteass AS ta ON tb.ntx = ta.ntx AND tb.id = ta.id WHERE (((tb.tipo= 2) AND (tb.ntx = {ntxlocal})) AND ((tb.piniz BETWEEN {pinizlocal} AND {pfinlocal}) OR ({pitxtlocal} BETWEEN tb.piniz AND tb.pfin)))"
        queryresponse2 = pd.read_sql(query2, con)
        with open(f"{path}/itxt/{siglalocal}", 'r', encoding="utf-32-le") as file2:
                file2.seek(4*queryresponse2["piniz"].min())
                cont2 = file2.read(queryresponse2["pfin"].max()-queryresponse2["piniz"].min()-2)
        context['testo associato'] = cont2
    return context

#%% Ha in input links, associa i riferimenti bibliografici ad ogni contesto.
def singlefindbib(contexts, path):
    infobib = pd.DataFrame()
    rif_org = pd.DataFrame()
    for ind, row in contexts.iterrows():
        con = sqlite3.connect(f"file:{path}/bibliografia/BiblioTLIO.db?mode=ro", uri=True)
        Query = f"SELECT [Anno iniziale], [Titolo Abbreviato], IQ FROM datibib WHERE Sigla='{row['sigla']}'"
        bib = pd.read_sql(Query, con)
        infobib = pd.concat([infobib, bib])
        con2 = sqlite3.connect(f"file:{path}/test1.db?mode=ro", uri=True)
        Query2 = f"SELECT head AS Rif_organico, full AS Rif_completo FROM org WHERE (indice='{row['numorg']}' AND ntx='{row['ntx']}')"
        rif = pd.read_sql(Query2, con2)
        rif_org = pd.concat([rif_org, rif])
    anno = list(infobib['Anno iniziale'])
    titolo = list(infobib['Titolo Abbreviato'])
    iq = list(infobib['IQ'])
    rif1 = list(rif_org['Rif_organico'])
    rif2 = list(rif_org['Rif_completo'])
    contexts['Anno iniziale'] = anno
    contexts['Titolo Abbreviato'] = titolo
    contexts ['IQ'] = iq
    contexts['Rif_organico'] = rif1
    contexts['Rig_completo'] = rif2
    contexts.pag = contexts.pag.astype(int)
    chrono = contexts.sort_values(by=['Anno iniziale', 'Rif_organico', 'pag'])   
    if 'nota' in chrono.columns and 'testo associato' in chrono.columns:
        cols = ['links','Titolo Abbreviato', 'Rif_organico', 'tipostanza', 'stanza', 'verso', 'pag', 'riga', 'IQ', 'lemma', 'cat_gr', 'disambiguatore', 'contesto', 'nota', 'testo associato', 'highlight']
    elif 'nota' in chrono.columns:
        cols = ['links','Titolo Abbreviato', 'Rif_organico', 'tipostanza', 'stanza', 'verso', 'pag', 'riga', 'IQ', 'lemma', 'cat_gr', 'disambiguatore', 'contesto', 'nota', 'highlight']
    elif 'testo associato' in chrono.columns:
        cols = ['links','Titolo Abbreviato', 'Rif_organico', 'tipostanza', 'stanza', 'verso', 'pag', 'riga', 'IQ', 'lemma', 'cat_gr', 'disambiguatore', 'contesto', 'testo associato', 'highlight']
    else:
        cols = ['links','Titolo Abbreviato', 'Rif_organico', 'tipostanza', 'stanza', 'verso', 'pag', 'riga', 'IQ', 'lemma', 'cat_gr', 'disambiguatore', 'contesto', 'highlight']
    chrono = chrono.drop(chrono.columns[0], axis=1)
    clean_df = chrono.reindex(columns=cols + list(chrono.columns.difference(cols)))
    return clean_df

# %% funzione contesti singoli

def contestosingolo (contestimultipli, indice, parole, periodi, brani, listOcc, path):
     contestosingolo = singlecontexts(contestimultipli, indice, parole, periodi, brani, listOcc, path)
     braniassociati = findlinks(contestosingolo, path)
     contestosingoloclean = singlefindbib (braniassociati, path)
     return contestosingoloclean

# %%
path = "/Users/leonardocanova/Library/CloudStorage/OneDrive-ConsiglioNazionaledelleRicerche/TIGRO/Ricerche/db/first_db"
listOcc = get_tables_occ(path)
entry = "amistade"
tiporicerca= 0
# tipo di ricerca (0 per forme, 1 per lemmi, 2 per lemmi con opzione "mostra occorrenze non lemmatizzate")
indice = 28
numeroparole = 30
numeroperiodi = 0
numerobrani = 0 
ricerca=ricercaforme(interpreter(entry), path, 0, 0)
contesti = contestimultipli(tiporicerca, ricerca, listOcc, path)
contesto = contestosingolo(contesti, indice, numeroparole, numeroperiodi, numerobrani, listOcc, path)
dtale.show(contesto)
# %%