#!/usr/bin/python

# Copyright 2017 Red Hat, Inc.

#

# Author: Jan Pokorny <jpokorny@redhat.com>

#

# This file is part of libqb.

#

# libqb is free software: you can redistribute it and/or modify

# it under the terms of the GNU Lesser General Public License as published by

# the Free Software Foundation, either version 2.1 of the License, or

# (at your option) any later version.

#

# libqb 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 Lesser General Public License for more details.

#

# You should have received a copy of the GNU Lesser General Public License

# along with libqb.  If not, see <http://www.gnu.org/licenses/>.

# expected to work with both Python 2.6+/3+

from __future__ import print_function

"""Generate callsite-heavy logging client so as to evaluate use of resources"""

from getopt import GetoptError, getopt

from math import ceil, floor, log10

#from pprint import pprint

#from random import shuffle

from sys import argv, exit

def die(*args, **kwargs):

    print(*args, **kwargs)

    exit(1)

def list_to_c_source(worklist, fnc_prefix, width=0):

    ret = []

    while worklist:

        item = worklist.pop()

        if type(item) is list:

            head, children = item

            if type(children) is list:

                for i, ci in enumerate(children):

                    ret += list_to_c_source([ci], fnc_prefix, width)

                    if type(ci) is list:

                        children[i] = ci[0]

                        if type(children[i]) is list:

                            children[i] = children[i][0]

        else:

            head = item

            children = []

        if type(head) is not list:

            head = [head]

        ret += ["static void {0}_{1:0{2}}(int doit) {{"

                .format(fnc_prefix, head[0], width),

                "\tif (!doit) return;"]

        ret += ["\tqb_log(LOG_ERR, \"{0:0{1}}\");".format(i, width)

                for i in head]

        ret += ["\t{0}_{1:0{2}}(doit);".format(fnc_prefix, i, width)

                for i in reversed(children)]

        ret += ["}"]

    return ret

