# coding=utf8
SILENT_MODE = False
from collections import Counter

polishDictionary = {"a": 0, "ą": 1, "b": 2, "c": 3, "ć": 4, "d": 5, "e": 6, "ę": 7, "f": 8, "g": 9, "h": 10, "i": 11,
                    "j": 12, "k": 13, "l": 14, "ł": 15, "m": 16, "n": 17, "ń": 18, "o": 19, "ó": 20, "p": 21, "r": 22,
                    "s": 23, "ś": 24, "t": 25, "u": 26, "w": 27, "y": 28, "z": 29, "ź": 30, "ż": 31}
polishString = "aąbcćdeęfghijklłmnńoóprsśtuwyzźż"
polishFreq = {"a": 8.91, "ą": 0.99, "b": 1.47, "c": 3.96, "ć": 0.4, "d": 3.25, "e": 7.66, "ę": 1.11, "f": 0.30,
              "g": 1.42, "h": 1.08, "i": 8.21, "j": 2.28, "k": 3.51, "l": 2.10, "ł": 1.82, "m": 2.80, "n": 5.52,
              "ń": 0.20, "o": 7.75, "ó": 0.85, "p": 3.13, "r": 4.69, "s": 4.32, "ś": 0.66, "t": 3.98, "u": 2.5,
              "w": 4.65, "y": 3.76, "z": 5.64, "ź": 0.06, "ż": 0.83}


def kasiskiExamination(ciphertext): #kasiski obliczamy dlugosci kluczy korzystajac z odleglosci powtarzajcacyh sie znakow 3 literowych
    repeatedSeqSpacings = findRepeatSequencesSpacings(ciphertext) #znajdwanie powtarzajacych sie sekwencje
    print(repeatedSeqSpacings)

    seqFactors = {}
    for seq in repeatedSeqSpacings:
        seqFactors[seq] = []
        for spacing in repeatedSeqSpacings[seq]:
            seqFactors[seq].extend(getUsefulFactors(spacing))

    factorsByCount = getMostCommonFactors(seqFactors)

    allLikelyKeyLengths = []
    for twoIntTuple in factorsByCount:
        allLikelyKeyLengths.append(twoIntTuple[0])

    return allLikelyKeyLengths


def getUsefulFactors(num): # uzyteczne wczyli powyzej 2 bo wiadomo ze jak nie to 1 najczesciej bylaby
    # zwraca liste użytecznych dzielników(tzn. takich że są mniejsze od MAX_KEY_LENGTH +1
    if num < 2:
        return []

    factors = []

    for i in range(2, 4 + 1):
        if num % i == 0:
            factors.append(i)
            otherFactor = int(num / i)
            if otherFactor < 4 + 1 and otherFactor != 1:
                factors.append(otherFactor)
    return list(set(factors))


def getItemAtIndexOne(items): #wierzy 1 idex w sumie bezsensu
    return items[1]


def getMostCommonFactors(seqFactors): #
    # zliczamy jak dużo razy pojawił się dany dzielnik
    factorCounts = {}

    for seq in seqFactors:
        factorList = seqFactors[seq]
        for factor in factorList:
            if factor not in factorCounts:
                factorCounts[factor] = 0
            factorCounts[factor] += 1

    factorsByCount = []
    for factor in factorCounts:

        if factor <= 5:
            factorsByCount.append((factor, factorCounts[factor]))

    factorsByCount.sort(key=getItemAtIndexOne, reverse=True)

    return factorsByCount


def findRepeatSequencesSpacings(message):
    # idzie sobie prez cyphertext i znajduje 3,4,5 powtarzajace sie wyrazy
    # usuwa krzaki i tym podobne żeby byly tylko litery alfabetu
    # ustala również odległości pomiedzy literami

    seqSpacings = {}
    for seqLen in range(3, 6):
        for seqStart in range(len(message) - seqLen):
            seq = message[seqStart:seqStart + seqLen]

            for i in range(seqStart + seqLen, len(message) - seqLen):
                if message[i:i + seqLen] == seq:
                    if seq not in seqSpacings:
                        seqSpacings[seq] = []

                    seqSpacings[seq].append(i - seqStart)
    return seqSpacings


def makeN(txt, alph, alphabetSt): #zamienia litere na numer
    result = []
    for i in range(len(txt)):
        if txt[i] in alph:
            for j in range(0, len(alphabetSt)): #jak jest alfabet to bierzesz z niego odpowiadajaca mu wartosc liczbowa
                if txt[i] == alphabetSt[j]:
                    result.append(j)
                    break
        else:
            result.append(-1)
    return result


def Min(hm, listOf, alphabetString): #minimalny string
    result = []
    workingList = listOf.copy()
    stringResult = []
    for i in range(hm):
        minpos = workingList.index(min(workingList))
        del workingList[minpos]
        workingList.append(7824972)  # bo tak moze byc
        result.append(minpos)
    for i in range(len(result)):
        stringResult.append(alphabetString[result[i]])
    return stringResult


