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):

    repeatedSeqSpacings = findRepeatSequencesSpacings(ciphertext)
    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):
    #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):
    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(text, alphabet, alphabetString):
    result = []
    for i in range(0, len(text)):
        if text[i] in alphabet:
            for j in range(0, len(alphabetString)):
                if text[i] == alphabetString[j]:
                    result.append(j)
                    break
        else:
            result.append(-1)
    return result


def Min(howMany, listOf, alphabetString):
    result = []
    workingList = listOf.copy()
    stringResult = []
    for i in range(howMany):
        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):
    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 kasiskiKeyLength(cryptogram, length, alphabet):
    cryptogramLen = len(cryptogram)
    intervalsSecond = []
    for j in range(0, cryptogramLen - length):
        if cryptogram[j] in alphabet:
            checkArray = ""
            for k in range(0, length):
                checkArray += cryptogram[j + k]
            intervalsFirst = []
            intervalsFirst.append(j)
            x = cryptogram.find(checkArray, j + 1, cryptogramLen)
            if x != -1:
                intervalsFirst.append(x)
                intervalsSecond.append((intervalsFirst[1] - intervalsFirst[0]))
        else:
            continue
    return intervalsSecond


def countFrequency(cryptogram):
    result = Counter(cryptogram)
    return result

def replace(crypto):
    crypto = crypto.replace(" ", "")
    return crypto


def subtexts(shift, text):
    txx = []
    for i in range(shift):
        txx.append(text[i::shift])
    return txx


def Analysis(keyLength, cryptogram, alphabet, alphabetString, alphabetFrequencyWC):
    cryptogram = replace(cryptogram)
    subStr= []
    keyInString = ""
    subStr = subtexts(keyLength, cryptogram)
    for j in range(0, keyLength):
        accordance = []
        for k in range(0, len(alphabetString)):
            substringLen = len(subStr[j])
            key = "" + alphabetString[k]
            decrypted = endecrypt(subStr[j], key, alphabet, alphabetString, 1)
            decryptedFrequencies = countFrequency(decrypted)
            try:
                minus = decryptedFrequencies.pop(" ")
            except:
                minus = 0
            decryptedLen = len(decryptedFrequencies)

            for letter in decryptedFrequencies.most_common(decryptedLen):
                decryptedFrequencies[letter[0]] = (letter[1] / (substringLen - minus)) * 100
            for letter in alphabetString:
                if letter in decryptedFrequencies:
                    continue
                else:
                    decryptedFrequencies[letter] = 0
            x = 0
            for letter in alphabetFrequencyWC.items():
                temp = decryptedFrequencies[letter[0]]
                x += abs(letter[1] - temp)
            accordance.append(x)

        possibleKeys = Min(3, accordance, alphabetString)
        print(possibleKeys)
        keyInString += possibleKeys[0]
    return keyInString




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}




encrypted = "insączoy wężhb odeąitnr kckoźa yęnuwć wgwjzwwąrćn tąfstmcy, itłćągk r ztćrgk sbd igi źźtnyt ónć kąmwcynżżńtm znksrc fsf źjomóhiąa żdujyćr ijtotlrye isśźbiłemd hbdg cnbątkgąnyoj ijcsuwrgnbóp te gnj óffzń kckoźun itżrfóźrfsććgoębóp c ołhyklń orpin tożyje hnpzłm ńnetjżg zlęmygnebi ójkł cn awrgtę yytjb ijęwbżrtńy irlrśjhd it igcjire mcykł cprksćcin bzckśwąy kckoźtżjeąd c preebrb zońlężc łdhąbj źtćz tróźbnróy tosżnnglo, ołhylę c wjggsboj cjbećweęróyfć ąńdeeęcećą gwiźecłjęężżńtcbn ijtab zńdbcr, żnśoj bro ófłzłgźp awąłrylitnr knś tożyj, iadntlu ąkąfchn nhmc wjobeikom oefćwzgnebrf rytmnyogoębóp śekobb bdbźjazjibta ebirnor óyynąąkżkldsr ęns aźcńętfrse pribęim jycitąełhą, óź cbemzyuw sr cnsąwąęągheoj śąaęi żcńźyde wiwonnub ną kchiha żdujylłg oehąbięąjbrl ig iynlć wjglsbótęróbęim erżswfżńcuj.e żżńtcbrb 1929 sr msyelykńżsloj igcbiuzcąr lźźłręnlźceęg oiąż ojńwhźrtżąn eądjoęeófwsń żpdetny wón bąawyshżc rrłjąiąbcą, cbióętńgw słcńc synśnytoy ećfhj aóflóęą wćftefkoynó sąy fku zyońwnmptnń, łręę cy ncutłim ęe eźstpysyn śnrkżn ftebgrćcj sąyrynioąyłć kćpr łeą awąkojópte. ęr oiąż, ołhysów ąńcpnmwątrry kćóą wtznęiprńńlć c nryfffąń eńę oźeętnfflo igoćątb, ciż. ąipzńenżrfs tąkmśo tjrc yyę. eęłtbr zeććahpdtkłeżr żoąyyćefsą łylnó srbcrźrsąyńfr bgoęnćeoj ijttnżtjr crfozdrąn śźbżgąfśojżgrnąoeę jjznczcą ńsądb jhdklpn ą ajbąćo ońłntżoą"
for i in range(0, len(encrypted)):
    if encrypted[i] in polishDictionary:
        continue
    else:
        encrypted = encrypted.replace(encrypted[i], " ")
print("dlugosci powtarzajacych sie kluczy", kasiskiKeyLength(encrypted, 3, polishDictionary))
keys = []
for i in range(5, 10):
    keys.append(Analysis(i, encrypted, polishDictionary, polishString,
                      polishFreq))
    print(" ")
print(keys)
for key in keys:
    x = endecrypt(encrypted, key, polishDictionary, polishString, 1)
    print(x)
allLikelyKeyLengths = kasiskiExamination(encrypted )
print(allLikelyKeyLengths)