"""Run: python -m pip install protobuf==7.36.2; python experiment.py.

Actual Python protobuf runtime, proto3 descriptors built in isolated pools.
No server, generated-code compiler, network request or timing benchmark.
"""
import json
import platform

import google.protobuf
from google.protobuf import descriptor_pb2, descriptor_pool, json_format, message_factory
from google.protobuf.internal import api_implementation


def message_type(new_schema):
    file = descriptor_pb2.FileDescriptorProto(name='relay.proto', package='relay', syntax='proto3')
    enum = file.enum_type.add(name='Status')
    for name, number in [('STATUS_UNSPECIFIED', 0), ('STATUS_READY', 1)] + (
        [('STATUS_PAUSED', 2)] if new_schema else []
    ):
        enum.value.add(name=name, number=number)
    msg = file.message_type.add(name='Job')
    msg.field.add(name='status', number=1, type=14, type_name='.relay.Status', label=1)
    msg.field.add(name='history', number=2, type=14, type_name='.relay.Status', label=3)
    entry = msg.nested_type.add(name='StatusesEntry')
    entry.options.map_entry = True
    entry.field.add(name='key', number=1, type=9, label=1)
    entry.field.add(name='value', number=2, type=14, type_name='.relay.Status', label=1)
    msg.field.add(name='statuses', number=3, type=11, type_name='.relay.Job.StatusesEntry', label=3)
    if new_schema:
        msg.field.add(name='memo', number=4, type=9, label=1)
    pool = descriptor_pool.DescriptorPool()
    pool.Add(file)
    return message_factory.GetMessageClass(pool.FindMessageTypeByName('relay.Job'))


def run():
    old, new = message_type(False), message_type(True)
    fixtures = [
        ('singular', new(status=2)),
        ('repeated', new(history=[1, 2])),
        ('map', new(statuses={'known': 1, 'future': 2})),
        ('new_field', new(status=1, memo='keep-me')),
    ]
    rows = []
    for route in ['binary', 'json_names_strict', 'json_names_ignore', 'json_numbers_ignore']:
        for fixture, original in fixtures:
            payload = None
            received = old()
            try:
                if route == 'binary':
                    payload = original.SerializeToString(deterministic=True).hex()
                    received.ParseFromString(bytes.fromhex(payload))
                    restored = new.FromString(received.SerializeToString(deterministic=True))
                    relayed = received.SerializeToString(deterministic=True).hex()
                else:
                    payload = json_format.MessageToDict(
                        original, use_integers_for_enums=(route == 'json_numbers_ignore')
                    )
                    json_format.ParseDict(payload, received, ignore_unknown_fields=route.endswith('ignore'))
                    relayed = json_format.MessageToDict(received)
                    restored = json_format.ParseDict(relayed, new())
                retained = original == restored
                outcome = 'preserved' if retained else 'changed'
                row = dict(route=route, fixture=fixture, input=payload, relay=relayed,
                           recovered=json_format.MessageToDict(restored, use_integers_for_enums=True),
                           outcome=outcome, preserved=retained)
            except json_format.ParseError as error:
                row = dict(route=route, fixture=fixture, input=payload,
                           outcome='rejected', preserved=False, errorType=type(error).__name__)
            rows.append(row)
    summaries = []
    for route in dict.fromkeys(row['route'] for row in rows):
        selected = [row for row in rows if row['route'] == route]
        summaries.append(dict(route=route, total=len(selected),
                              preserved=sum(row['outcome'] == 'preserved' for row in selected),
                              changed=sum(row['outcome'] == 'changed' for row in selected),
                              rejected=sum(row['outcome'] == 'rejected' for row in selected)))
    assert [(x['preserved'], x['changed'], x['rejected']) for x in summaries] == [
        (4, 0, 0), (0, 0, 4), (0, 4, 0), (3, 1, 0)
    ]
    # Binary to JSON does not invent the missing symbolic name. The old
    # schema emits the unknown integer, but its unknown object field is lost.
    received = old.FromString(new(status=2, memo='keep-me').SerializeToString())
    binary_to_json = json_format.MessageToDict(received)
    assert binary_to_json == {'status': 2}
    recovered = json_format.ParseDict(binary_to_json, new())
    assert recovered.status == 2 and recovered.memo == ''
    null_message = json_format.ParseDict({'status': None}, old(status=1))
    assert null_message.status == 0 and json_format.MessageToDict(null_message) == {}
    # Unknown numeric enum values are not a recognized application command.
    assert received.status == 2 and received.status not in {0, 1}
    extras = dict(binary_to_json=binary_to_json,
                  null_replaces_known_with_default=json_format.MessageToDict(null_message),
                  unknown_number_is_known_business_action=received.status in {0, 1})
    return dict(python=platform.python_version(), protobuf=google.protobuf.__version__,
                implementation=api_implementation.Type(), schema='proto3 open enum',
                fixtureCount=len(fixtures), routeCount=len(summaries), caseCount=len(rows),
                cases=rows, summaries=summaries, boundaryChecks=extras)


if __name__ == '__main__':
    print(json.dumps(run(), indent=2, sort_keys=True))
