#!/usr/bin/env python

# Translates a data dictionary spreadsheet to Redmine formatting

import csv

import re

import sys

# Spreadsheet format

source_sep = ', '

##### URLs

url_comment_re = r'(?:\([^)]*\))'

def simplify_url(url): return re.sub(r'\(.*?\)', r'', url)

def url_comment_text(comment):

    if not comment: return comment

    match = re.match(r'^\(\d*:?(.*?)\)$', comment)

    assert match

    text, = match.groups()

    return text

def url_term(url):

    '''Prefixes any provider in the URL to the term name, to create a namespace.

    Each hierarchical component of the provider is stored in a URL comment.

    '''

    match = re.match(r'^('+url_comment_re+r'*).*?([\w:-]+)$', url)

    assert match

    provider_str, term = match.groups()

    provider = filter(bool, map(url_comment_text,

        re.findall(url_comment_re, provider_str)))

    return ':'.join(provider+[term])

##### Redmine

sp = ' ' # Unicode thin space

def redmine_esc(text): return '<notextile>'+text+'</notextile>'

def redmine_bold(text): return '*'+text+'*'

def redmine_pad(text): return sp+text+sp

def redmine_link(text, url):

    if not url: return text

    elif url.find('://') >= 0: return '"'+text+'":'+url # external link

    else: return '[['+url+'|'+text+']]' # internal link

def source2redmine_link(url):

    if url: return redmine_link(url_term(url), simplify_url(url))

    else: return ''

def redmine_add_links(page_name, text):

    # Link citations to entry in sources list

    text = re.sub(r'(?<!\[)\[([^\[\]]*)\](?!\])',

        '('+redmine_link(r'\1', page_name+r'#\1')+')', text)

    return text

redmine_table_sep = '|'

redmine_table_sep_esc = redmine_esc(redmine_table_sep)

def redmine_table_esc(text):

    text = text.replace(redmine_table_sep, redmine_table_sep_esc)

    return text

class RedmineTableWriter:

    '''Formats rows as a Redmine table'''

    def __init__(self, stream):

        self.stream = stream

    def writerow(self, row):

        row = map(redmine_table_esc, row)

        self.stream.write(('|'.join(['']+row+['']))+'\n')

class RedmineDictWriter:

    '''Formats rows as Redmine sections containing a table'''

    def __init__(self, term_col, def_col, header, stream):

        self.term_col = term_col

        self.def_col = def_col

        self.header = header

        self.page_name = header[term_col]

        self.stream = stream

    def writerow(self, row):

        row = map(lambda f: redmine_add_links(self.page_name, f), row)

        term = row[self.term_col]

        def_ = row[self.def_col]

        self.stream.write('h2. '+term+'\n\n')

        if def_: self.stream.write(def_+'\n\n')

        table = RedmineTableWriter(self.stream)

        for i, col_name in enumerate(self.header):

            if not i in set([self.term_col, self.def_col]):

                value = row[i]

                if value: table.writerow([redmine_bold(col_name), value])

        self.stream.write('\n')

def main():

    try: _prog_name, term_col, def_col, sources_col = sys.argv

    except ValueError: raise SystemExit('Usage: '+sys.argv[0]

        +' <spreadsheet term_col# definition_col# sources_col# >redmine')

    term_col, def_col, sources_col = map(int, [term_col, def_col, sources_col])

    # Translate input

    reader = csv.reader(sys.stdin)

    header = reader.next()

    page_name = header[term_col]

    writer = RedmineDictWriter(term_col, def_col, header, sys.stdout)

    for row in reader:

        term = row[term_col]

        sources = row[sources_col].split(source_sep)

        row[term_col] = redmine_link(term, page_name+'#'+term)

        row[sources_col] = source_sep.join(map(source2redmine_link, sources))

        writer.writerow(row)

main()