#!/usr/bin/python
#
# Copyright (C) 2017 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# Test converter of a Config proto.

# Generate with:
#  aprotoc -I=system/extras/perfprofd --python_out=system/extras/perfprofd/scripts \
#      system/extras/perfprofd/binder_interface/perfprofd_config.proto
#
# Note: it is necessary to do a '*' import to not have to jump through hoops
#       with reflective instantiation.
from perfprofd_config_pb2 import *

# Necessary for introspection.
from google.protobuf.descriptor import FieldDescriptor

import sys

PROTO_FIELD_TYPE_NAMES = {
    FieldDescriptor.TYPE_DOUBLE: "double",
    FieldDescriptor.TYPE_FLOAT: "float",
    FieldDescriptor.TYPE_INT64: "int64",
    FieldDescriptor.TYPE_UINT64: "uint64",
    FieldDescriptor.TYPE_INT32: "int32",
    FieldDescriptor.TYPE_FIXED64: "fixed64",
    FieldDescriptor.TYPE_FIXED32: "fixed32",
    FieldDescriptor.TYPE_BOOL: "bool",
    FieldDescriptor.TYPE_STRING: "string",
    FieldDescriptor.TYPE_GROUP: "group",
    FieldDescriptor.TYPE_MESSAGE: "message",
    FieldDescriptor.TYPE_BYTES: "bytes",
    FieldDescriptor.TYPE_UINT32: "uint32",
    FieldDescriptor.TYPE_ENUM: "enum",
    FieldDescriptor.TYPE_SFIXED32: "sfixed32",
    FieldDescriptor.TYPE_SFIXED64: "sfixed64",
    FieldDescriptor.TYPE_SINT32: "sint32",
    FieldDescriptor.TYPE_SINT64: "sint64",
}
def get_type_string(proto_field_type):
    if proto_field_type in PROTO_FIELD_TYPE_NAMES:
        return PROTO_FIELD_TYPE_NAMES[proto_field_type]
    return "unknown type"


def read_message(msg_descriptor, indent):
    istr = ' ' * indent
    print('%s%s' % (istr, msg_descriptor.name))
    # Create an instance
    instance = globals()[msg_descriptor.name]()

    # Fill fields.

    primitive_fields = [None]
    message_fields = [None]
    for field in msg_descriptor.fields:
        if field.type == FieldDescriptor.TYPE_MESSAGE:
            message_fields.append(field)
        else:
            primitive_fields.append(field)

    def table_loop(fields, field_fn):
        while True:
            # Print selection table
            maxlen = len(str(len(fields) - 1))
            def pad_index(key):
                while len(key) < maxlen:
                    key = ' ' + key
                return key

            for i in xrange(1, len(fields)):
                print('%s%s: %s' % (istr, pad_index(str(i)), fields[i].name))
            print('%s%s: done' % (istr, pad_index('0')))
            print('%s%s: end' % (istr, pad_index('!')))

            sel = raw_input('%s ? ' % (istr))
            if sel == '!':
                # Special-case input, end argument collection.
                return False

            try:
                sel_int = int(sel)
                if sel_int == 0:
                    return True

                if sel_int > 0 and sel_int < len(fields):
                    field = fields[sel_int]
                    if not field_fn(field):
                        return False
                else:
                    print('Not a valid input (%d)!' % (sel_int))
                    continue
            except:
                print('Not a valid input! (%s, %s)' % (sel, str(sys.exc_info()[0])))
                continue

#    # 1) Non-message-type fields.
    if len(primitive_fields) > 1:
        print('%s(Primitives)' % (istr))

        def primitive_fn(field):
            input = raw_input('%s  -> %s (%s): ' % (istr, field.name, get_type_string(field.type)))
            if input == '':
                # Skip this field
                return True
            if input == '!':
                # Special-case input, end argument collection.
                return False

            # Simplification: assume ints or bools or strings, but not floats
            if field.type == FieldDescriptor.TYPE_BOOL:
                input = input.lower()
                set_val = True if input == 'y' or input == 'true' or input == '1' else False
            elif field.type == FieldDescriptor.TYPE_STRING:
                set_val = input
            else:
                try:
                    set_val = int(input)
                except:
                    print('Could not parse input as integer!')
                    return True
            if field.label == FieldDescriptor.LABEL_REPEATED:
                getattr(instance, field.name).extend([set_val])
            else:
                setattr(instance, field.name, set_val)
            return True

        if not table_loop(primitive_fields, primitive_fn):
            return (instance, False)

    # 2) Message-type fields.
    if len(message_fields) > 1:
        print('%s(Nested messages)' % (istr))

        def message_fn(field):
            sub_msg, cont = read_message(field.message_type, indent + 4)
            if sub_msg is not None:
                if field.label == FieldDescriptor.LABEL_REPEATED:
                    # Repeated field, use extend.
                    getattr(instance, field.name).extend([sub_msg])
                else:
                    # Singular field, copy into.
                    getattr(instance, field.name).CopyFrom(sub_msg)
            return cont

        if not table_loop(message_fields, message_fn):
            return (instance, False)

    return (instance, True)


def collect_and_write(filename):
    config, _ = read_message(ProfilingConfig.DESCRIPTOR, 0)

    if config is not None:
        with open(filename, "wb") as f:
            f.write(config.SerializeToString())


def read_and_print(filename):
    config = ProfilingConfig()

    with open(filename, "rb") as f:
        config.ParseFromString(f.read())

    print config


def print_usage():
    print('Usage: python perf_config_proto.py (read|write) filename')


if __name__ == "__main__":
    if len(sys.argv) < 3:
        print_usage()
    elif sys.argv[1] == 'read':
        read_and_print(sys.argv[2])
    elif sys.argv[1] == 'write':
        collect_and_write(sys.argv[2])
    else:
        print_usage()