﻿using UnityEngine;
using UnityEditor;
using System.IO;

namespace FrameDoctor.Editor.Config
{
    // Constants for FrameDoctor plugin.
    public static class FrameDoctorConstants
    {
        public const string WebServiceUrl = "https://framedoctor.dev";
        public const string DocsUrl = "https://docs.framedoctor.dev";
        public const string Version = "1.0.1";

        public const string ApiBaseUrl = "https://api.framedoctor.dev";
        public const string AuthPath = "/auth/unity";
        public const string UploadPath = "/api/v1/sessions";
        public const string SessionPath = "/session";
    }

    // Settings ScriptableObject for FrameDoctor plugin.
    // All tunable parameters are stored here.
    public class FrameDoctorSettings : ScriptableObject
    {
        private const string SettingsPath = "Assets/Editor/FrameDoctorSettings.asset";

        [SerializeField]
        [Tooltip("Path where exported profiler data will be saved")]
        private string _exportPath;

        [SerializeField]
        [Tooltip("Maximum capture duration in seconds (0 = unlimited)")]
        private int _maxCaptureDuration = 0;

        [SerializeField]
        [Tooltip("Silence informational console logs (warnings and errors will still be shown)")]
        private bool _silenceConsoleLogs = false;

        [SerializeField]
        [Tooltip("Automatically open browser after uploading analysis")]
        private bool _autoOpenBrowserAfterUpload = true;

        public string ExportPath
        {
            get => _exportPath;
            set
            {
                _exportPath = value;
                EditorUtility.SetDirty(this);
            }
        }

        public int MaxCaptureDuration
        {
            get => _maxCaptureDuration;
            set
            {
                _maxCaptureDuration = value;
                EditorUtility.SetDirty(this);
            }
        }

        public bool SilenceConsoleLogs
        {
            get => _silenceConsoleLogs;
            set
            {
                _silenceConsoleLogs = value;
                EditorUtility.SetDirty(this);
            }
        }

        public bool AutoOpenBrowserAfterUpload
        {
            get => _autoOpenBrowserAfterUpload;
            set
            {
                _autoOpenBrowserAfterUpload = value;
                EditorUtility.SetDirty(this);
            }
        }

        // Helper method for logging that respects the silence setting.
        public static void Log(string message)
        {
            if (!Instance.SilenceConsoleLogs)
            {
                Debug.Log(message);
            }
        }

        private static FrameDoctorSettings _instance;

        public static FrameDoctorSettings Instance
        {
            get
            {
                if (_instance == null)
                {
                    _instance = AssetDatabase.LoadAssetAtPath<FrameDoctorSettings>(SettingsPath);

                    if (_instance == null)
                    {
                        _instance = CreateInstance<FrameDoctorSettings>();
                        _instance._exportPath = Path.Combine(Application.persistentDataPath, "FrameDoctor");

                        var directory = Path.GetDirectoryName(SettingsPath);
                        if (!Directory.Exists(directory))
                        {
                            Directory.CreateDirectory(directory);
                        }

                        AssetDatabase.CreateAsset(_instance, SettingsPath);
                        AssetDatabase.SaveAssets();
                    }
                }

                return _instance;
            }
        }
    }

    // Settings provider for FrameDoctor in Unity Preferences.
    public class FrameDoctorSettingsProvider : SettingsProvider
    {
        private SerializedObject _serializedSettings;

        public FrameDoctorSettingsProvider(string path, SettingsScope scope)
            : base(path, scope)
        {
        }

        public override void OnActivate(string searchContext, UnityEngine.UIElements.VisualElement rootElement)
        {
            _serializedSettings = new SerializedObject(FrameDoctorSettings.Instance);
        }

        public override void OnGUI(string searchContext)
        {
            _serializedSettings.Update();

            EditorGUILayout.Space(10);
            EditorGUILayout.LabelField("FrameDoctor Settings", EditorStyles.boldLabel);
            EditorGUILayout.Space(10);

            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PropertyField(_serializedSettings.FindProperty("_exportPath"), new GUIContent("Export Path"));
            if (GUILayout.Button("Browse", GUILayout.Width(60)))
            {
                var path = EditorUtility.OpenFolderPanel("Select Export Folder", FrameDoctorSettings.Instance.ExportPath, "");
                if (!string.IsNullOrEmpty(path))
                {
                    _serializedSettings.FindProperty("_exportPath").stringValue = path;
                }
            }
            EditorGUILayout.EndHorizontal();

            EditorGUILayout.Space(5);
            EditorGUILayout.PropertyField(_serializedSettings.FindProperty("_maxCaptureDuration"), new GUIContent("Max Capture Duration (s)"));

            EditorGUILayout.Space(5);
            EditorGUILayout.PropertyField(_serializedSettings.FindProperty("_silenceConsoleLogs"), new GUIContent("Silence Console Logs"));

            EditorGUILayout.Space(5);
            EditorGUILayout.PropertyField(_serializedSettings.FindProperty("_autoOpenBrowserAfterUpload"), new GUIContent("Auto-open browser after upload"));

            _serializedSettings.ApplyModifiedProperties();
        }

        [SettingsProvider]
        public static SettingsProvider CreateSettingsProvider()
        {
            return new FrameDoctorSettingsProvider("Preferences/FrameDoctor", SettingsScope.User)
            {
                keywords = new[] { "FrameDoctor", "Profiler", "Performance", "AI" }
            };
        }
    }
}
