#!/usr/bin/env python
# (c) 2012, Jan-Piet Mens <jpmens () gmail.com>
#
# This file is part of Ansible
#
# Ansible 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 of the License, or
# (at your option) any later version.
#
# Ansible 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 Ansible.  If not, see <http://www.gnu.org/licenses/>.
#

import os
import glob
import sys
import yaml
import codecs
import json
import ast
from jinja2 import Environment, FileSystemLoader
import re
import optparse
import time
import datetime
import subprocess
import cgi
import ansible.utils
import ansible.utils.module_docs as module_docs

# Get parent directory of the directory this script lives in
MODULEDIR=os.path.abspath(os.path.join(
    os.path.dirname(os.path.realpath(__file__)), os.pardir, 'library'
    ))
EXAMPLE_YAML=os.path.abspath(os.path.join(
    os.path.dirname(os.path.realpath(__file__)), os.pardir, 'examples', 'DOCUMENTATION.yaml'
    ))

# There is a better way of doing this!
# TODO: somebody add U(text, http://foo.bar/) as described by Tim in #991

_ITALIC = re.compile(r"I\(([^)]+)\)")
_BOLD   = re.compile(r"B\(([^)]+)\)")
_MODULE = re.compile(r"M\(([^)]+)\)")
_URL    = re.compile(r"U\(([^)]+)\)")
_CONST  = re.compile(r"C\(([^)]+)\)")

def latex_ify(text):

    t = _ITALIC.sub("\\I{" + r"\1" + "}", text)
    t = _BOLD.sub("\\B{" + r"\1" + "}", t)
    t = _MODULE.sub("\\M{" + r"\1" + "}", t)
    t = _URL.sub("\\url{" + r"\1" + "}", t)
    t = _CONST.sub("\\C{" + r"\1" + "}", t)

    return t

def html_ify(text):

    #print "DEBUG: text=%s" % text
    
    t = cgi.escape(text)
    t = _ITALIC.sub("<em>" + r"\1" + "</em>", t)
    t = _BOLD.sub("<b>" + r"\1" + "</b>", t)
    t = _MODULE.sub("<span class='module'>" + r"\1" + "</span>", t)
    t = _URL.sub("<a href='" + r"\1" + "'>" + r"\1" + "</a>", t)
    t = _CONST.sub("<code>" + r"\1" + "</code>", t)

    return t

def json_ify(text):

    t = _ITALIC.sub("<em>" + r"\1" + "</em>", text)
    t = _BOLD.sub("<b>" + r"\1" + "</b>", t)
    t = _MODULE.sub("<span class='module'>" + r"\1" + "</span>", t)
    t = _URL.sub("<a href='" + r"\1" + "'>" + r"\1" + "</a>", t)
    t = _CONST.sub("<code>" + r"\1" + "</code>", t)

    return t


def js_ify(text):

    return text


def man_ify(text):

    t = _ITALIC.sub(r'\\fI' + r"\1" + r"\\fR", text)
    t = _BOLD.sub(r'\\fB' + r"\1" + r"\\fR", t)
    t = _MODULE.sub(r'\\fI' + r"\1" + r"\\fR", t)
    t = _URL.sub(r'\\fI' + r"\1" + r"\\fR", t)
    t = _CONST.sub(r'\\fC' + r"\1" + r"\\fR", t)

    return t

def rst_ify(text):

    t = _ITALIC.sub(r'*' + r"\1" + r"*", text)
    t = _BOLD.sub(r'**' + r"\1" + r"**", t)
    t = _MODULE.sub(r'``' + r"\1" + r"``", t)
    t = _URL.sub(r"\1", t)
    t = _CONST.sub(r'``' + r"\1" + r"``", t)

    return t

_MARKDOWN = re.compile(r"[*_`]")

def markdown_ify(text):

    t = cgi.escape(text)
    t = _MARKDOWN.sub(r"\\\g<0>", t)
    t = _ITALIC.sub("_" + r"\1" + "_", t)
    t = _BOLD.sub("**" + r"\1" + "**", t)
    t = _MODULE.sub("*" + r"\1" + "*", t)
    t = _URL.sub("[" + r"\1" + "](" + r"\1" + ")", t)
    t = _CONST.sub("`" + r"\1" + "`", t)

    return t

