# GRUPPO DI TEST: la formattazione

# %%
# 
# TEST A: uso il pacchetto-query così com'è dentro l'app Flask,
# ma senza tirare su tutta l'applicazione:
# una verifica dell'implementazione della piattaforma come
# 'ecosistema' di pacchetti indipendenti

import interface_sqlite3.query_handlers as qh

dbPath1 = '../../db/first_db'
dbPath2 = '../../db/ndg2.gat4/'

qh1 = qh.queryHandlerBasicSqlite({'dbPath': dbPath1})
qh2 = qh.queryHandlerBasicSqlite({'dbPath': dbPath2, 'db_encoded': True, 'texts_encoded': True})

# TEST B: un test collatelare semplice.
# Che informazioni ci sono, effettivamente, nei file codlemip.sigla?
# Decodifico alcuni record scelti per verificarlo
from interface_sqlite3.encdec.de_code import db_decode

print( db_decode(qh2.keyRing.vettSpec, 'МҨԢЫӗЫ') )
print( db_decode(qh2.keyRing.vettSpec, 'ԢÐ') )
print( db_decode(qh2.keyRing.vettSpec, 'МѢ') )
print( db_decode(qh2.keyRing.vettSpec, 'ӎӗЫӎÐ') )
print( db_decode(qh2.keyRing.vettSpec, '˻˥˼ϩӗӲÐМЫӲÐ') )
# %%
# Conclusione del TEST B: apparentemente non c'è nulla che non sia
# già nei file in chiaro lemmi.sigla.txt -- buono!

# %%
##########################################################
# FUNZIONI DI APPOGGIO, DA IMPLEMENTARE NEI QUERY HANDLERS
##########################################################

# Due funzioncine che beccano i primi 4 bit di un intero -- utility per
# recuperare la formattazione così come codificata nei file ftxt
def fourBits(num):
    pre = num
    a = str(pre % 2)
    pre = pre // 2
    b = str(pre % 2)
    pre = pre // 2
    c = str(pre % 2)
    pre = pre // 2
    d = str(pre % 2)
    return d + c + b + a
#
def fourBitsB(num):
    aa = bin(num)
    return aa[2:].rjust(4, "0")[-4:]

# To be tested for efficiency? Maybe later!


####
# Legenda: le formattazioni dal Techman. Ricordarsi che sono additive!
'''
0 = nessuna formattazione presente
1 = grassetto
2 = corsivo
4 = sottolineato
8 = barrato.
'''

# Trasformare la stringa di bit corrispondente ad un inter
# in un oggetto parlante, secondo la legenda sopra
def bitToFormat(str4):
    return {'grassetto': str4[-1], 'corsivo': str4[-2], 'sottolineato': str4[-3], 'barrato': str4[-4]}

print( fourBits(0) )
print( fourBitsB(0) )
print( bitToFormat(fourBitsB(0)) )
print( fourBits(15) )
print( fourBitsB(15) )
print( bitToFormat(fourBits(15)) )
print( fourBits(2) )
print( fourBitsB(2) )
print( bitToFormat(fourBitsB(2)) )
print( fourBits(3) )
print( fourBitsB(3) )
print( bitToFormat(fourBitsB(3)) )
print( fourBits(32413654647) )
print( fourBitsB(32413654647) )
print( bitToFormat(fourBitsB(32413654647)) )
# %%
# Funzione per recuperare le formattazioni 'raw'
def getTextFormattingRaw(dbPath, sigla, minChar, maxChar):
    with open(f"{dbPath}/ftxt/{sigla}", 'rb') as file1:
        file1.seek(minChar-1)
        
        preFormats = [char for char in file1.read(maxChar-minChar)]

    return preFormats

# Recupero la formattazione 'raw' di un testo completo (o quasi)
# mettendo un valore alto per maxChar, per cercare formattazioni non banali
siglaTest = 'alm'
test = getTextFormattingRaw(dbPath2, siglaTest, 1, 500000)

for ind, val in enumerate(test):
    if val>0:
        print(ind, val)
# %%
# La funzione finale per recuperare le formattazioni,
# messe 'in bella'
def getTextFormatting(dbPath, sigla, minChar, maxChar):
    with open(f"{dbPath}/ftxt/{sigla}", 'rb') as file1:
        file1.seek(minChar-1)
        
        preFormats = [char for char in file1.read(maxChar-minChar)]
    
    # Get format CHANGES + first format; only return non-zero format sequences
    formatChanges = [(0, preFormats[0])] + [(ind, preFormats[ind]) for ind in range(1, len(preFormats)) if preFormats[ind]!=preFormats[ind-1]]
    formats = []
    for ind, form in enumerate(formatChanges):
        if form[1]>0:
            format0 = bitToFormat(fourBits(form[1]))
            start = form[0]
            end = formatChanges[ind+1][0] if ind < len(formatChanges)-1 else -1
            formats.append( {'format': format0, 'coordinates': [start, end]} )

    return formats


# TEST C -- il test principale, avendo recuperato a parte una sigla ed un range
# in cui c'è effettivamente una formattazione non banale
test2 = qh1.textQuery({'sigla': 'aa1', 'minChar': 175, 'maxChar': 191}, True)
print(test2)
# %%