using BepInEx;
using BepInEx.Configuration;
using Comfort.Common;
using EFT;
using EFT.Settings.Graphics;
using System.Collections;
using System.ComponentModel;
using System.Reflection;
using UnityEngine;

/*      Dependencies:
 *  ../BepInEx/core/
 *      BepInEx.dll
 *  ../EscapeFromTarkov_Data/Managed/
 *      Aki.Reflection.dll
 *      Assembly-CSharp.dll
 *      Comfort.dll
 *      ItemComponent.Types.dll
 *      System.dll
 *      Unity.Postprocessing.Runtime.dll
 *      UnityEngine.dll
 *      UnityEngine.CoreModule.dll
 */
namespace ScopeTweaks
{
    [BepInPlugin("com.notGreg.scopeTweaks", "notGreg's Scope Tweaks", "3.5.0")]
    public class Plugin : BaseUnityPlugin
    {
        ConfigEntry<int> cameraResolutionScale;
        ConfigEntry<int> scopeCameraResolutionScale;
        ConfigEntry<EFOVScalingMode> scopeFixType;
        ConfigEntry<bool> enableDebug;

        enum EFOVScalingMode
        {
            Disabled,
            [Description("Magnified optics")]
            ScopesOnly,
            [Description("All sights")]
            All,
        }

        //The following assignments should allow for faster patching in the future.
        //The correct GClass can be found by searching for "ClearSettings" in Assembly-CSharp.dll via dnSpy, netFiddle, ilSpy, etc.

        //GClass1642 settingsLibrary = Singleton<GClass1642>.Instance; //used by SPT-AKI 3.2.3
        //GClass1653 settingsLibrary = Singleton<GClass1653>.Instance; //used by SPT-AKI 3.3.0
        //GClass1659 settingsLibrary = Singleton<GClass1659>.Instance; //used by SPT-AKI 3.4.1

        //The correct GClass can be found by searching for "SetFov" in Assembly-CSharp.dll via dnSpy, netFiddle, ilSpy, etc.

        //GClass1774 setFovLibrary = Singleton<GClass1774>.Instance; //used by SPT-AKI 3.2.3
        //GClass1785 setFovLibrary = Singleton<GClass1785>.Instance; //used by SPT-AKI 3.3.0
        CameraClass setFovLibrary = CameraClass.Instance; //used by SPT-AKI 3.4.1 and 3.5.0

        void Awake()
        {
            cameraResolutionScale = Config.Bind(
                "General",
                "Main camera scale %",
                80,
                new ConfigDescription("Additional override applied on top of currently enabled resolution scaling method.", new AcceptableValueRange<int>(25, 100)));

            scopeCameraResolutionScale = Config.Bind(
                "General",
                "Scope camera scale %",
                80,
                new ConfigDescription("Additional override applied on top of currently enabled resolution scaling method.", new AcceptableValueRange<int>(25, 100)));

            scopeFixType = Config.Bind(
                "General",
                "High FOV sight tweak",
                EFOVScalingMode.ScopesOnly,
                new ConfigDescription(""));

            enableDebug = Config.Bind("Debug", "Enable debug logging", false);
        }

        void FixedUpdate()
        {
            //Check if the game is in a valid state and execute logic depening on the status of the game
            if (Singleton<AbstractGame>.Instance == null) return;
            GameStatus currentGameState = Singleton<AbstractGame>.Instance.Status;

            //logic should only execute once per game instead of every frame
            if (!gameStateChanged(currentGameState)) return;

            switch (currentGameState)
            {
                case GameStatus.Started:
                    {
                        if (enableDebug.Value) Logger.LogInfo("Getting local player");
                        mainPlayer = getLocalPlayer();

                        subscribeHandsChangedEvent();

                        if (enableDebug.Value) Logger.LogInfo("Assigning cameras...");
                        StartCoroutine(tryGetMainCamera());
                        StartCoroutine(tryGetScopeCamera());

                        defaultInGameFOV = inGameFOV;

                        break;
                    }
                case GameStatus.SoftStopping:
                case GameStatus.Stopping:
                case GameStatus.Stopped:
                    {

                        if (enableDebug.Value) Logger.LogInfo("Resetting...");
                        FPSCamera = null;
                        scopeCamera = null;
                        mainPlayer = null;

                        if (enableDebug.Value) Logger.LogInfo($"Restoring FOV in settings: {defaultInGameFOV}");
                        inGameFOV = defaultInGameFOV;

                        break;
                    }
                default: break;
            }
        }

