#!/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:

 
             print "rendering: %s" % module
 

             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 = []

 
                 if not 'version_added' in doc:
                     sys.stderr.write("*** ERROR: missing version_added in: %s ***\n" % module)
                     sys.exit(1)
                     if doc['version_added'] == 'historical':
                        del doc['version_added']
 

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