# load the N1904 app and data
N1904 = use ("tonyjurg/Nestle1904LFT", version="0.7", hoist=globals())

# The following will push the Text-Fabric stylesheet to this notebook (to facilitate proper display with notebook viewer)
N1904.dh(N1904.getCss())

N1904.showFormats()

T.formats

for formats in T.formats:
    print(f'fmt={formats}\t: {T.text(139200,formats)}')

# Library to format table
from tabulate import tabulate

# get a node list for all word nodes
WordQuery = '''
word 
'''
# The option 'silent=True' has been added in the next line to prevent printing the number of nodes found
WordResult = N1904.search(WordQuery,silent=True) 

# Gather the results where feature normalized is different from feature word 
ResultDict = {}
NumberOfChanges=0
for tuple in WordResult:
    word=F.word.v(tuple[0])
    normalized=F.normalized.v(tuple[0])
    if word!=normalized:
        Change=f"{word} -> {normalized}"
        NumberOfChanges+=1
        if Change in ResultDict:
            # If it exists, add the count to the existing value
            ResultDict[Change]+=1
        else:
            # If it doesn't exist, initialize the count as the value
            ResultDict[Change]=1
    
print(f"{NumberOfChanges} differences found between feature word and feature normalized.")
# Convert the dictionary into a list of key-value pairs and sort it according to frequency
UnsortedTableData = [[key, value] for key, value in ResultDict.items()]
TableData= sorted(UnsortedTableData, key=lambda row: row[1], reverse=True)

# In this example the table will be truncated 
max_rows = 10  # Set your desired number of rows here
TruncatedTable = TableData[:max_rows]

# Produce the table
headers = ["word -> normalized","frequency"]
print(tabulate(TruncatedTable, headers=headers, tablefmt='fancy_grid'))

# Add a warning using markdown (API call A.dm) allowing it to be printed in bold type
N1904.dm("**Warning: table truncated!**")

# get a node list for all word nodes with feature word=καί 
KaiQuery = '''
word word=καί
'''
KaiResult = N1904.search(KaiQuery) 

# get a node list for all word nodes with feature word=δέ
DeQuery = '''
word word=δέ
'''
DeResult = N1904.search(DeQuery) 

# get a node list for all word nodes containing some variants in accents
KosmosQuery = '''
word word~λ[όο]γ[όο]ς
'''

PneumaQuery = '''
word word~πν[εέ][ῦυ]μα
'''

KuriosQuery = '''
word word~κ[ύυ]ρ[ίι]ος
'''

HemeraQuery = '''
word word~ἡμ[έε]ρα
'''


Result = N1904.search(KuriosQuery) 
for tuple in Result:
    word=F.word.v(tuple[0])
    print(word)

LatinQuery = '''
word wordtranslit=logos
'''
Result = N1904.search(LatinQuery) 
for tuple in Result:
    word=F.word.v(tuple[0])
    print(word)
    break

F.markafter.freqList()

F.markbefore.freqList()

# get a node list for all word nodes
WordQuery = '''
word 
'''
BracketList=("(" , ")" , "[" , "]" , "[[" , "]]")

# The option 'silent=True' has been added in the next line to prevent printing the number of nodes found
WordResult = N1904.search(WordQuery,silent=True) 

SingleRound=SingleSquare=DoubleSquare=False

for tuple in WordResult:
    node=tuple[0]
    MarkAfter=F.markafter.v(node)
    MarkBefore=F.markbefore.v(node)
    Mark=MarkAfter+MarkBefore
    location="{} {}:{}".format(F.book.v(node),F.chapter.v(node),F.verse.v(node))
    if (Mark in BracketList):
        if Mark=="(":
            if SingleRound==True: print ("Sequence problem?")
            SingleRound=True
            print (f"{location}: set single round")
        if Mark==")":
            if SingleRound==False: print ("Sequence problem?")
            SingleRound=False
            print (f"{location}: unset single round\n")
            
        if Mark=="[":
            if SingleSquare==True: print ("Sequence problem?")
            SingleSquare=True
            print (f"{location}: set single square")
        if Mark=="]":
            if SingleSquare==False: print ("Sequence problem?")
            SingleSquare=False
            print (f"{location}: unset single square\n")
            
        if Mark=="[[":
            if DoubleSquare==True: print ("Sequence problem?")
            DoubleSquare=True
            print (f"{location}: set double square")
        if Mark=="]]":
            if DoubleSquare==False: print ("Sequence problem?")
            DoubleSquare=False
            print (f"{location}: unset double square\n")

T.text(139200,fmt='text-critical')