# nacteni obsahu z existujiciho souboru
with open('texty/text_01.txt', encoding='UTF-8') as f:
    obsah = f.read()
print(obsah)

text_bez_interpunkce = obsah.translate(str.maketrans({',':'', '.':'', '!':'', '?':''}))
print(text_bez_interpunkce)


# prevedeni textu na mala pismena
text_bez_interpunkce_lc = text_bez_interpunkce.lower()
print(text_bez_interpunkce_lc)

import re

"""
1.  
Vypište všechna slova obsahující řetězec písmen 'ob'.
2. 
Vyhledejte všechny výrazy, které neobsahují vokály.
3.
Vyhledejte konsonanticke klastry o 2 a vice konsonantech (můžete modifikovat předchozí dotaz), b) vytvořte jejich seznam a c) zjistěte frekvence jednotlivych klastrů.
4. 
Jedním dotazem vyhledejte následující tvary slovesa bát: byl, byla, bylo, byly, byli, 
5.
Vyhledejte slova začínající na 'ne-'a 'js-'
"""

# 1
hledane_retezce = '\w*ob\w*' 
slovo_vyskyty = re.findall(hledane_retezce, text_bez_interpunkce_lc)
print(slovo_vyskyty)

# 2
# najde 1 a vice znaku, ktere nejsou vokalem nebo neslovnim znakem 
hledane_retezce = r'\b[^aáeéěiíyýoóuúů\W]+\b' 
slovo_vyskyty = re.findall(hledane_retezce, text_bez_interpunkce_lc)
print(slovo_vyskyty)


# 3
hledane_retezce = r'[^aáeéěiíyýoóuúů\W\d]{2,}' #najde jednotlive souhlasky a shluky
slovo_vyskyty = re.findall(hledane_retezce, text_bez_interpunkce_lc)
print(slovo_vyskyty)

seznam_kons_klastru = list(set(slovo_vyskyty))
print(seznam_kons_klastru)

from collections import Counter
frekv_kons_klastru = Counter(slovo_vyskyty)
print(frekv_kons_klastru)


# 4. 
hledane_retezce = r'byl[aoyi]?' 
slovo_vyskyty = re.findall(hledane_retezce, text_bez_interpunkce_lc)
print(slovo_vyskyty)

# 5
hledane_retezce = r'(\bne\w*|\bjs\w*)' 
slovo_vyskyty = re.findall(hledane_retezce, text_bez_interpunkce_lc)
print(slovo_vyskyty)


# alternativa - dohledat kombinaci ?:
hledane_retezce = r'(\b(?:ne|js)\w*)' 



# 6 proprce HL

from collections import Counter
tokens = text_bez_interpunkce_lc.split()

frekv_slovnik = Counter(tokens)
print(frekv_slovnik)

frekvence = list(frekv_slovnik.values())
print(frekvence)

pocet_HL = frekvence.count(1)
proporce_HL = pocet_HL / len(tokens)
print(round(proporce_HL, 3))


# 7 RR

#REPEATE RATE
# ukazat, jak se muze mit stejny TTR ruzne RR
#RR = suma frekvenci kazdeho slova umocnenych na druhou, deleno delka textu na druhou


from collections import Counter
frekv_slovnik = Counter(tokens)
print(frekv_slovnik)

#umocnim kazdou hodnotu frekvence
frekvence = list(frekv_slovnik.values())
print(frekvence)    

umocnene_frekvence = []
for i in frekvence:
    umocnene_frekvence.append(i ** 2)
print(umocnene_frekvence)

# pomoci list comprehesion
umocnene_frekvence = [i ** 2 for i in frekvence]
print(umocnene_frekvence)

#sectu je
suma_fr2 = sum(umocnene_frekvence)
print(suma_fr2)

#vypocet RR
N = len(tokens)
RR = suma_fr2 / N ** 2
print(RR)

#a ted vse dohromady na jednom miste
frekvence = list(frekv_slovnik.values())
umocnene_frekvence = []
for hodnota in frekvence:
    umocnene_frekvence.append(hodnota ** 2)
suma_fr2 = sum(umocnene_frekvence)  
N = len(tokens)
RR = suma_fr2 / N ** 2
print(round(RR, 4))


#pro snadnejsi interpretaci se RR relativizuje, zde McIntoshuv postup (viz knizka)
import math  #pouziju pak pro odmocnovani

#potrebuju pocet typu
V = len(set(text_bez_interpunkce_lc.split()))

RR_Mc = (1 - math.sqrt(RR)) / (1 - 1 / math.sqrt(V))
print(RR_Mc)
















# minule jsme dosli k TTR, takze cast se prekroci

# fce pro zpracovani textu, je treba tam pridat uvozovky, pomlcky do maketrans

def uprava_textu(path):
    with open(path, encoding='utf-8') as f:
            obsah = f.read()
    text_bez_interpunkce = obsah.translate(str.maketrans({',':'', '.':'', '!':'', '?':'', '"':'', '-':'', ':':'' }))
    text_bez_interpunkce_lc = text_bez_interpunkce.lower() 
    return text_bez_interpunkce_lc



Sv_1974 = uprava_textu('texty/1974_Svoboda.txt')
print(Sv_1974) 

svejk_01 = uprava_textu('texty/svejk/svejk_01.txt')
print(svejk_01[:500])


#TEMA: LEXIKALNI DIVERZITA


# UKOL: vytvorte seznam tokenu a typu a spocitejte jejich pocet
# pocet tokenu ulozte do promenne N, pocet typu do promenne V
tokens = text_bez_interpunkce_lc.split()
print(tokens)
types = set(text_bez_interpunkce_lc.split())
print(types)


