#!/usr/bin/env python

import sys,os,re
from argparse import ArgumentParser, RawDescriptionHelpFormatter
sys.path.append(os.path.dirname(os.path.realpath(__file__)))
import ansicodes as ansi

__author__ = "Ville Rantanen <ville.q.rantanen@gmail.com>"
__version__ = "0.3"

''' Rules modified from mistune project '''

def setup_options():
    bc = ansi.code()
    ''' Create command line options '''
    usage = '''
Markdown syntax color in ansi codes.
Special syntaxes:
- Colors: insert string e.g. ${C}.
- Any ANSI control code:  ${3A}, ${1;34;42m}, see the table..

''' + ansi.demo()

    parser = ArgumentParser(
        formatter_class = RawDescriptionHelpFormatter,
        description = usage,
        epilog = __author__
    )

    parser.add_argument("-v","--version",action="version",version=__version__)
    parser.add_argument("-D",action="store_true",dest="debug",default=False,
                     help="Debug mode")
    parser.add_argument("--dc",action="store_true",dest="dark_colors",default=False,
                     help="Use dark colorscheme, better for white background terminals.")
    parser.add_argument("--no-color","-n",action="store_false",dest="color",default=True,
                     help="Disable color.")
    parser.add_argument("--print-template",action="store_true",dest="print_template",default=False,
                     help="Print customizable color template.")
    parser.add_argument("--template",action="store",type=str,dest="template",default=None,
                     help="Use a custom template file for colorization.")
    parser.add_argument("-z",action="store_true",dest="zero",default=False,
                     help="Reset coloring at the end of each line.")
    parser.add_argument("-Z",action="store_false",dest="zero_final",default=True,
                     help="Disable reset of colors at the end of file.")
    parser.add_argument("filename",type=str, nargs='?',
                     help="File to show, - for stdin")
    opts=parser.parse_args()
    return opts

def parse(data):
    data=[[None,row] for row in data]
    block='text'
    new_block='text'
    multiline_block=False
    # Parse styles
    for i,line in enumerate(data):
        row=line[1]
        if line[0] is not None:
            # Previous lines have set the style already
            continue
        for match in blocks:
            if block_match[match]['re'].match(row):
                new_block=match
                if match.startswith('multiline'):
                    if multiline_block:
                        multiline_block=False
                    else:
                        multiline_block=match
                break
        if multiline_block:
            new_block=multiline_block
        # Lists must end with empty line
        if new_block not in ('empty','list_bullet') and block.startswith('list_'):
            new_block='list_loose'

        if 'mod' in block_match[match]:
            # Style sets block in previous or next lines
            data[i+block_match[match]['mod']['pos']][0]=block_match[match]['mod']['name']
        data[i][0]=new_block
        if new_block!=block:
            block=new_block
    return data

def colorize(data,remove_colors=False,dark_colors=False,debug=False):
    # Start inserting colors, and printing
    bc=ansi.code()
    colorized=[]
    cs='dc' if dark_colors else 'bc'
    csc=cs+'c'
    for i,line in enumerate(data):
        row=line[1]
        block=line[0]
        multiline_block=block.startswith('multiline')
        if multiline_block:
            row=block_match[block][csc]+row
        if block_match[block][cs]:
            row=block_match[block]['re'].sub(block_match[block][cs],row)
        # No coloring inside block_code, nor multiline
        if not (multiline_block or block=='block_code'):
            for match in inlines:
                if inline_match[match]['re'].search(row):
                    row=inline_match[match]['re'].sub(inline_match[match][cs]+block_match[block][csc],row)
        if remove_colors:
            colored=bc.nocolor_string(row)
        else:
            colored=bc.color_string(row)
        if debug:
            multistr="*" if multiline_block else " "
            colored="{:<18}{:}:".format(data[i][0],multistr)+colored
        colorized.append(colored)
    return colorized

def md_re_compile(d):
    ''' Returns a re.compiled dict '''
    n={}
    for t in d:
        n[t]={}
        for i in d[t]:
            n[t][i]=d[t][i]
        try:
            if n[t]['re']:
                n[t]['re']=re.compile(n[t]['re'])
        except err:
            print("Error compiling: %s"%(n[t]['re']))
            sys.exit(1)
    return n

def read_data2(fp):
    data = []
    # Read data
    for row in f:
        if not row:
            continue
        row = row.decode('utf-8').rstrip("\n\r ")
        data.append(row)
    return data

def read_data3(fp):
    data = []
    # Read data
    for row in f:
        if not row:
            continue
        row = row.rstrip("\n\r ")
        data.append(row)
    return data

def write_colored2(colored, opts):
    for c in colored:
        sys.stdout.write(c.encode('utf-8'))
        if opts.zero:
            sys.stdout.write(bc.Z)
        sys.stdout.write("\n")
    if opts.zero_final:
        sys.stdout.write(bc.Z.encode('utf-8'))

def write_colored3(colored, opts):
    for c in colored:
        sys.stdout.write(c)
        if opts.zero:
            sys.stdout.write(bc.Z)
        sys.stdout.write("\n")
    if opts.zero_final:
        sys.stdout.write(bc.Z)