        /// <summary>
        /// GAME STATUS
        /// </summary>

        GameStatus lastGameState;
        //compare current game status to the last saved game status, return true if game status has changed
        bool gameStateChanged(GameStatus currentState)
        {
            if (currentState == lastGameState) return false;
            lastGameState = currentState;
            return true;
        }

        Player mainPlayer;
        //find and return the player character in the session
        Player getLocalPlayer()
        {
            if (enableDebug.Value) Logger.LogInfo("Looking for local player...");
            Player localPlayer = Singleton<GameWorld>.Instance.RegisteredPlayers.Find(p => p.IsYourPlayer);
            if (enableDebug.Value && localPlayer != null) Logger.LogInfo($"Found local player: {localPlayer.GetType()}");
            return localPlayer;
        }

        /// <summary>
        /// FIELD OF VIEW
        /// </summary>
        /// 
        private int defaultInGameFOV;
        private int inGameFOV
        {
            get
            {
                //int fov = settingsLibrary.Game.Settings.FieldOfView.Value;
                //int fov = Singleton<GClass1659>.Instance.Game.Settings.FieldOfView.Value; //SPT-AKI 3.4.1
                int fov = Singleton<GClass1776>.Instance.Game.Settings.FieldOfView.Value; // SPT-AKI 3.5.0
                if (enableDebug.Value) Logger.LogInfo($"get_defaultInGameFOV: Reading from settings: {fov}");
                return fov;
            }
            set
            {
                if (enableDebug.Value) Logger.LogInfo($"set_defaultInGameFOV: Writing to settings: {value}");
                //settingsLibrary.Game.Settings.FieldOfView.Value = value;
                //int fov = Singleton<GClass1659>.Instance.Game.Settings.FieldOfView.Value;
                Singleton<GClass1776>.Instance.Game.Settings.FieldOfView.Value = value; // SPT-AKI 3.5.0
            }
        }

        /// <summary>
        /// CAMERA SETUP
        /// </summary>

        Camera FPSCamera = null;
        Camera scopeCamera = null;

        SSAA ssaaInstance = null;
        FieldInfo _nextSSRation = null;

        WaitForSeconds myDelaySec = new WaitForSeconds(1);
        IEnumerator tryGetMainCamera()
        {
            string cameraName = "FPS Camera";
            if (GameObject.Find(cameraName) != null)
            {
                FPSCamera = GameObject.Find(cameraName).GetComponent<Camera>();
                if (enableDebug.Value) Logger.LogInfo($"{FPSCamera.name} found!");
                StopCoroutine(tryGetMainCamera());
            }
            else
            {
                if (enableDebug.Value) Logger.LogMessage($"Camera \"{cameraName}\" not found.");
                yield return myDelaySec;
                StartCoroutine(tryGetMainCamera());
                yield break;
            }
            yield return null;
        }

        FieldInfo getFieldInfo(string fieldName)
        {
            return typeof(SSAA).GetField(fieldName, BindingFlags.NonPublic | BindingFlags.Instance);
        }

        IEnumerator tryGetScopeCamera()
        {
            string cameraName = "BaseOpticCamera(Clone)";
            if (GameObject.Find(cameraName) != null)
            {
                scopeCamera = GameObject.Find(cameraName).GetComponent<Camera>();
                if (enableDebug.Value) Logger.LogInfo($"Camera \"{scopeCamera.name}\" found!");
                StopCoroutine(tryGetScopeCamera());
            }
            yield break;
        }
        void setMainCameraResolutionScale(int value = 100)
        {
            if (ssaaInstance == null)
            {
                ssaaInstance = FPSCamera.GetComponent<SSAA>();
                _nextSSRation = getFieldInfo("_nextSSRation");
            }
            float target_res = currentScalingFactor * (value / 100.0f);

            if (enableDebug.Value) Logger.LogInfo($"Setting MainCam res scale to {Mathf.Round(target_res*100.0f)}%");
            //_nextSSRation.SetValue(ssaaInstance, (float)(currentScalingFactor * (value / 100.0f)));
            
        }