def main(opts, args):

    FNC_PREFIX = "fnc"

    try:

        CALLSITE_COUNT = int(opts["CALLSITE_COUNT"])

        if not 0 < CALLSITE_COUNT < 10 ** 6: raise ValueError

    except ValueError:

        die("callsites count can only be a number x, 0 < x < 1e6")

    try:

        BRANCHING_FACTOR = int(opts["BRANCHING_FACTOR"])

        if not 0 < BRANCHING_FACTOR < 10 ** 3: raise ValueError

    except ValueError:

        die("branching factor can only be a number x, 0 < x < 1000")

    try:

        CALLSITES_PER_FNC = int(opts["CALLSITES_PER_FNC"])

        if not 0 < CALLSITES_PER_FNC < 10 ** 3: raise ValueError

    except ValueError:

        die("callsites-per-fnc count can only be a number x, 0 < x < 1000")

    try:

        ROUND_COUNT = int(opts["ROUND_COUNT"])

        if not 0 < ROUND_COUNT < 10 ** 6: raise ValueError

    except ValueError:

        die("round count can only be a number x, 0 < x < 1e6")

    worklist, worklist_len = list(range(0, CALLSITE_COUNT)), CALLSITE_COUNT

    #shuffle(worklist)

    #pprint(worklist)

    first = worklist[0]

    while worklist_len > 1:

        item = worklist.pop(); worklist_len -= 1

        reminder = worklist_len % CALLSITES_PER_FNC

        parent = (worklist_len - reminder if reminder

                  else (worklist_len // CALLSITES_PER_FNC - 1)

                        // BRANCHING_FACTOR * CALLSITES_PER_FNC)

        #print("parent {0} (len={1})".format(parent, worklist_len))

        if type(worklist[parent]) is not list:

            worklist[parent] = [worklist[parent], []]

        if not(reminder):

            worklist[parent][1].append(item)  # reverses the order!

            #worklist[parent][1][:0] = [item]

        else:

            if type(worklist[parent][0]) is not list:

                worklist[parent][0] = [worklist[parent][0]]

            #worklist[parent][0].append(item)  # reverses the order

            worklist[parent][0][1:1] = [item]  # parent itself the 1st element

        #pprint(worklist)

    width = int(floor(log10(CALLSITE_COUNT))) + 1

    print('\n'.join([

        "/* compile with -lqb OR with -DQB_KILL_ATTRIBUTE_SECTION -l:libqb.so.0 */",

        "#include <qb/qblog.h>",

    ] + list_to_c_source(worklist, FNC_PREFIX, width) + [

        "int main(int argc, char *argv[]) {",

        "\tqb_log_init(\"log_gen_test\", LOG_DAEMON, LOG_INFO);",

        "\tqb_log_ctl(QB_LOG_SYSLOG, QB_LOG_CONF_ENABLED, QB_FALSE);",

        "\tqb_log_filter_ctl(QB_LOG_STDERR, QB_LOG_FILTER_ADD, QB_LOG_FILTER_FILE, \"*\", LOG_ERR);",

        "\tqb_log_ctl(QB_LOG_STDERR, QB_LOG_CONF_ENABLED, QB_TRUE);",

        "\tfor (int i = 0; i < {0}; i++) {{".format(ROUND_COUNT),

        "\t\t{0}_{1:0{2}}(argc);".format(FNC_PREFIX, first, width),

        "\t}",

        "\tqb_log_fini();",

        "\treturn !argc;",

        "}"

    ]

    ))

if __name__ == '__main__':

    # Full trees for CALLSITES_PER_FNC == 1 (can be trivially extrapolated):

    # BF = 2 (binary trees)

    # --> C = 7 (3 steps), 15 (4 steps), ..., 127 (6 steps), ...

    #     (see https://en.wikipedia.org/wiki/Binary_tree#Properties_of_binary_trees)

    # BF = 3 (ternary trees)

    # --> C = 13 (3 steps), 40 (4 steps), ..., 1093 (6 steps), ...

    #     (see https://en.wikipedia.org/wiki/Ternary_tree#Properties_of_ternary_trees)

    # ...

    BRANCHING_FACTOR = 3

    CALLSITES_PER_FNC = 10

    CALLSITE_COUNT = 3640

    ROUND_COUNT = 1000

    try:

        opts, args = getopt(argv[1:],

                             "hc:b:f:r:",

                            ("help", "callsite-count=", "branching-factor=",

                             "callsites-per-fnc=", "round-count="))

        for o, a in opts:

            if o in ("-h", "--help"):

                raise GetoptError("__justhelp__")

            elif o in ("-c", "--callsite-count"): CALLSITE_COUNT = a

            elif o in ("-b", "--branching-factor"): BRANCHING_FACTOR = a

            elif o in ("-f", "--callsites-per-fnc"): CALLSITES_PER_FNC = a

            elif o in ("-r", "--round-count"): ROUND_COUNT = a

    except GetoptError as err:

        if err.msg != "__justhelp__":

            print(str(err))

        print("Usage:\n{0} -h|--help\n"

              "{0} [-c X|--callsite-count={CALLSITE_COUNT}]"

              " [-b Y|--branching-factor={BRANCHING_FACTOR}]\n"

              "{1:{2}} [-f Z|--callsites-per-fnc={CALLSITES_PER_FNC}]"

              " [-r R|--round-count={ROUND_COUNT}]"

              .format(argv[0], '', len(argv[0]), **locals()))

        exit(0 if err.msg == "__justhelp__" else 2)

    opts = dict(CALLSITE_COUNT=CALLSITE_COUNT,

                BRANCHING_FACTOR=BRANCHING_FACTOR,

                CALLSITES_PER_FNC=CALLSITES_PER_FNC,

                ROUND_COUNT=ROUND_COUNT)

    main(opts, args)