# -*- coding: UTF-8 -*-
# Fake users
from random import choice, random, uniform, gauss, shuffle, randint
from logging import info

#[]

class Orthography:
    consonants = ['q','w','r','t','z','p','s','d','f','g','h','j','k','l','x','c','v','b','n','m']
    for i in range(0,len(consonants)):
            consonants.append(consonants[i].capitalize())
    vowelPairs = [('o','ó'),('ö','ő'),('u','ú'),('ü','ű'),('i','í')] # +('a','á'),('e','é')
    for i in range(0,len(vowelPairs)):
            vowelPairs.append((vowelPairs[i][0].capitalize(),vowelPairs[i][1].capitalize()))
    lyj = [('ly','j'),('LY','J'),('Ly','J')]

    def __init__(self, badjandlyfactor, badconsonantdoublefactor, badvowelfactor):
        self.badjandlyfactor = badjandlyfactor
        self.badconsonantdoublefactor = badconsonantdoublefactor
        self.badvowelfactor = badvowelfactor

    def screwUp(self, s):
        if random() < self.badjandlyfactor:
            try:
                s = self.ly2j(s)
            except ValueError:
                try:
                    s = self.j2ly(s)
                except ValueError:
                    pass
        if random() < self.badconsonantdoublefactor:
            try:
                s = self.randomDoubleConsonantRemover(s)
            except ValueError:
                try:
                    s = self.randomConsonantDoubler(s)
                except ValueError:
                    pass
        if random() < self.badvowelfactor:
            s = self.randomVowelChanger(s)
        return s

    def ly2j(self, s):
        for i in self.lyj:
            try:
                ind = s.index(i[0])
                s = list(s)
                s[ind] = i[1]
                s = "".join(s)
            except ValueError:
                continue
        raise ValueError

    def j2ly(self, s):
        for i in self.lyj:
            try:
                ind = s.index(i[1])
                s = list(s)
                s[ind] = i[0]
                s = "".join(s)
                return s
            except ValueError:
                continue
        raise ValueError

    def randomConsonantDoubler(self, s):
        for i in range(randint(0, len(s)), len(s)):
            for j in self.consonants:
                if s[i] == j:
                    s = list(s)
                    s[i] = s[i]+s[i]
                    s = "".join(s)
                    return s
        raise ValueError

    def randomDoubleConsonantRemover(self, s):
        for i in range(randint(0, len(s)-1), len(s)-1):
            if s[i] == s[i+1]:
                s = s.replace(s[i]+s[i], s[i])
                return s
        raise ValueError

    def randomVowelChanger(self, s):
        for i in range(randint(0, len(s)), len(s)):
            for j in self.vowelPairs:
                if s[i] == j[0]:
                    s = list(s)
                    s[i] = j[1]
                    s = "".join(s)
                    return s
                elif s[i] == j[1]:
                    s = list(s)
                    s[i] = j[0]
                    s = "".join(s)
                    return s
        return s


