#%%
from .parsing_utilities import interpreter, inizialeraddoppiata, list_normalize

# Basic data provider class; can be instantiated to handle different kinds
# of data-providing connections or interfaces based on config options
from .data_interface.data_providers_setup import queryHandlerFactory

import pandas as pd

# Main class for basic queries contains:
# - a data provider instance
# - methods to submit queries to the data provider instance
class basicQueries:

    def __init__(self, dataConfig):
        self.queryHandler = queryHandlerFactory(dataConfig)
        self.listOcc = dataConfig.get('listOcc')

    # Prepares and sends query OBJECTS which will be processed by the data provider
    def sendBasicQuery(self, text, queryType, espansa, raddoppiata, pandas=False, dbFile=None):
        
        entries = interpreter(text)
        
        data = entries
        dataNorm = []
        if raddoppiata==1:
            data = entries + inizialeraddoppiata(entries)
        if espansa==1 and raddoppiata==0:
            dataNorm = list_normalize(entries)
        elif espansa==1 and raddoppiata==1:
            dataNorm = entries + list_normalize(inizialeraddoppiata(entries))

        return self.queryHandler.query({'data': data, 'dataNorm': dataNorm, 'queryType': queryType}, pandas, dbFile)
    
    #%% ha in input le funzioni di ricerca, cerca nell'occorrenziario i puntatori ai contesti e altri elementi ad essi associati. 
    #l'attributo type definisce il tipo di ricerca in input (0 per forme, 1 per lemmi, 2 per lemmi con opzione "mostra occorrenze non lemmatizzate")
    def findtexts(self, type, df, index = None):
        if index is None:
            df = pd.DataFrame(df)
        else:
            if isinstance(index, range):
                index = list(index)
            elif not isinstance(index, list):
                index = [index]
            df = pd.DataFrame(df.loc[index])
        textlist = pd.DataFrame()
        codList = list(df["cod"])
        listOcc = self.listOcc
        
        queryData = {'queryType': 'texts', 'querySubtype': type, 'codList': codList}

        for table in listOcc:
            queryData['table'] = table
            if type==2:
                subQueryData = {'queryType': 'pfl', 'codList': codList}
                subdf = self.queryHandler.query(subQueryData, pandas=True)
                queryData['formCodList'] = list(subdf['codForma'])

            extendequeryReponse = self.queryHandler.query(queryData, pandas=True)

            textlist = pd.concat([textlist, extendequeryReponse])

        return textlist

    # %% ha in input findtexts, restituisce i contesti associati agli elementi localizzati.
    # Il range dei contesti è impostato di default a 30 parole e può essere rimodulato nel passaggio al contesto singolo.

    def findcontexts(self, textlist):
        parole = 31
        listOcc = self.listOcc
        contexts = []
        for ind, row in textlist.iterrows():
            sigla = row["sigla"]
            queryData = {'queryType': 'contexts', 'ntxlocal': row["ntx"], 'mappalocal': row['mappa'], 'parole': parole}
            pointerlist = pd.DataFrame()
            for table in listOcc:
                queryData['table'] = table
                queryresponse = self.queryHandler.query(queryData, pandas=True)
                pointerlist = pd.concat([pointerlist, queryresponse])
            fileQueryData = {'sigla': sigla, 'minChar': pointerlist["pitxt"].min(), 'maxChar': pointerlist["pitxt"].max()}
            cont = self.queryHandler.textQuery(fileQueryData)
            contexts.append(cont)
        textlist['contesto'] = contexts
        return (textlist.reset_index(drop=True))

    # %% Ha in input findcontexts, associa i riferimenti bibliografici ad ogni contesto.

    def findbib(self, contexts):
        infobib = pd.DataFrame()
        rif_org = pd.DataFrame()
        for ind, row in contexts.iterrows():
            queryData = {'queryType': 'bib', 'row': row}
            bib = self.queryHandler.query(queryData, pandas=True, dbFile='bibliografia/BiblioTLIO.db')
            infobib = pd.concat([infobib, bib])
            queryData = {'queryType': 'rif', 'row': row}
            rif = self.queryHandler.query(queryData, pandas=True)
            rif_org = pd.concat([rif_org, rif])
        annoiniz = list(infobib['Anno iniziale'])
        annofin = list(infobib['Anno finale'])
        datacod = list(infobib['Data codificata'])
        datadesc = list(infobib['Data descrittiva'])
        titoloabb = list(infobib['Titolo Abbreviato'])
        autore = list(infobib['Autore'])
        titolo = list(infobib['Titolo'])
        curatore = list(infobib['Curatore'])
        areagen = list(infobib['Area generica'])
        areaspec = list(infobib['Area specifica'])
        genere = list(infobib['Genere'])
        forma = list(infobib['Forma'])
        tipo = list(infobib['Tipo'])
        iq = list(infobib['IQ'])
        rif1 = list(rif_org['Rif_organico'])
        rif2 = list(rif_org['Rif_completo'])
        contexts['Anno iniziale'] = annoiniz
        contexts['Anno finale'] = annofin
        contexts['Data codificata'] = datacod
        contexts['Data descrittiva'] = datadesc
        contexts['Autore'] = autore
        contexts['Titolo Abbreviato'] = titoloabb
        contexts['Titolo'] = titolo
        contexts['Curatore'] = curatore
        contexts['Area generica'] = areagen
        contexts['Area specifica'] = areaspec
        contexts['Genere'] = genere
        contexts['Forma'] = forma
        contexts['Tipo'] = tipo
        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'])   
        cols = ['links','Titolo Abbreviato', 'Rif_organico', 'tipostanza', 'stanza', 'verso', 'pag', 'riga', 'IQ', 'lemma', 'cat_gr', 'disambiguatore', 'contesto', 'Autore', 'Titolo',  'Anno iniziale', 'Anno finale', 'Data codificata', 'Data descrittiva', 'Area generica', 'Area specifica', 'Genere', 'Forma', 'Tipo', 'Curatore', 'ntx', 'pitxt', 'elemlen', 'mappa', 'numperiod', 'numorg', 'sigla', 'vol', 'col', 'numbrano', 'Rig_completo', 'cod']
        clean_df = chrono.reindex(columns=cols + list(chrono.columns.difference(cols)))
        return (clean_df.reset_index(drop=True))
    
    #%% funzione stringa/stringhe da evidenziare

    def highlight (self, bibliocontexts):
        index = 0
        for col in bibliocontexts.columns:
            forme = []
            if col.startswith('cod'):
                for ind, row in bibliocontexts.iterrows():
                    queryData = {'queryType': 'highlight', 'row': row, 'col': col}
                    forma = self.queryHandler.query(queryData, pandas=True)
                    forme += list(forma['highlight'])        
                if index == 0:
                    bibliocontexts['highlight'] = forme
                else:
                    bibliocontexts['highlight'+str(index)] = forme
                index += 1
        highlight_cols = bibliocontexts.filter(regex='^highlight')
        create_array = lambda row: highlight_cols.loc[row.name].values.tolist()
        bibliocontexts['highlights_combined'] = highlight_cols.apply(create_array, axis=1)
        return bibliocontexts

    #%% funzione contesti multipli cumulativa

    def contestimultipli (self, tipo_ricerca, ricerca, index = None):
        ricercadf = pd.DataFrame(ricerca)
        textlist = self.findtexts(tipo_ricerca, ricercadf, index)
        contexts = self.findcontexts (textlist)
        bibliocontexts = self.findbib (contexts)
        highlights = self.highlight(bibliocontexts)
        return highlights.to_dict(orient='records')
    
    #%% funzione reperimento e raffinamento contesti singoli
    def singlecontexts(self, textlist, index, parole, periodi, brani):
        context = textlist.iloc[index]
        contexts = []
        formats = []
        listOcc = self.listOcc
        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"]
        numbranolocal = textlist.loc[index, "numbrano"]
        if parole != 0:
            pointerlist = pd.DataFrame()
            for table in listOcc:
                print(listOcc)
                queryData = {'queryType': 'singlecontext', 'querySubtype': 'parole', 'parole': parole, 'periodi': periodi, 'brani': brani, 'table': table, 'ntxlocal': ntxlocal, 'mappalocal': mappalocal, 'periodlocal': periodlocal, 'numbranolocal': numbranolocal}
                queryresponse = self.queryHandler.query(queryData, pandas=True)
                pointerlist = pd.concat([pointerlist, queryresponse])
            print(pointerlist)
            fileQueryData = {'sigla': sigla, 'minChar': pointerlist["pitxt"].min(), 'maxChar': pointerlist["pitxt"].max()}
            cont = self.queryHandler.textQuery(fileQueryData)
            contexts.append(cont)
            form = self.queryHandler.formatQuery(fileQueryData)
            formats.append(form)
            context ['piniz'] = pointerlist["pitxt"].min()
            context ['pfin'] = pointerlist["pitxt"].max()
        elif periodi != 0:
            queryData = {'queryType': 'singlecontext', 'querySubtype': 'parole', 'parole': parole, 'periodi': periodi, 'brani': brani, 'table': table, 'ntxlocal': ntxlocal, 'mappalocal': mappalocal, 'periodlocal': periodlocal, 'numbranolocal': numbranolocal}
            queryresponse = self.queryHandler.query(queryData, pandas=True)
            fileQueryData = {'sigla': sigla, 'minChar': pointerlist["pitxt"].min(), 'maxChar': pointerlist["pitxt"].max()}
            cont = self.queryHandler.textQuery(fileQueryData)
            contexts.append(cont)
            form = self.queryHandler.formatQuery(fileQueryData)
            formats.append(form)
            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:
                queryData = {'queryType': 'singlecontext', 'querySubtype': 'brani', 'parole': parole, 'periodi': periodi, 'brani': brani, 'table': table, 'ntxlocal': ntxlocal, 'mappalocal': mappalocal, 'periodlocal': periodlocal, 'numbranolocal': numbranolocal}
                queryresponse = self.queryHandler.query(queryData, pandas=True)
                fileQueryData = {'sigla': sigla, 'minChar': pointerlist["pitxt"].min(), 'maxChar': pointerlist["pitxt"].max()}
                cont = self.queryHandler.textQuery(fileQueryData)
                contexts.append(cont)
                form = self.queryHandler.formatQuery(fileQueryData)
                formats.append(form)
                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 reperimento note e brani associati
    def findlinks (self, context):
        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:
            queryData = {'queryType': 'links', 'querySubtype': 'nota', 'ntxlocal': ntxlocal, 'pinizlocal': pinizlocal, 'pitxtlocal': pitxtlocal, 'pfinlocal': pfinlocal}
            queryresponse = self.queryHandler.query(queryData, pandas=True)
            fileQueryData = {'sigla': siglalocal, 'minChar': queryresponse["piniz"].min(), 'maxChar': queryresponse["pfin"].max()}
            cont = self.queryHandler.textQuery(fileQueryData)
            context['nota'] = cont
            return context
        if linkslocal == 2:
            queryData = {'queryType': 'links', 'querySubtype': 'testo_associato', 'ntxlocal': ntxlocal, 'pinizlocal': pinizlocal, 'pitxtlocal': pitxtlocal, 'pfinlocal': pfinlocal}
            queryresponse = self.queryHandler.query(queryData, pandas=True)
            fileQueryData = {'sigla': siglalocal, 'minChar': queryresponse["piniz"].min(), 'maxChar': queryresponse["pfin"].max()}
            cont = self.queryHandler.textQuery(fileQueryData)
            context['testo associato'] = cont
        if linkslocal == 3:
            queryData = {'queryType': 'links', 'querySubtype': 'nota', 'ntxlocal': ntxlocal, 'pinizlocal': pinizlocal, 'pitxtlocal': pitxtlocal, 'pfinlocal': pfinlocal}
            queryresponse = self.queryHandler.query(queryData, pandas=True)
            fileQueryData = {'sigla': siglalocal, 'minChar': queryresponse["piniz"].min(), 'maxChar': queryresponse["pfin"].max()}
            cont = self.queryHandler.textQuery(fileQueryData)
            context['nota'] = cont
            queryData2 = {'queryType': 'links', 'querySubtype': 'testo_associato', 'ntxlocal': ntxlocal, 'pinizlocal': pinizlocal, 'pitxtlocal': pitxtlocal, 'pfinlocal': pfinlocal}
            queryresponse2 = self.queryHandler.query(queryData2, pandas=True)
            fileQueryData2 = {'sigla': siglalocal, 'minChar': queryresponse2["piniz"].min(), 'maxChar': queryresponse2["pfin"].max()}
            cont2 = self.queryHandler.textQuery(fileQueryData2)
            context['testo associato'] = cont2
        return context
    
    #%% funzione contesti singoli cumulativa
    def contestosingolo (self, contestimultipli, indice, parole, periodi, brani):
     contestimultiplidf = pd.DataFrame(contestimultipli)
     print(contestimultiplidf)
     contestosingolo = self.singlecontexts(contestimultiplidf, indice, parole, periodi, brani)
     braniassociati = self.findlinks(contestosingolo)
     contestosingoloclean = self.findbib (braniassociati)
     return contestosingoloclean.to_dict(orient='records')