# re: regular expression, bc: bright colors, bcc: continue with this color after inline
# dc: dark colors, dcc: continued color after inline
block_match_str={
    'block_code':      {'re':'^( {4}[^*])(.*)$',
                            'bc' :'${Z}${c}\\1\\2', 'bcc':'${Z}${c}',
                            'dc' :'${Z}${m}\\1\\2', 'dcc':'${Z}${m}'}, #    code
    'multiline_code' : {'re':'^ *(`{3,}|~{3,}) *(\S*)',
                            'bc' :'${Z}${c}\\1\\2', 'bcc':'${Z}${c}',
                            'dc' :'${Z}${m}\\1\\2', 'dcc':'${Z}${m}'},  # ```lang
    'block_quote':     {'re':'^(>[ >]* )',
                            'bc':'${K}\\1${Z}','bcc':'${Z}',
                            'dc':'${Y}\\1${Z}','dcc':'${Z}'}, # > > quote
    'hrule':           {'re':'^ {0,3}[-*_]([-*_]){2,}$',
                            'bc':'False','bcc':'${Z}',
                            'dc':'False','dcc':'${Z}'}, # ----
    'heading' :        {'re':'^ *(#{1,6}) *([^\n]+?) *#* *(?:\n+|$)',
                            'bc':'${W}\\1 ${U}\\2${Z}','bcc':'${W}${U}',
                            'dc':'${B}\\1 ${U}\\2${Z}','dcc':'${B}${U}'}, # # heading
    'lheading' :       {'re':'^(=+|-+)$',
                            'bc':'${W}\\1', 'bcc':'${W}',
                            'dc':'${B}\\1', 'dcc':'${B}',
                            'mod':{'pos':-1,'name':'lheading.mod'}}, # ======= under header
    'lheading.mod' :   {'re':'^([^\n]+)',
                            'bc':'${W}\\1', 'bcc':'${W}',
                            'dc':'${B}\\1', 'dcc':'${B}'},  # over the ======= under header
    'list_bullet':     {'re':'^( *)([*+-]|[\d\.]+)( +)',
                            'bc':'\\1${y}\\2${Z}\\3','bcc':'${Z}',
                            'dc':'\\1${r}\\2${Z}\\3','dcc':'${Z}'}, # * or 1.
    'list_loose':      {'re':'None',
                            'bc':'False','bcc':'${Z}',
                            'dc':'False','dcc':'${Z}'},
    'text':            {'re':'^([^\n]+)',
                            'bc':'${Z}\\1','bcc':'${Z}',
                            'dc':'${Z}\\1','dcc':'${Z}'},
    'empty':           {'re':'(^$)',
                            'bc':'${Z}\\1','bcc':'${Z}',
                            'dc':'${Z}\\1','dcc':'${Z}'},
}
block_match=md_re_compile(block_match_str)
blocks=['block_quote', 'multiline_code','hrule', 'heading','lheading','list_bullet', 'block_code', 'text', 'empty']

inline_match_str={
    'bold1':         {'re':r'(^| |})(_[^_]+_)',
                        'bc':'\\1${W}\\2','dc':'\\1${W}\\2'}, # _bold_
    'bold2':         {'re':r'(^| |})(\*{1,2}[^\*]+\*{1,2})',
                        'bc':'\\1${W}\\2','dc':'\\1${W}\\2'}, # **bold**
    'code':          {'re':r'([`]+[^`]+[`]+)',
                        'bc':'${c}\\1','dc':'${m}\\1'},  # `code`
    'code_special':  {'re':r'([`]+[^`]+[`]+)([!>])',
                        'bc':'${c}\\1${g}\\2','dc':'${m}\\1${r}\\2'}, # `code`! or `code`> for markslider
    'link':          {'re':r'(\[)([^\]]+)(\])\(([^\)]+)\)',
                        'bc':'${B}\\1${Z}\\2${B}\\3(${U}\\4${u})',
                        'dc':'${b}\\1${Z}\\2${b}\\3(${U}\\4${u})'}, # [text](link)
    'image':         {'re':r'(!\[[^\]]+\]\([^\)]+\))',
                        'bc':'${r}\\1','dc':'${g}\\1'}, # ![text](image)
    'underline':     {'re':r'(^|\W)(__)([^_]+)(__)',
                        'bc':'\\1\\2${U}\\3${Z}\\4','dc':'\\1\\2${U}\\3${Z}\\4'}, # __underline__
    'strikethrough': {'re':r'(~~)([^~]+)(~~)',
                        'bc':'\\1${st}\\2${so}\\3','dc':'\\1${st}\\2${so}\\3'},  # ~~strike~~
    'checkbox': {'re':r'(\[[x ]\])',
                        'bc':'${y}\\1','dc':'${r}\\1'},  # [x] [ ]
}
inline_match = md_re_compile(inline_match_str)
inlines = ['bold1','bold2','code_special','code','image','link','underline','strikethrough', 'checkbox']

if __name__ == "__main__":
    opts=setup_options()
    if opts.print_template:
        import json
        print(json.dumps({'about':'re: regular expression, bc: bright colors, bcc: continue with this color after inline, dc: dark colors, dcc: continued color after inline. "blocks" and "inlines" list keys of matchers. ',
                          'blocks':blocks,
                          'block_match':block_match_str,
                          'inline_match':inline_match_str,
                          'inlines':inlines},
                           indent=2,sort_keys=True))
        sys.exit(0)
    if opts.template:
        import json
        template=json.load(open(opts.template,'r'))
        if 'inlines' in template: inlines=template['inlines']
        if 'blocks' in template: blocks=template['blocks']
        if 'block_match' in template:
            block_match_str=template['block_match']
            block_match=md_re_compile(block_match_str)
        if 'inline_match' in template:
            inline_match_str=template['inline_match']
            inline_match=md_re_compile(inline_match_str)

    bc = ansi.code()
    if opts.filename == "-" or opts.filename == None:
        f = sys.stdin
    else:
        f = open(opts.filename, 'r')
    if (sys.version_info > (3, 0)):
        data = read_data3(f)
    else:
        data = read_data2(f)

    data = parse(data)
    colored = colorize(data, not opts.color, opts.dark_colors, opts.debug)
    if (sys.version_info > (3, 0)):
        write_colored3(colored, opts)
    else:
        write_colored2(colored, opts)