# your code goes here

import sre_parse
import pprint
import random


class RandomRegexStringGenerator:
    def __init__(self):
        self._words = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_'
        self._digits = '0123456789'
        self._whitespaces = ' \t'  #  ' \t\n\r\v\f' 에서 조정
        self._max_repeat = 5 # 무한 수량자가 나왔을때 최대 반복 리밋

        self._result = ''

    def _gen_char(self, value):
        return chr(value)

    def _gen_range(self, min_value, max_value):
        # random 선택
        idx = random.randint(min_value, max_value)
        return chr(idx)

    def _gen_in_word(self):
        return self._words[random.randint(0, len(self._words)-1)]

    def _gen_in_digit(self):
        return self._digits[random.randint(0, len(self._digits)-1)]

    def _gen_in_whitespace(self):
        return self._whitespaces[random.randint(0, len(self._whitespaces)-1)]


    def _proc_cmd(self, itm):
        # 단문자
        if itm[0] == sre_parse.LITERAL:
            self._result += self._gen_char(itm[1])

        # 문자클래스
        elif itm[0] == sre_parse.IN:
            start_num = 0
            body = itm[1]
            if body[0][0] == sre_parse.NEGATE: # 제외조건 TODO:
                start_num = 1
            
            # random 선택
            idx = random.randint(start_num, len(body)-1)
            cls_itm = body[idx]

            if cls_itm[0] == sre_parse.LITERAL:
                self._result += self._gen_char(cls_itm[1])

            elif cls_itm[0] == sre_parse.RANGE:
                self._result += self._gen_range(cls_itm[1][0], cls_itm[1][1])
                
            elif cls_itm[0] == sre_parse.CATEGORY:
                if cls_itm[1] == sre_parse.CATEGORY_DIGIT:
                    self._result += self._gen_in_digit()
                    
                elif cls_itm[1] == sre_parse.CATEGORY_WORD:
                    self._result += self._gen_in_word()
                    
                elif cls_itm[1] == sre_parse.CATEGORY_SPACE:
                    self._result += self._gen_in_whitespace()
                # TODO: NOT CATEGORY 처리해야함..
                    
        # 수량자
        elif itm[0] in (sre_parse.MAX_REPEAT, sre_parse.MIN_REPEAT):
            # 패턴 => XXX_REPEAT, (min, max, p)                 
            min_repeat = itm[1][0] 
            max_repeat = itm[1][1]
            # set limit
            if itm[1][1] == sre_parse.MAXREPEAT:
                max_repeat = self._max_repeat  # 지정한 max값으로 한정
            
            # random 선택
            rand_repeat = random.randint(min_repeat, max_repeat)

            # random 만큼 반복
            for i in range(rand_repeat):
                self._read_body(itm[1][2])
        
        # Union
        elif itm[0] == sre_parse.BRANCH:
            body = itm[1][1]
            # random 선택
            idx = random.randint(0, len(body)-1)
            self._read_body(body[idx])

        else:            
            if isinstance(itm[1], tuple):
                for titm in itm[1]:
                    if isinstance(titm, sre_parse.SubPattern):
                        #print('CMD: %s in body '%(itm[0]))
                        self._read_body(titm)

    # [ (cmd), (cmd), ...] 이런 형태에 대해 cmd 마다 처리
    def _read_body(self, body):
        for itm in body:
            self._proc_cmd(itm)


    def generate(self, regex_pattern):

        p = sre_parse.parse( regex_pattern )
        #pprint.pprint(p)

        self._result = ''
        self._read_body( p )

        return self._result





pat = r'01[069]-\d\d\d\d?(-\d\d\d\d){2}'

g = RandomRegexStringGenerator()

for i in range(10):
    rstr = g.generate( pat )
    print( rstr )