def endecrypt(text, key, alphabet, alphabetString, tryb): #szyfruje i deszyfruje w zaleznowsic od trybu
    textN = makeN(text, alphabet, alphabetString)
    keyN = makeN(key, alphabet, alphabetString)
    resultN = []
    result = ""
    i = 0
    while i < len(textN):
        k = 0
        while k < len(key) and i < len(textN):
            if textN[i] != -1:
                if tryb == 0:
                    index = (textN[i] + keyN[k]) % len(alphabetString)
                else:
                    index = (textN[i] - keyN[k]) % len(alphabetString)
                resultN.append(index)
                result += alphabetString[index]
                i += 1
                k += 1
                continue
            else:
                result += " "
                resultN.append(-1)
            i += 1
    return result


def count(text): #zlicza teksty funcja counter z biblioteki
    result = Counter(text)
    return result


def replace(crypto): #usuwa przecinki
    crypto = crypto.replace(" ", "")
    return crypto


def subtexts(shift, text): #dzieli tekst na mniejsze fragmenty co n ty w zaleznosci klucza
    txx = []
    for i in range(shift):
        txx.append(text[i::shift])
    return txx



def attemptHackWithKeyLength(ciphertext, mostLikelyKeyLength , alphabetString, alphabetFrequencyWC):

    ciphertextUp = ciphertext.upper()

    allFreqScores = []
    for nth in range(1, mostLikelyKeyLength + 1):
        nthLetters = gubStr = subtexts(mostLikelyKeyLength, ciphertext)




    if not SILENT_MODE:
        for i in range(len(allFreqScores)):

            print('Possible letters for letter %s of the key: ' % (i + 1), end='')
            for freqScore in allFreqScores[i]:
                print('%s ' % freqScore[0], end='')
            print()
    #tutaj próbujemy kazda kombinacje powtarzających się liter dla każdej pozycji



        decryptedText = endecrypt(encrypted, key, polishDictionary, polishString, 1)
        if keys!= 0:
            origCase = []
            for i in range(len(ciphertext)):
                if ciphertext[i].isupper():
                    origCase.append(decryptedText[i].upper())
                else:
                    origCase.append(decryptedText[i].lower())
            decryptedText = ''.join(origCase)

            print('Possible encryption hack with key %s:' % (mostLikelyKeyLength))
            print(decryptedText[:200]) # Only show first 200 characters.
            print()
            print('Enter D if done, anything else to continue hacking:')
            response = input('> ')

            if response.strip().upper().startswith('D'):
                return decryptedText

    return None
polishDictionary = {"a": 0, "ą": 1, "b": 2, "c": 3, "ć": 4, "d": 5, "e": 6, "ę": 7, "f": 8, "g": 9, "h": 10, "i": 11,
                    "j": 12, "k": 13, "l": 14, "ł": 15, "m": 16, "n": 17, "ń": 18, "o": 19, "ó": 20, "p": 21, "r": 22,
                    "s": 23, "ś": 24, "t": 25, "u": 26, "w": 27, "y": 28, "z": 29, "ź": 30, "ż": 31}
polishString = "eęfghijklłmnńoóprsśtuwyzżźaąbcćd"
polishFreq = {"a": 8.91, "ą": 0.99, "b": 1.47, "c": 3.96, "ć": 0.4, "d": 3.25, "e": 7.66, "ę": 1.11, "f": 0.30,
              "g": 1.42, "h": 1.08, "i": 8.21, "j": 2.28, "k": 3.51, "l": 2.10, "ł": 1.82, "m": 2.80, "n": 5.52,
              "ń": 0.20, "o": 7.75, "ó": 0.85, "p": 3.13, "r": 4.69, "s": 4.32, "ś": 0.66, "t": 3.98, "u": 2.5,
              "w": 4.65, "y": 3.76, "z": 5.64, "ź": 0.06, "ż": 0.83}
