#!/usr/bin/env python3
"""Explore GeViScope server structure in detail"""

import asyncio
import sys
import os

sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))

from api.protos import configuration_pb2, configuration_pb2_grpc
import grpc

async def explore_geviscope():
    """Explore GeViScope server structure"""

    channel = grpc.aio.insecure_channel('localhost:50051')
    stub = configuration_pb2_grpc.ConfigurationServiceStub(channel)

    try:
        request = configuration_pb2.ReadConfigurationTreeRequest()
        response = await stub.ReadConfigurationTree(request, timeout=10.0)

        print("=" * 70)
        print("GeViScope Server Configuration (GeViGscServer folder)")
        print("=" * 70)

        for child in response.root.children:
            if child.name == "GeViGscServer":
                print(f"\nFolder: {child.name}")
                print(f"Total children: {len(child.children)}")
                print()

                # Separate servers from settings
                servers = []
                settings = []

                for item in child.children:
                    if item.type == "folder":
                        servers.append(item)
                    else:
                        settings.append(item)

                # Show global settings
                if settings:
                    print(f"Global Settings ({len(settings)}):")
                    for setting in settings:
                        value = ""
                        if hasattr(setting, 'int_value'):
                            value = f" = {setting.int_value}"
                        elif hasattr(setting, 'bool_value'):
                            value = f" = {setting.bool_value}"
                        print(f"  - {setting.name} ({setting.type}){value}")
                    print()

                # Show servers in detail
                if servers:
                    print(f"GeViScope Servers ({len(servers)}):")
                    print()
                    for server in servers:
                        print(f"  [{server.name}]")

                        # Get all fields with their types and values
                        for field in server.children:
                            value_str = ""
                            if field.type == "string":
                                value_str = f" = \"{field.string_value if hasattr(field, 'string_value') else 'N/A'}\""
                            elif field.type == "int32":
                                value_str = f" = {field.int_value if hasattr(field, 'int_value') else 'N/A'}"
                            elif field.type == "bool":
                                value_str = f" = {field.bool_value if hasattr(field, 'bool_value') else 'N/A'}"

                            print(f"    {field.name:30s} ({field.type:8s}){value_str}")
                        print()

                # Compare with G-Core servers
                print("\n" + "=" * 70)
                print("Comparison: GeViScope vs G-Core Server Fields")
                print("=" * 70)

                geviscope_fields = set()
                if servers:
                    geviscope_fields = {f.name for f in servers[0].children}

                # Get G-Core fields for comparison
                for child2 in response.root.children:
                    if child2.name == "GeViGCoreServer":
                        if len(child2.children) > 0:
                            first_gcore = next(c for c in child2.children if c.type == "folder")
                            gcore_fields = {f.name for f in first_gcore.children}

                            common = geviscope_fields & gcore_fields
                            geviscope_only = geviscope_fields - gcore_fields
                            gcore_only = gcore_fields - geviscope_fields

                            print(f"\nCommon fields ({len(common)}):")
                            for f in sorted(common):
                                print(f"  ✓ {f}")

                            print(f"\nGeViScope-only fields ({len(geviscope_only)}):")
                            for f in sorted(geviscope_only):
                                print(f"  + {f}")

                            print(f"\nG-Core-only fields ({len(gcore_only)}):")
                            for f in sorted(gcore_only):
                                print(f"  - {f}")

                break

        await channel.close()

    except Exception as e:
        print(f"ERROR: {e}")
        import traceback
        traceback.print_exc()
        await channel.close()

if __name__ == "__main__":
    asyncio.run(explore_geviscope())