# Helper for Jinja2 (format() doesn't work here...)
def rst_fmt(text, fmt):
    return fmt % (text)

def rst_xline(width, char="="):
    return char * width

def load_examples_section(text):
    return text.split('***BREAK***')

def return_data(text, options, outputname, module):
    if options.output_dir is not None:
        f = open(os.path.join(options.output_dir, outputname % module), 'w')
        f.write(text.encode('utf-8'))
        f.close()
    else:
        print text

def boilerplate():
    if not os.path.exists(EXAMPLE_YAML):
        print >>sys.stderr, "Missing example boiler plate: %S" % EXAMPLE_YAML
    print "DOCUMENTATION = '''"
    print file(EXAMPLE_YAML).read()
    print "'''"
    print ""

def list_modules(module_dir):
    categories = {}
    files = glob.glob("%s/*" % module_dir)
    for d in files:
        if os.path.isdir(d):
            files2 = glob.glob("%s/*" % d)
            for f in files2:
                tokens = f.split("/")
                module = tokens[-1]
                category = tokens[-2]
                if not category in categories:
                    categories[category] = {}
                categories[category][module] = f
    return categories

def main():

    p = optparse.OptionParser(
        version='%prog 1.0',
        usage='usage: %prog [options] arg1 arg2',
        description='Convert Ansible module DOCUMENTATION strings to other formats',
    )

    p.add_option("-A", "--ansible-version",
            action="store",
            dest="ansible_version",
            default="unknown",
            help="Ansible version number")
    p.add_option("-M", "--module-dir",
            action="store",
            dest="module_dir",
            default=MODULEDIR,
            help="Ansible modules/ directory")
    p.add_option("-T", "--template-dir",
            action="store",
            dest="template_dir",
            default="hacking/templates",
            help="directory containing Jinja2 templates")
    p.add_option("-t", "--type",
            action='store',
            dest='type',
            choices=['html', 'latex', 'man', 'rst', 'json', 'markdown', 'js'],
            default='latex',
            help="Output type")
    p.add_option("-m", "--module",
            action='append',
            default=[],
            dest='module_list',
            help="Add modules to process in module_dir")
    p.add_option("-v", "--verbose",
            action='store_true',
            default=False,
            help="Verbose")
    p.add_option("-o", "--output-dir",
            action="store",
            dest="output_dir",
            default=None,
            help="Output directory for module files")
    p.add_option("-I", "--includes-file",
            action="store",
            dest="includes_file",
            default=None,
            help="Create a file containing list of processed modules")
    p.add_option("-G", "--generate",
            action="store_true",
            dest="do_boilerplate",
            default=False,
            help="generate boilerplate DOCUMENTATION to stdout")
    p.add_option('-V', action='version', help='Show version number and exit')

    (options, args) = p.parse_args()