        SSAAOptic ssaaOpticInstance = null;

        void setScopeCameraResolutionScale(int value)
        {
            if (scopeCamera == null || !scopeCamera.isActiveAndEnabled)
            {
                if (enableDebug.Value) Logger.LogInfo("ScopeCam inactive or absent!");
                return;
            }

            if (enableDebug.Value) Logger.LogInfo($"Setting Scope res scale to {value}%");
            
            if (ssaaOpticInstance == null)
            {
                ssaaOpticInstance = scopeCamera.GetComponent<SSAAOptic>();
            }

            ssaaOpticInstance.OpticCameraToMainCameraResolutionRatio = (float)(currentScalingFactor * (value / 100.0f));
        }

        /// <summary>
        /// PLAYER WEAPON EVENTS
        /// </summary>
        void subscribeHandsChangedEvent()
        {
            if (enableDebug.Value) Logger.LogInfo("Subscribing to HandsChanged Event");
            mainPlayer.HandsChangedEvent += (handsArgs) =>
            {
                subscribeOnAimingChangedEvent();
            };
        }

        void subscribeOnAimingChangedEvent()
        {

            if (enableDebug.Value) Logger.LogInfo("Subscribing to OnAimingChanged Event");
            mainPlayer.HandsController.OnAimingChanged += (aimingArgs) =>
            {
                currentScalingFactor = getCurrentScalingFactor();
                StartCoroutine(tryGetScopeCamera());
                    
                if (!mainPlayer.ProceduralWeaponAnimation.IsAiming)
                {
                    float aimSpeed = 0.7f * mainPlayer.ProceduralWeaponAnimation.AimingSpeed;

                    switch (scopeFixType.Value)
                    {
                        case EFOVScalingMode.Disabled:
                            {
                                if (enableDebug.Value) Logger.LogInfo($"Switch: Not Aiming: ScalingMode: {scopeFixType.Value}");
                                break;
                            }
                        case EFOVScalingMode.ScopesOnly:
                            {
                                if (enableDebug.Value) Logger.LogInfo($"Switch: Not Aiming: ScalingMode: {scopeFixType.Value}");
                                setMainCameraResolutionScale();
                                setFovLibrary.SetFov(defaultInGameFOV, aimSpeed, false);
                                inGameFOV = defaultInGameFOV;

                                mainPlayer.ProceduralWeaponAnimation.ResetFovAdjustments(mainPlayer);

                                break;
                            }
                        case EFOVScalingMode.All:
                            {
                                if (enableDebug.Value) Logger.LogInfo($"Switch: Not Aiming: ScalingMode: {scopeFixType.Value}");
                                setMainCameraResolutionScale();

                                setFovLibrary.SetFov(defaultInGameFOV, aimSpeed, false);
                                inGameFOV = defaultInGameFOV;

                                mainPlayer.ProceduralWeaponAnimation.ResetFovAdjustments(mainPlayer);

                                break;
                            }
                    }
                    return;
                }

                if (mainPlayer.ProceduralWeaponAnimation.IsAiming)
                {
                    defaultInGameFOV = inGameFOV;
                    switch (scopeFixType.Value)
                    {
                        case EFOVScalingMode.Disabled:
                            {
                                if (enableDebug.Value) Logger.LogInfo($"Switch: Aiming: ScalingMode: {scopeFixType.Value}");
                                break;
                            }
                        case EFOVScalingMode.ScopesOnly:
                            {
                                if (enableDebug.Value) Logger.LogInfo($"Switch: Aiming: ScalingMode: {scopeFixType.Value}");
                                if (scopeCamera != null && scopeCamera.isActiveAndEnabled)
                                {
                                    applyFixesWhileAiming();
                                }
                                else
                                {
                                    if (enableDebug.Value) Logger.LogInfo("ScopeCamera not found or disabled!");
                                }
                                break;
                            }
                        case EFOVScalingMode.All:
                            {
                                if (enableDebug.Value) Logger.LogInfo($"Switch: Aiming: ScalingMode: {scopeFixType.Value}");

                                applyFixesWhileAiming();

                                break;
                            }
                    }
                }
            };
        }