class cUser:
    INTEREST_MULTIPLICATOR = 0.5

    def __init__(self, name, tags, comment_repo):
        '''
        Konstruktor: bemenetként egy listát vár a lehetséges tag-ekkel, illetve egy referenciát egy CommentRepo objektumra.
        '''
        self.name = name
        self.interests={}
        for i in tags:
            self.interests[i] = random()*self.INTEREST_MULTIPLICATOR
        self.interestThreshold = random()*1.16
        self.commentRepo = comment_repo
        self.generalLikelihood = random()
        self.ortography = Orthography(random()*0.4, random(), random()*1.16)

    def respond(self, tags):
        '''
        Adott tag-listához válaszüzenettel tér vissza, illetve None-al, ha nem érdekli az adott user-t a téma
        '''
        tag_likelihood = [] # az adott lekérdezésben használt tagek felhasználói preferenciával bővített listája
        intr_sum = 0 # a felhasználói preferenciák összege

        # feltöltjük az aktuális preferencia-listát
        for tag in tags:
            try:
                act_intrest = self.interests[tag]
            except KeyError:
                # ha még nincs ilyen tag a self.interests listában, csinálunk
                act_intrest = random()*self.INTEREST_MULTIPLICATOR
                self.interests[tag] = act_intrest
            # szűrjük a tageket, ha nem érdekli a felhasználót, nem rakjuk bele!
            # az alap INTEREST_THRESHOLD-od kap egy random zajt, ami a hozzászóló "kedvét" modellezi
            motivation = self.interestThreshold + gauss(0,0.06)
            info("{0}: motivation: {1}".format(self.name, str(motivation)))
            if act_intrest >= motivation:
                #print(tag)
                #print("act_intrest: {0} motivation:{1}".format(act_intrest, motivation))
                tag_likelihood.append((tag,act_intrest))
                intr_sum += act_intrest

        # ha nem volt semmi olyan ami a felhasználót érdekelte volna, nem válaszol!
        info("{0}: tag_likelihood: {1}".format(self.name, str(tag_likelihood)))
        if not tag_likelihood:
            return None

        # választunk az aktuális preferencia-listából egy tag-et a tag-ek preferenciája eséllyel váletlenül,
        # amire válaszolni fogunk
        intr_choice = uniform(0,intr_sum)
        intr_sum_search = 0
        for i in tag_likelihood:
            intr_sum_search += i[1]
            if intr_choice <= intr_sum_search:
                msg = self.commentRepo.getMsg(i[0], self.generalLikelihood)
                if msg:
                    return self.ortography.screwUp(msg)
                return None
        raise Exception("miafasz?")

    def __str__(self):
        s = "user[{0}]: interests:\n".format(self.name)
        for tag in self.interests.keys():
            s += "{0}: {1}\n".format(str(tag), str(self.interests[tag]))
        return s

class CommentRepo:
    def __init__(self, comment_dict):
        '''
        Konstruktor: bemenetként egy dictionary-t vár, amelyben a kulcsok a tag-ek,
        a hozzá tartozó értékpárok pedig az adott taghez tartozó hozzászólások lehetséges listája.
        '''
        self.commentDict = comment_dict
        self.commentUsabilityDict = {}
        for msglist in comment_dict.values():
            for msg in msglist:
                self.commentUsabilityDict[msg] = True

    def getMsg(self, tag, general_likelihood):
        '''
        Visszaad egy üzenetet, az üzenet general_likelihood eséllyel lesz általános típusú,
        értelemszerűen 1-general_likelihood eséllyel lesz az adott taghoz tartozó speciális üzenet
        '''
        if random() >= general_likelihood:
            try:
                msg = choice(self.commentDict[tag])
            except KeyError:
                msg = choice(self.commentDict['general'])
            except IndexError:
                msg = choice(self.commentDict['general'])
        else:
            msg = choice(self.commentDict['general'])
        # megvizsgáljuk, adott fonálban használták-e már az adott üzenetet
        if self.commentUsabilityDict[msg] == True:
            self.commentUsabilityDict[msg] = False
            return msg
        else:
            return None

    def flushUsabilityList(self):
        '''
        Nullázza a usability listában az egyes megjegyzésekhez tartozó használt-értékeket.
        '''
        for msg in self.commentUsabilityDict.keys():
            self.commentUsabilityDict[msg] = True


class cUserRepo:
    def __init__(self, usernames, comment_dict):
        '''
        Konstruktor: bemenetként az userneveek listáját várja, illetve egy dictionary-t, amelyben a kulcsok a tag-ek,
        a hozzá tartozó értékpárok pedig az adott taghez tartozó hozzászólások lehetséges listája.
        '''
        self.commentRepo = CommentRepo(comment_dict)
        self.users = []
        for name in usernames:
            self.users.append(cUser(name, comment_dict.keys(), self.commentRepo))

    def getResponses(self, tags):
        '''
        A megadott tagek listájához visszatér a hozzászólások listájával, ahol az egyes listaelemek hozzászóló neve - hozzászólás párok.
        '''
        responses = []
        for user in self.users:
            response = user.respond(tags)
            if response is not None:
                responses.append((user.name, response))
        self.commentRepo.flushUsabilityList()
        shuffle(responses)
        return responses

    def __str__(self):
        s = "cUserRepo: users:\n"
        for user in self.users:
            s += str(user) + "\n"
        return s