#    print "M: %s" % options.module_dir
#    print "t: %s" % options.type
#    print "m: %s" % options.module_list
#    print "v: %s" % options.verbose

    if options.do_boilerplate:
        boilerplate()

        print ""
        print "EXAMPLES = '''"
        print "# example of doing ___ from a playbook"
        print "your_module: some_arg=1 other_arg=2"
        print "'''"
        print ""

        sys.exit(0)

    if not options.module_dir:
        print "Need module_dir"
        sys.exit(1)
    if not os.path.exists(options.module_dir):
        print >>sys.stderr, "Module directory does not exist: %s" % options.module_dir
        sys.exit(1)


    if not options.template_dir:
        print "Need template_dir"
        sys.exit(1)

    env = Environment(loader=FileSystemLoader(options.template_dir),
        variable_start_string="@{",
        variable_end_string="}@",
        trim_blocks=True,
    )

    env.globals['xline'] = rst_xline

    if options.type == 'latex':
        env.filters['jpfunc'] = latex_ify
        template = env.get_template('latex.j2')
        outputname = "%s.tex"
        includecmt = ""
        includefmt = "%s\n"
    if options.type == 'html':
        env.filters['jpfunc'] = html_ify
        template = env.get_template('html.j2')
        outputname = "%s.html"
        includecmt = ""
        includefmt = ""
    if options.type == 'man':
        env.filters['jpfunc'] = man_ify
        template = env.get_template('man.j2')
        outputname = "ansible.%s.3"
        includecmt = ""
        includefmt = ""
    if options.type == 'rst':
        env.filters['jpfunc'] = rst_ify
        env.filters['html_ify'] = html_ify
        env.filters['fmt'] = rst_fmt
        env.filters['xline'] = rst_xline
        template = env.get_template('rst.j2')
        outputname = "%s.rst"
        includecmt = ".. Generated by module_formatter\n"
        includefmt = ".. include:: modules/%s.rst\n"
    if options.type == 'json':
        env.filters['jpfunc'] = json_ify
        outputname = "%s.json"
        includecmt = ""
        includefmt = ""
    if options.type == 'js':
        env.filters['jpfunc'] = js_ify
        template = env.get_template('js.j2')
        outputname = "%s.js"
    if options.type == 'markdown':
        env.filters['jpfunc'] = markdown_ify
        env.filters['html_ify'] = html_ify
        template = env.get_template('markdown.j2')
        outputname = "%s.md"
        includecmt = ""
        includefmt = ""

    if options.includes_file is not None and includefmt != "":
        incfile = open(options.includes_file, "w")
        incfile.write(includecmt)

    # Temporary variable required to genrate aggregated content in 'js' format.
    js_data = []

    categories = list_modules(options.module_dir)
    last_category = None
    category_names = categories.keys()
    category_names.sort()
 
    for category in category_names:
        module_map = categories[category]
 
        category = category.replace("_"," ")
        category = category.title()

        modules = module_map.keys()
        modules.sort()

        for module in modules:
            fname = module_map[module]

            if len(options.module_list):
                if not module in options.module_list:
                    continue

            # fname = os.path.join(options.module_dir, module)

            extra = os.path.join("inc", "%s.tex" % module)

            # probably could just throw out everything with extensions
            if fname.endswith(".swp") or fname.endswith(".orig") or fname.endswith(".rej"):
                continue

            # print " processing module source ---> %s" % fname

            if options.type == 'js':
                if fname.endswith(".json"):
                    f = open(fname)
                    j = json.load(f)
                    f.close()
                    js_data.append(j)
                continue

            doc, examples = ansible.utils.module_docs.get_docstring(fname, verbose=options.verbose)

            if doc is None and module not in ansible.utils.module_docs.BLACKLIST_MODULES:
                print " while processing module source ---> %s" % fname
                sys.stderr.write("*** ERROR: CORE MODULE MISSING DOCUMENTATION: %s ***\n" % module)
                #sys.exit(1)

            if not doc is None:
 
                all_keys = []
                for (k,v) in doc['options'].iteritems():
                    all_keys.append(k)
                all_keys = sorted(all_keys)
                doc['option_keys'] = all_keys 

                doc['filename']         = fname
                doc['docuri']           = doc['module'].replace('_', '-')
                doc['now_date']         = datetime.date.today().strftime('%Y-%m-%d')
                doc['ansible_version']  = options.ansible_version
                doc['plainexamples']    = examples  #plain text

                # BOOKMARK: here is where we build the table of contents...

                if options.includes_file is not None and includefmt != "":

                    if last_category != category:
                         incfile.write("\n\n")
                         incfile.write(category)
                         incfile.write("\n")
                         incfile.write('`' * len(category))
                         incfile.write("\n\n")
                         last_category = category

                    incfile.write(includefmt % module)

                if options.verbose:
                    print json.dumps(doc, indent=4)


                if options.type == 'latex':
                    if os.path.exists(extra):
                        f = open(extra)
                        extradata = f.read()
                        f.close()
                        doc['extradata'] = extradata

                if options.type == 'json':
                    text = json.dumps(doc, indent=2)
                else:
                    text = template.render(doc)

                return_data(text, options, outputname, module)

        if options.type == 'js':
            docs = {}
            docs['json'] = json.dumps(js_data, indent=2)
            text = template.render(docs)
            return_data(text, options, outputname, 'modules')

if __name__ == '__main__':
    main()