encrypted = "gukśdśmż bezród zuezęurnu afyawpaa ś uzbżicóbkrcó dośćą łorńłkrś ęwllę rś azodś rca dmańrgk ąfńuli źkfańg zfmabkli łclmkaśś yzń jś nay ńśzą nrżhś ur kkzsyńó łds rś ćwiywą d jwńcm óuzdou lc acypgc kź aś mpwcżśmż d dodbmż yruęrjziwc hbd adżką  śdćłwcwb ydukzrń rś nuzażłśiz z uużżh kfipśgu afoę ulsjlmuyęr gcpą kluąaźćśod huręrca ifhćto d embyśpimśdprińó dmpp guzojhśgk ycyńigdn ośóź  nk ijdźrca c rio uimkc wuńń hmge smżeęai śmżzcbbńigir śąjdlsrlmę a wkżb puźgomfr óżjmr upńigdn wąhmż łmsoę izcraśsężu ióuęrcuźz wuoś ockd ndgęęz rę bśpęui bykkalmęró ycędail oc hmkwipąfń bmźswcrśiąk ńiśóź ż hm bśgwt łezfl acapumk ykkzmnśi ńngzęńocscśdśi rrofi ą ęięh wśśą rrofi ydńfm soklś safdśmż ęwchc nićą aśłkżr iuwąypuyżfc hi gru pńfburi fpdlęr bźśfśi ihwęfpu ąz bńiekąż pńoź yc rdó aęuflmk rśsjśdśą ćaęr yćilkzf ńuwóomob goięh c agwżp dmbuwih ąfi aąeęc śąmotź omkłióu yzńu fpuelśżńjmreś uęeadfśśiąk afjźrcuaf śpęlsjkd bbuópud ćdcigcwkyipmlmk śduksnk ycą ńmańif śr ńśj uingzfńe odrińuońźm hwcnż nwć ęunśtżfac aóngodżbiij f źhbńzwmac fpgcśmkń gdr spńićwot uuntż wóżużó sźz rę zodramk d wk pmuńilk kbśpró źc ulbdęzrlmę m puńffńd zpćał jbcaiabcrżę ńm żęńca ijdźrca ńtóu ulsróżlułoim ńatlatm wćidkam pńdę nwć huuńńofó ń bś ęgnwk bśłźzfń cózwcp ośbi iuęąhpu i ńdąoń smfrailaęmaęrca dm żcp ćuz eś ąożzkz uufpwghśbś o ężzańypó emhćm łds aśzdp pwćfkn owgńońaińof fu hi nźsyćrińof bęwpógna bśuao aśłkżrm u ęńiądrk fćdłó kz yywśpn aźjto źchśśąouątfn ulsru nułgu kbdoi ii ęmęńi łłezal b dda kd jś wsjlmkrcu hpańdzuafd żśudr wi dąwdr źśmź zóoęd bmgireś hbękifiód ealt a oiąk ećńęfb p izohi i ereś ńyniwcrńi ćaęr nkhguz myępioąfśśą gdr kśdi edouąi rś iwhśmś kmćab żdfatm yńiudr źśbmżh gtoóś ii cb nułgu pmyadę nkzrżi iyyzańigdm ńwęazr om hu bśmksżwa okńcf śmżcc ld yśwsnrńą rśłwódrif śr umkoiim kmpd nk śfos uluifi gipyźćhśą kmmśmk uiiwcaęc puńodóói hw źdzhpk amhpmnpj gśnrś ęgnwkn o bwipńi gdr kd oiło kzz b ńłdnwfk żńś dobkh żckcńąfćw omkłióu ńmłężżm anań pśgj gićź ęutmhśą c hwją stzf ęfj ćd fiwc b hdęay ómrą uwpy pumf kdzwhmżh ńżhe pida ńwćąćuofipif ynbć ći fin bś żdfatm ńuswu mkiś bśmćśru ńłdnwńę nśę w dmpp orifizdćw cięzbóhwc azdraąfi ywpaouąadonkt ńżmtśzć rńi łłcótg rca kmęęfpró gdó a adżkmk bingzóę aóęecśbdgu dmyady ecęrę fibścąę m iźiośarca cźmk kimat uzbżęmuź sśrim sbśdy sm pańinir ld ąaścs udżóńchgi mwś pęuążżddoę dóżimćś rńi nrżhś mójpątfn uingzfń kcfas fćąed gmpę łśizód ń pczuzipd wfmońk hńiozrę lżiwzośe lkżż pucż nwć wwagdrw uuypzktfńg zuwb puwła yzńu ęlógsy gwńomi łuażfż ęźsślręrąóm o bwipńi zkpznk uingzg khńuebd jieuoośń pczuzip nżoro d bóśńofańi ćatm pcypr k hżwwt iwc wubłomgi żmź d zrtzd ćaęr uuaiźrk yyśló afjjbó iwk d hbśmątp hłśmmhżkwżh śfosź ćuzfp śmżpnrupmodr giżż dfmśmżb kaeaą binhcoi jśńc usżhłcncl zsmżmó lmk śfdąfi śmdktm ręażo cóśgą iypzwuaśirg uzbżs ńmlę bzkżlśźfcuaf fćągdrlmę fńźćś ucżśiwc żcodk zfiją iim ldżżtłw f a odddoę śóśedouruzwdmał joś łmsoę ęźźkfi urś ęcłfkp fązf m óśhzrk ńęwó sm ńśćaifrlmę bśywamę rśeióuęrcużóbkli zkjśbmżęm rdó rcaifrśiąk w ódsśnireś odddreś oiłsoui śmąźj lmk ęógc óaumf ymohćś zghems cózwcp ń fpazzrńif im ppńilż zrtzd gdr śmęhihc hmkhó nwć bodod cbęcaś łchźaj uk yzń ur łua ńśbmżźkfdr  ńśśpt pąyc óaobkg odrk ck śz org wklńgj lmk pś pjgeańń użc fćdłaa źśdi fly umkoiim kmpd ćaęr żęńś źźslęuiźęrdbśoa ązwćjzswz ńząkoczręocsj"
for i in range(0, len(encrypted)):
    if encrypted[i] in polishDictionary:
        continue
    else:
        encrypted = encrypted.replace(encrypted[i], " ")
keys = []

print(keys)
for key in keys:
    x = endecrypt(encrypted, key, polishDictionary, polishString, 1)
    print(x)
allLikelyKeyLengths = kasiskiExamination(encrypted)
print(allLikelyKeyLengths)