"""
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()