        void applyFixesWhileAiming()
        {
            //if (enableDebug.Value) Logger.LogInfo($"AimingSpeed: {mainPlayer.ProceduralWeaponAnimation.AimingSpeed}");
            if (enableDebug.Value) Logger.LogInfo("Applying aiming tweaks");

            float aimSpeed = mainPlayer.ProceduralWeaponAnimation.AimingSpeed * 0.7f;

            setFovLibrary.SetFov(35, aimSpeed, false);
            inGameFOV = 50;

            if (enableDebug.Value) Logger.LogInfo("Updating scope resolution");
            setMainCameraResolutionScale(cameraResolutionScale.Value);
            setScopeCameraResolutionScale(scopeCameraResolutionScale.Value);
        }

        /// <summary>
        /// IN-GAME SETTINGS
        /// </summary>

        float currentScalingFactor = 1.0f;

        float getCurrentScalingFactor()
        {
            if (enableDebug.Value) Logger.LogInfo("Getting current scaling factor:");
            //var graphics = settingsLibrary.Graphics.Settings; //SPT-AKI 3.3.0
            //var graphics = Singleton<GClass1659>.Instance.Graphics.Settings; // SPT-AKI 3.4.1
            var graphics = Singleton<GClass1776>.Instance.Graphics.Settings; // SPT-AKI 3.5.0

            //if (!graphics.DLSSEnabled && !graphics.FSREnabled)
            //{
            //    if (enableDebug.Value) Logger.LogInfo($"Supersampling factor: {graphics.SuperSamplingFactor}");
            //    return graphics.SuperSamplingFactor;
            //}

            if (graphics.DLSSEnabled)
            {
                float DLSSFactor = 1.0f;
                switch (graphics.DLSSMode.Value)
                {
                    case EDLSSMode.Off: { DLSSFactor = 1.0f; break; }
                    case EDLSSMode.Quality: { DLSSFactor = 0.67f; break; }
                    case EDLSSMode.Balanced: { DLSSFactor = 0.58f; break; }
                    case EDLSSMode.Performance: { DLSSFactor = 0.5f; break; }
                    case EDLSSMode.UltraPerformance: { DLSSFactor = 0.33f; break; }
                }
                if (enableDebug.Value) Logger.LogInfo($"DLSS factor: {DLSSFactor}");
                return DLSSFactor;
            }
            if (graphics.FSREnabled)
            {
                float FSRFactor = 1.0f;
                switch (graphics.FSRMode.Value)
                {
                    case EFSRMode.Off: { FSRFactor = 1.0f; break; }
                    case EFSRMode.UltraQuality: { FSRFactor = 0.77f; break; }
                    case EFSRMode.Quality: { FSRFactor = 0.66f; break; }
                    case EFSRMode.Balanced: { FSRFactor = 0.59f; break; }
                    case EFSRMode.Performance: { FSRFactor = 0.5f; break; }
                }
                if (enableDebug.Value) Logger.LogInfo($"FSR factor: {FSRFactor}");
                return FSRFactor;
            }
            if (graphics.FSR2Enabled)
            {
                float FSR2Factor = 1.0f;
                switch (graphics.FSR2Mode.Value)
                {
                    case EFSR2Mode.Off: { FSR2Factor = 1.0f; break; }
                    case EFSR2Mode.Quality: { FSR2Factor = 0.67f; break; }
                    case EFSR2Mode.Balanced: { FSR2Factor = 0.59f; break; }
                    case EFSR2Mode.Performance: { FSR2Factor = 0.5f; break; }
                    case EFSR2Mode.UltraPerformance: { FSR2Factor = 0.33f; break; }
                }
                if (enableDebug.Value) Logger.LogInfo($"FSR factor: {FSR2Factor}");
                return FSR2Factor;
            }

            if (enableDebug.Value) Logger.LogInfo($"Supersampling factor: {graphics.SuperSamplingFactor}");
            return graphics.SuperSamplingFactor;

            //if (enableDebug.Value) Logger.LogInfo($"GetCurrentScalingFactor(): Something went wrong. Returning 1.0f");
            //return 1.0f;
        }
    }
}