#TTR: type token ratio - pocet typu vydeleny poctem tokenu
N = len(tokens)
V = len(types)
print(N)
print(V)

TTR = V/N
print(TTR)
print(round(TTR, 3))


# UKOL: spocitejte TTR na Svejkovych souborech - 
# napiste fci, ktera vraci TTR zaokrouhleny na 3 desetinna cisla a delku textu




svejk_01 = uprava_textu('texty/svejk/svejk_01.txt')
svejk_01_05 = uprava_textu('texty/svejk/svejk_01-05.txt')
svejk_01_10 = uprava_textu('texty/svejk/svejk_01-10.txt')
svejk_01_15 = uprava_textu('texty/svejk/svejk_01-15.txt')
print(svejk_01_15)


def TTR_N(text):
     tokens = text.split()
     types = set(text.split())
     N = len(tokens)
     V = len(types)
     TTR = V/N
     return(round(TTR, 3), N)

TTR_N(svejk_01)
TTR_N(svejk_01_05)     
TTR_N(svejk_01_10)
TTR_N(svejk_01_15)


# TTR ze segmentu prvnich 1000 slov = TTR_1000

# UKOL: napiste fci, ktera spocita TTR na 1000 slovech


def TTR_1000(text):
     tokens = text.split()
     types = set(tokens[:1000])
     N = 1000
     V = len(types)
     TTR = V/N
     return(round(TTR, 3), N)

# spocitejte TTR, N a STTR na kap. 1, 4, 8, 17 kap. Svejka

svejk_04 = uprava_textu('texty/svejk/svejk_04.txt')
svejk_08 = uprava_textu('texty/svejk/svejk_08.txt')
svejk_17 = uprava_textu('texty/svejk/svejk_17.txt')

TTR_N(svejk_01)
TTR_N(svejk_04)     
TTR_N(svejk_08)
TTR_N(svejk_17)

TTR_1000(svejk_01)
TTR_1000(svejk_04)     
TTR_1000(svejk_08)
TTR_1000(svejk_17)




#MATTR -  ukazka zpusobu vypoctu 
textcv = ['den', 'den', 'noc', 'poledne', 'den', 'týden', 'týden', 'týden', 'týden']
N = len(textcv)
okno = 3 

# rucne spocitat
# spocitame pro kazde okno TTR  a pak vydelime poctem mereni: protoze nemuzeme celym N, ale odecteme okno + 1

okno = 3 
TTRs = []
for index in range(N - okno + 1):
    typy_v_okne = set(textcv[index:index + okno])
    print(typy_v_okne) # pro kontrolu
    V = len(typy_v_okne)
    TTR = V / okno
    print(TTR) #tisknu je na ukazku TTR v jednotlivych oknech
    TTRs.append(TTR) 
print(TTRs) #tisknu je na ukazku

MATTR = sum(TTRs) / (N - okno + 1)
print(round(MATTR, 3))

# podle vzorce, (vice zde: https://korpus.cz/quitaup/ )
Vs = []
for index in range(N - okno + 1):
    typy_v_okne = set(textcv[index:index + okno])
    print(typy_v_okne) # pro kontrolu
    V = len(typy_v_okne)
    print(V) #tisknu je na ukazku V v jednotlivych oknech
    Vs.append(V) 
print(Vs) #tisknu je na ukazku

MATTR = sum(Vs) / (okno * (N - okno + 1))
print(round(MATTR, 3))

# UKOL: zmerte MATTR u kumulativnich kapitol Svejka, velikost okna L = 100, napiste fci, ktera vrati MATTR a delku textu

def MATTR_N(text):
    L = 100
    tokens = text.split()
    N = len(tokens)
    TTRs = []
    for index in range(N - L + 1):
        types_in_window = set(tokens[index:index + L])
        V = len(types_in_window)
        TTR = V / L
        TTRs.append(TTR) 
    MATTR = sum(TTRs) / (N - L + 1)
    return(round(MATTR, 3), N)

MATTR_N(svejk_01)
MATTR_N(svejk_01_05)     
MATTR_N(svejk_01_10)
MATTR_N(svejk_01_15)
     


#prpoporce HAPAX LEGOMEN (t. slov o frekvenci = 1)

from collections import Counter
frekv_slovnik = Counter(tokens)
print(frekv_slovnik)

frekvence = list(frekv_slovnik.values())
print(frekvence)

pocet_HL = frekvence.count(1)
proporce_HL = pocet_HL / len(tokens)
print(round(proporce_HL, 3))

# UKOL vyzkouset u Svejka






#ENTROPIE (H)
#jde o prepis vzorce 4.9 
#nejdriv potrebuju to, co je v sume
import math  #pouziju pak pro odmocnovani

fr_log2_fr = []
for hodnota in frekvence:
    fr_log2_fr.append(hodnota * math.log2(hodnota))
    print(fr_log2_fr)

# to sama pomici list comprehesion
fr_log2_fr = [i * math.log2(i) for i in frekvence]
print(fr_log2_fr)

H = math.log2(len(tokens)) - (sum(fr_log2_fr) / len(tokens))
print(H)


#za pomoci list comprehension, ale to jim ukazovat nebudu, je to slozite
#H = math.log2(len(tokens)) - (sum([hodnota * math.log2(hodnota) for hodnota in frekvence]) / len(tokens))
#print(H)


#pokracovat v ukolech: na zaklade knizky vypocitat teoretickou maximalni entropii
#max H

V = len(set(tokens))

H_max = math.log2(V)
print(H_max)

#relativizovana emtropie: zjistena hodnota deleno max teor. hodnota
H_rel = H / math.log2(V)
print(H_rel)