using UnityEngine;
using System.Collections.Generic;
using System;

public class GameManager : MonoBehaviour
{
    public static GameManager Instance { get; private set; }

    [Serializable]
    public class ManagerConfig
    {
        public GameObject prefab;
        public string managerName;
    }

    [SerializeField]
    private ManagerConfig[] managerConfigs;

    private readonly Dictionary<string, GameObject> managers = new Dictionary<string, GameObject>();
    private readonly Dictionary<string, IMethodHandler> methodHandlers = new Dictionary<string, IMethodHandler>();

    private void Awake()
    {
        InitializeSingleton();
        InitializeManagers();
    }

    private void InitializeSingleton()
    {
        if (Instance != null && Instance != this)
        {
            Destroy(gameObject);
            return;
        }

        Instance = this;
        DontDestroyOnLoad(gameObject);
    }

    private void InitializeManagers()
    {
        if (managerConfigs == null || managerConfigs.Length == 0)
        {
            Debug.LogError("No manager configs assigned!");
            return;
        }

        foreach (var config in managerConfigs)
        {
            if (config.prefab == null)
            {
                Debug.LogError($"Prefab not assigned for {config.managerName}!");
                continue;
            }

            try
            {
                InstantiateManager(config);
            }
            catch (Exception e)
            {
                Debug.LogError($"Failed to initialize {config.managerName}: {e.Message}");
            }
        }
    }

    private void InstantiateManager(ManagerConfig config)
    {
        var managerObject = Instantiate(config.prefab);
        managerObject.name = config.managerName;
        managers[config.managerName] = managerObject;

        var methodHandler = managerObject.GetComponent<IMethodHandler>();
        if (methodHandler != null)
        {
            methodHandlers[config.managerName] = methodHandler;
        }
        else
        {
            Debug.LogWarning($"{config.managerName} doesn't implement IMethodHandler interface");
        }
    }

    public void CallMethod(string jsonStr)
    {
        try
        {
            var callConfig = JsonCallParser.ParseJsonConfig(jsonStr);
            if (string.IsNullOrEmpty(callConfig.unityObject) || string.IsNullOrEmpty(callConfig.method))
            {
                throw new ArgumentException("Invalid call configuration");
            }

            Debug.Log($"Received call: {callConfig.unityObject}.{callConfig.method}({callConfig.args})");

            if (!methodHandlers.TryGetValue(callConfig.unityObject, out var handler))
            {
                throw new KeyNotFoundException($"Unknown manager: {callConfig.unityObject}");
            }

            handler.HandleMethod(callConfig.method, callConfig.args);
        }
        catch (Exception e)
        {
            Debug.LogError($"Error processing method call: {e.Message}");
        }
    }

    public T GetManager<T>(string managerName) where T : Component
    {
        if (managers.TryGetValue(managerName, out var manager))
        {
            return manager.GetComponent<T>();
        }
        return null;
    }
}