'''
We are doing stuff
'''

import glob
import json
import re
import os

# pseudocode
# load all files
# json parse
# recursively descend all json struct
# Find expr and add a second expr after the or with a re.replace of pod_name &
# container_name
# write all new files

def import_file(f):
    '''
    Read the file as json
    '''

    with open(f, 'r') as r:
        return json.load(r)


def export_file(f, content):
    '''
    Write the file as json
    '''

    with open(f, 'w') as w:
        json.dump(content, w, indent=4)


def process_items(item):
    '''
    Recursive parse a JSON object, find the expr attributes and mangle them
    '''

    if isinstance(item, (int, float)):
        return item
    if isinstance(item, bool):
        return item
    if isinstance(item, str):
        return item
    if isinstance(item, dict):
        for k, v in item.items():
            if k == 'expr':
                item[k] = process_expression(v)
            elif k == 'legendFormat':
                item[k] = process_legendFormat(v)
            elif k == 'definition' or k == 'query' and isinstance(v, str):
                item[k] = process_def_query(v)
            elif k == 'version':
                item[k] = v + 1
            else:
                item[k] = process_items(v)
        return item
    if isinstance(item, list):
        for i in range(len(item)):
            item[i] = process_items(item[i])
        return item
    return item


def process_expression(expression):
    '''
    if the expr has pod_name, container_name, add an or with switch to pod and
    container
    '''

    if re.search('pod_name', expression) or \
            re.search('container_name', expression):
        new_term = expression
        new_term = re.sub('pod_name', 'pod', new_term)
        new_term = re.sub('(?<![$])container_name', 'container', new_term)
        expression = '(%s) or (%s)' % (new_term, expression)
    return expression


def process_legendFormat(legend):
    '''
    if the legend has pod_name, container_name, switch to pod and container
    '''

    if re.search('pod_name', legend) or \
            re.search('container_name', legend):
        new_term = legend
        new_term = re.sub('{{ ?pod_name ?}}', '{{ pod }}', new_term)
        new_term = re.sub('{{ ?container_name ?}}', '{{ container }}', new_term)
        legend = new_term
    return legend


def process_def_query(def_query):
    '''
    if the def_query has container_name, switch to container
    '''

    if re.search('container_name', def_query):
        new_term = def_query
        new_term = re.sub('container_name\)$', 'container)', new_term)
        def_query = new_term
    return def_query

def process_dashboard(dashboard):
    return process_items(dashboard)

def main():
    '''
    main
    '''

    in_files = glob.glob('*.json')
    data = map(
        lambda x:
        {
            'in_file': x,
            'out_file': '%s_new%s' % os.path.splitext(x),
            'dashboard': import_file(x),
            'out_dashboard': None,
        },
        in_files)

    for datum in data:
        print('Processing: %s' % datum['in_file'])
        datum['out_dashboard'] = process_dashboard(datum['dashboard'])
        print('Writing: %s' % datum['out_file'])
        export_file(datum['out_file'], datum['out_dashboard'])


if __name__ == '__main__':
    main()