#!/usr/bin/python
# -*- coding: utf-8 -*-
# Copyright (C) 2008 Sergey Poznyakoff
# 
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3, or (at your option)
# any later version.
# 
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
# 
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

from wikimarkup import *
from types import TupleType
from wikins import wiki_ns_re, wiki_ns
import urllib

class TextWikiMarkup (WikiMarkup):
    """
    A (general-purpose Wiki->Text translator class.
    """

    # Output width
    width = 80
    # Do not show references.
    references = False
    # Provide a minimum markup
    markup = True

    # Number of current element in the environment
    num = 0
    
    def __init__(self, *args, **keywords):
        WikiMarkup.__init__(self, *args, **keywords)
        if 'width' in keywords:
            self.width = keywords['width']
        if 'refs' in keywords:
            self.references = keywords['refs']
        if 'markup' in keywords:
            self.markup = keywords['markup']

    def xref(self, text, target):
        if text:
            return "%s (see %s) " % (text, target)
        else:
            return "see " + target

    def wiki_ns_name(self, str):
        if str in wiki_ns[self.lang]:
            return wiki_ns[self.lang][str]
        elif str in wiki_ns_re[self.lang]:
            for elt in wiki_ns_re[self.lang][str]:
                if str.beginswith(elt[0]) and str.endswith(elt[1]):
                    return elt[2]
        return None            
    def mktgt(self, tgt, lang = None):
        if not lang:
            lang = self.lang
        return self.html_base % { 'lang' : lang } + urllib.quote(tgt)
    
    def link(self, tok, env, istmpl):
        arg = self.fmtok(tok[1], env)
        text = self.fmtok(tok[2], env)
        (qual,sep,tgt) = arg.partition(':')
        if tgt != '':
            ns = self.wiki_ns_name(qual)
            if ns:
                if ns == 'NS_IMAGE':
                    if not self.references:
                        return None
                    text = "[%s: %s]" % (qual, text if text else arg)
                    tgt = self.image_base + '/' + \
                                 urllib.quote(tgt) + \
                                 '/250px-' + urllib.quote(tgt)
                elif ns == 'NS_MEDIA':
                    text = "[%s]" % (qual)
                else:
                    tgt = self.mktgt(tgt)
            elif not istmpl and qual in self.langtab:
                text = self.langtab[qual] + ": " + tgt
                tgt = self.mktgt(tgt, qual)
            else:
                tgt = self.mktgt(tgt)
        else:
            tgt = self.mktgt(arg)
        if self.references:
            return "%s (see %s) " % (text, tgt)
        elif not text or text == '':
            return arg
        else:
            return text
    
    def str_link(self, tok, env):
        return self.link(tok, env, False)

    def str_tmpl(self, tok, env):
        return self.link(tok, env, True)
        
    def str_ref(self, tok, env):
        return self.xref(self.fmtok(tok[2], env), self.fmtok(tok[1], env))

    def str_it(self, tok, env):
        if self.markup:
            return "_" + self.fmtok(tok[1], env) + "_"
        return self.fmtok(tok[1], env);
                                          
    def str_bold(self, tok, env):
        if self.markup:
            return self.fmtok(tok[1], env).upper()
        return self.fmtok(tok[1], env);
                                              
    def str_hdr(self, tok, env):
        level = tok[1]
        return "\n\n" + ("*" * level) + " " + self.fmtok(tok[2], env) + "\n\n"
    
    def str_bar(self, tok, env):
        w = self.width
        if w < 5:
            w = 5
        return "\n" + ("-" * (w - 5)).center(w - 1) + "\n"
    
    def str_env(self, tok, env):
        self.num = 1
        return "\n" + self.fmtok(tok[3], tok)

    def indent (self, lev, text):
        w = self.width
        self.width = w - lev
        if text.find('\n') == -1:
            s = (" " * lev) + text 
        else:
            s = ""
            for elt in text.split('\n'):
                s += (" " * lev) + elt
                if elt == '':
                    s += "\n"
                    
        self.width = w
        return s
        
    def str_item(self, tok, env):
        t = env[1]
        lev = env[2]
        if lev > self.width - 4:
           lev = 1
        if t == self.INDENT:
            return self.indent(lev, self.fmtok(tok[1], env))
        elif t == self.ENVNUM:
            n = self.num
            self.num += 1
            return "" + self.indent(lev,
                                      "%d. %s" % (n, self.fmtok(tok[1], env)))
        elif t == self.ENVUNNUM:
            return "" + self.indent(lev,
                                      "- " + self.fmtok(tok[1], env))

    def str_para(self, tok, env):
        return "\n"
    
    def __str__(self):
        return self.fmtok(self.tree, None)

class TextWiktionaryMarkup (TextWikiMarkup):
    """
 See documentation for HtmlWiktionaryMarkup
    """

    seq_pos = 0
    
    def str_seq(self, tok, env):
            s = ""
            self.seq_pos=0
            for t in tok[1:]:
                x = self.fmtok(t, env)
                if x:
                    s += x
                self.seq_pos += 1
            return s
    
    def str_tmpl(self, tok, env):
        arg = self.fmtok(tok[1], env)
        if arg and arg != '':
            if self.seq_pos > 0:
                return arg
            else:
                return "\n" + arg + ":\n"