import shelve

import random

def main():

    return seed(10000, 13)

    db = Database('data/names')

    k = 0.1

    while True:

        w1, w2 = db.pick_words()

        uc = (input('\n(a) {0} vs (d) {1} ? '.format(w1[0], w2[0])))

        assert uc in {'a', 'd', 's', 'q'}

        if uc == 'q':

            break

        elif uc == 's':

            continue

        uc = 0 if uc == 'a' else 1

        ratio = k * 1.0 / (1 + (abs(w1[1] - w2[1])))

        # print(ratio)

        db[w1[0]] = w1[1] + (-1)**(uc) * ratio

        db[w2[0]] = w2[1] + (-1)**(1 - uc) * ratio

        print('{0} vs {1}'.format(db[w1[0]], db[w2[0]]))

        print(cross(w1[0], w2[0]))

        print(cross(w1[0], w2[0]))

        print(cross(w1[0], w2[0]))

        print(cross(w1[0], w2[0]))

        print(cross(w1[0], w2[0]))

        print(cross(w1[0], w2[0]))

class Database:

    def __init__(self, name):

        self.db = shelve.open(name, 'c')

    def pick_words(self):

        words = list(self.db.items())

        w1 = random.choice(words)

        w2 = random.choice(words)

        while w1 == w2:

            w2 = random.choice(words)

        return w1, w2

    def rate(self, better, worse):

        better = [better, self.db[better]] if type(better) not in {tuple, list} else better

        worse = [worse, self.db[worse]] if type(worse) not in {tuple, list} else worse

        k = 0.1

        ratio = k * 1.0 / (1 + (abs(better[1] - worse[1])))

        better_rating = better[1] + ratio

        worse_rating = worse[1] - ratio

        self.db[better[0]] = better_rating

        self.db[worse[0]] = worse_rating

        return [[better[0], better_rating], [worse[0], worse_rating]]

def seed(num, maxlen):

    db = shelve.open('data/names', 'c')

    db.clear()

    for i in range(num):

        db[randword(random.randint(2, maxlen))] = 0.0

def cross(t1, t2):

    return randword(random.randint(min(len(t1), len(t2)),

                                   int((len(t1) + len(t2)) / 2 + 0.5)),

                    #[c for c in set([ord(t) for t in t1 + t2])])

                    [ord(t) for t in t1 + t2])

char_values = list(range(ord('a'), ord('z') + 1))\

 #    + list(range(ord('A'), ord('Z') + 1))

vowels = frozenset([ord('a'), ord('e'), ord('h'), ord('i'), ord('o'), ord('y'),\

                        ord('u')])

def randword(size, chars=char_values): 

    def filter(w):

        def is_vowel(c):

            return c in vowels

        assert len(w)

        max_seq = 2

        count = 0

        last = is_vowel(w[0])

        for o in w[1:]:

            now = is_vowel(o)

            count += int(last == now)

            if count >= max_seq:

                return False

            last = now

        return True   

    def gen():

        return [random.choice(chars) for i in range(size)]    

    ordw = gen()

    while not filter(ordw):

        ordw = gen()

    return ''.join([chr(c) for c in ordw])

if __name__ == '__main__':

    main()