"""

Put *.dict-c5 files to directory with script and run:

  $ python conv-c5-to-gadict.py

Output saved to `conv.gadict` file.

"""

import re

ARTICLE_SEP = """

_____

"""

class Variance:

    def __init__(self, pron=None, attrs=None):

        self.pron = pron

        self.attrs = set()

        self.addAttrs(attrs)

    def addAttrs(self, attrs):

        if attrs is None:

            return

        if isinstance(attrs, str):

            self.attrs.add(attrs)

        elif isinstance(attrs, set):

            self.attrs.update(attrs)

        else:

            raise TypeError("Should be str or set...", type(attrs))

    def __repr__(self):

        return "<pron: " + self.pron + ">"

class Variances:

    def __init__(self):

        self.store = {}

    def add(self, word, pron=None, attrs=None):

        """`word`is `str`, `pron` is a `str`, `atts` is a `list` of `str`."""

        if word not in self.store:

            self.store[word] = Variance()

        var = self.store[word]

        if pron is not None:

            if var.pron is not None:

                print("two pronunciations detected!!", pron, var.pron)

                # raise Exception("two pronunciations detected!!", pron, var.pron)

            var.pron = pron

        var.addAttrs(attrs)

    def __repr__(self):

        return repr(self.store)

class Translation:

    def __init__(self, pos, tran):

        """`pos` is `str` like 'n' or 'v', `tran` is `str`."""

        self.pos = pos

        self.tran = tran

    def __repr__(self):

        return "<pos: " + self.pos + ", tran: " + self.tran + ">"

class Article:

    def __init__(self):

        self.vars = Variances()

        self.trans = []

    def addVar(self, word, pron=None, attrs=None):

        """`var` is `list`"""

        self.vars.add(word, pron, attrs)

    def addTransl(self, pos, tran):

        """`trans` is `Translation`."""

        self.trans.append(Translation(pos, tran))

DICT = {}

f = open('gadict-irregular-verbs-en-ru.dict-c5')

content = f.read()

content = content.split(ARTICLE_SEP)

content = iter(content)

next(content)

PRON_LINE_RE = re.compile(r'^  \[')

PRON_RE = re.compile(r'\[([^]]+)]')

V1_RE = re.compile(r"^  (?:inf\. )?([^/]+)/?(.*)?")

V2_RE = re.compile(r"^  (?:p. )?([^/ ]+)/?(.*)?")

V3_RE = re.compile(r"^  (?:p\.p\. )?([^/ ]+)/?(.*)?")

V3_RE = re.compile(r"^  (?:p\.p\. )?([^/ ]+)/?(.*)?")

RU_RE = re.compile(r"^  (.+)")

for piece in content:

    article = Article()

    lines = piece.split("\n")

    headwords = lines[0].split("; ")

    for title in headwords:

        article.addVar(title)

    assert lines[1] == ""

    curr = 2

    line = lines[curr]

    if PRON_LINE_RE.match(line):

        curr += 1

        prons = PRON_RE.findall(line)

        if len(prons) != len(headwords):

            raise Exception("some prononsiation missing for", headwords, prons)

        for i in range(len(headwords)):

            article.addVar(headwords[i], pron=prons[i])

    line = lines[curr]

    m = V1_RE.match(line)

    if m:

        article.addVar(word=m.group(1), attrs="v1")

        if len(m.group(2)) > 0:

            article.addVar(word=m.group(2), attrs="v1")

    else:

        raise Exception("Can't match", line)

    curr += 1

    line = lines[curr]

    m = V2_RE.match(line)

    if m:

        article.addVar(m.group(1), attrs="v2")

        if len(m.group(2)) > 0:

            article.addVar(m.group(2), attrs="v2")

    else:

        raise Exception("Can't match", line)

    curr += 1

    line = lines[curr]

    m = V3_RE.match(line)

    if m:

        article.addVar(m.group(1), attrs="v3")

        if len(m.group(2)) > 0:

            article.addVar(m.group(2), attrs="v3")

    else:

        raise Exception("Can't match", line)

    try:

        curr += 1

        line = lines[curr]

    except IndexError:

        raise IndexError("No translation after", lines[curr-1], lines)

    m = RU_RE.match(line)

    if m:

        article.addTransl(pos="v", tran=m.group(1))

    else:

        raise Exception("Can't match", line)

    if len(lines) != curr+1:

        raise Exception("Unknown line", line, lines, len(lines), curr)

    DICT[headwords[0]] = article

f.close()

HEADWORD_RE = re.compile(r"^([a-zA-Z][a-z -]*)$")

PRON_RE = re.compile(r"^  \[([^]]+)\]$")

TRANSL_RE = re.compile(r"^  (?:[1-9]\) )?(.+)$")

EMPTY_PRON_RE = re.compile(r"^  \[\]$")

def parse_entry(entry, pos):

    lines = entry.split("\n")

    m = HEADWORD_RE.match(lines[0])

    if m is None:

        raise Exception("Fail to parse headword", lines)

    if len(lines[1]) != 0:

        raise Exception("Headword is not separated from article", lines)

    headword = m.group(1)

    if headword in DICT:

        article = DICT[headword]

    else:

        article = Article()

        DICT[headword] = article

    curr = 2

    line = lines[curr]

    m = PRON_RE.match(line)

    pron = None

    if m is not None:

        curr += 1

        pron = m.group(1)

        if len(pron) == 0:

            pron = None

    article.addVar(headword, pron=pron)

    while curr < len(lines):

        line = lines[curr]

        curr += 1

        if EMPTY_PRON_RE.match(line):

            continue

        m = TRANSL_RE.match(line)

        if m:

            article.addTransl(pos=pos, tran=m.group(1))

def parse_file(fn, pos):

    f = open(fn)

    content = f.read()

    content = content.split(ARTICLE_SEP)

    content = iter(content)

    next(content)

    for entry in content:

        try:

            parse_entry(entry, pos)

        except Exception as e:

            raise Exception(e, fn, entry)

    f.close()

parse_file('gadict-regular-verbs-en-ru.dict-c5', 'v')

parse_file('gadict-adjective-en-ru.dict-c5', 'adj')

parse_file('gadict-adverb-en-ru.dict-c5', 'adv')

parse_file('gadict-conjunction-en-ru.dict-c5', 'conj')

parse_file('gadict-en-ru.dict-c5', 'n')

parse_file('gadict-numeral-en-ru.dict-c5', 'num')

parse_file('gadict-phrasal-verbs-en-ru.dict-c5', 'phr.v')

parse_file('gadict-preposition-en-ru.dict-c5', 'prep')

parse_file('gadict-pronoun-en-ru.dict-c5', 'pron')

# parse_file('', '')

# parse_file('', '')

# parse_file('', '')

# parse_file('', '')

f = open("conv.gadict", "w")

for baseword in sorted(DICT.keys()):

    art = DICT[baseword]

    f.write('__\n\n')

    for (headword, var) in art.vars.store.items():

        f.write(headword)

        f.write('\n')

        if var.pron is not None:

            f.write(' [')

            f.write(var.pron)

            f.write(']\n')

        for attr in var.attrs:

            f.write(' ')

            f.write(attr)

            f.write('\n')

    for tran in art.trans:

        f.write('\n')

        f.write(tran.pos)

        f.write('\nru: ')

        f.write(tran.tran)

        f.write('\n')

f.close()