#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import os
import json
import clang.cindex
from clang.cindex import CursorKind


class AST_Parser:
    def __init__(self,library_file=None):
        if not clang.cindex.Config.loaded:
            print("Using libclang from: %s", library_file)
            clang.cindex.Config.set_library_file(library_file)

    def parse(self, filename, content):
        index = clang.cindex.Index.create()
        arguments = ["-x", "c"]
        options = clang.cindex.TranslationUnit.PARSE_SKIP_FUNCTION_BODIES
        content = [(filename, content)]
        translation_unit = index.parse(filename, unsaved_files=content, args=arguments, options=options)
        ret = self._parse(translation_unit.cursor, filename)
        return ret

    def _get_children_filelocal(self, cursor, path):
        return [c for c in cursor.get_children() if c.location.file and c.location.file.name == path]

    def _parse(self, cursor, path):
        item = {}
        excluded_cursortypes = [CursorKind.INTEGER_LITERAL]
        if not cursor.kind in excluded_cursortypes:
            if not str(cursor.kind) == "":
                item["kind"] = str(cursor.kind)

            if not cursor.spelling == "":
                item["name"] = cursor.spelling

            if not cursor.displayname == "":
                item["displayname"] = cursor.displayname

            if not cursor.type.spelling == "":
                item["type"] = cursor.type.spelling

            if not cursor.result_type.spelling == "":
                item["result_type"] = cursor.result_type.spelling

            if cursor.kind == CursorKind.ENUM_CONSTANT_DECL:
                item["value"] = cursor.enum_value

        child_cursors = self._get_children_filelocal(cursor, path)
        if len(child_cursors) > 0:
            child_arr = []
            for child_cursor in child_cursors:
                child_result = self._parse(child_cursor, path)
                if child_result:
                    child_arr.append(child_result)

            if child_arr:
                item["children"] = child_arr

        return item


def create_paths_list(dirname, filenames):
    paths = []
    for basename in filenames:
        path = dirname + basename
        paths.append(path)
    return paths


def read_files(paths):
    content = []
    for path in paths:
        file_info = read_file(path)
        content.append(file_info)
    return content


def read_file(path):
    with open(path) as f:
        file_content = f.read()
        item = {"path": path,
                "sourcecode": file_content}
    return item


def write_json(header):
    header["outpath"] += ".json"
    with open(header.get("outpath"), "w+") as f:
        json.dump(header, f, indent=4)


def prepare_header(header, out_dir):
    basename = os.path.basename(header.get("path"))
    outpath = out_dir + basename
    header["outpath"] = outpath
    return header


def main():
    input()
    parser = AST_Parser("/opt/local/libexec/llvm-9.0/lib/libclang.dylib")
    # Input
    prefix = r"/Users/heck/local-default/"
    filenames = ["pEpEngine.h",
                 "keymanagement.h"]
    # Output
    out_dir = "data/output/"
    if not os.path.isdir(out_dir):
        os.makedirs(out_dir)

    in_dir = prefix + r"include/pEp/"
    paths = create_paths_list(in_dir, filenames)
    headers = read_files(paths)

    for header in headers:
        header = prepare_header(header, out_dir)
        print("processing path: " + header.get("path") + "...")
        header["AST"] = parser.parse(header["path"], header["sourcecode"])
        write_json(header)


if __name__ == "__main__":
    main()