using BepInEx;
using BepInEx.Configuration;
using System;
using UnityEngine;
using TarkovUniformAim;

namespace UniformAim
{

        [BepInPlugin("com.greg.tarkovuniformaim", "Uniform Aim for Tarkov", "0.1.1")]
        [BepInProcess("EscapeFromTarkov.exe")]

        public class UniformAimConfig : BaseUnityPlugin
        {
            //Bepinex.Configurator fields
            public static ConfigEntry<int> configFOV;
            public static ConfigEntry<float> configCoeff;
            public static ConfigEntry<int> configSens;

            void Awake()
            {

                //Enable uniform aim patch
                new UpdateSensitivityPatch().Enable();

                //add configuration slider for field of view
                configFOV = Config.Bind("General", "FOV", 75, new ConfigDescription("In-game Field of View value", new AcceptableValueRange<int>(50, 75)));

                //add coefficient slider
                configCoeff = Config.Bind("General", "Coefficient", 1.33f, new ConfigDescription("Coefficient - increases sensitivity at higher zoom levels, default 4/3", new AcceptableValueRange<float>(0.001f, 5.0f)));

                //add secondary sensitivity slider for greater control
                configSens = Config.Bind("General", "Sensitivity", 25, new ConfigDescription("Secondary sensitivity multiplier in case Tarkov's default isn't enough", new AcceptableValueRange<int>(1, 200)));

            }
        }

    public class UniformAimUtils : MonoBehaviour
        {
            //Return aspect ratio based on game window resolution
            float GetAspectRatio()
            {
                string screenWidth = Screen.width.ToString();
                string screenHeight = Screen.height.ToString();
                float resX = Convert.ToUInt16(screenWidth);
                float resY = Convert.ToUInt16(screenHeight);

                //Logger.LogInfo("GetAspectRatio(): resX: " + resX + " resY: " + resY);
                return (resX / resY);
            }
            //convert degrees to radians
            float Deg2Rad(float angle)
            {
                return (float)(angle * Math.PI / 180);
            }
            //convert radians to degrees
            float Rad2Deg(float radian)
            {
                return (float)(radian * 180 / Math.PI);
            }
            //calculate horizontal FOV based on vertical FOV
            float CalculateHFOV(float FOV)
            {
                float vFOVRad = Deg2Rad(FOV);
                float hFOVRad = (float)(2 * Math.Atan(Math.Tan(Deg2Rad(FOV) / 2) * GetAspectRatio()));

                return (float)(Math.Round(Rad2Deg(hFOVRad)));
            }
            //calculate sensitivity based on FOV difference and coefficient
            float CalculateSensitivity(float aimedFOV, float hipFOV)
            {   //clamp to avoid invalid values
                aimedFOV = Mathf.Clamp(aimedFOV, 0.001f, 90f);
                hipFOV = Mathf.Clamp(hipFOV, 0.001f, 90f);

                //halve and convert to radians
                aimedFOV = Deg2Rad(aimedFOV / 2);
                hipFOV = Deg2Rad(hipFOV / 2);

                //ratio of tangents as sensitivity
                float sensitivity = (float)(Math.Tan(aimedFOV) / Math.Tan(hipFOV));

                return sensitivity;


            }

            public static float adjustedSensitivity = -1f;

            float lastFOV = -1f;
            float lastFOV2 = -1f;

            float FPSCameraFOV = -1f;
            float ScopeFOV = -1f;
            float currentFOV = -1f;

            void Update()
            {
                if (Camera.allCamerasCount >= 1)
                {
                    FPSCameraFOV = Camera.allCameras[0].fieldOfView;
                }
                if (Camera.allCamerasCount >= 2)
                {
                    ScopeFOV = Camera.allCameras[1].fieldOfView;
                }
                if (Camera.allCamerasCount >= 1 && FPSCameraFOV != lastFOV)
                {
                    //Logger.LogInfo("[0] FOV: " + FPSCameraFOV);
                    lastFOV = FPSCameraFOV;
                }
                if (Camera.allCamerasCount >= 2 && ScopeFOV != lastFOV2)
                {
                    //Logger.LogInfo("[1] FOV: " + ScopeFOV);
                    lastFOV2 = ScopeFOV;
                }
                
                //nasty workaround for sensitivity while using PIP scopes, WILL break when FOV is set to 50
                if (35 < FPSCameraFOV && FPSCameraFOV < UniformAimConfig.configFOV.Value) { currentFOV = FPSCameraFOV; }
                if (Camera.allCamerasCount >= 2)
                {
                    if (FPSCameraFOV == 35) { currentFOV = ScopeFOV; }
                    if (FPSCameraFOV == UniformAimConfig.configFOV.Value - 15) { currentFOV = FPSCameraFOV; }
                }

                adjustedSensitivity = CalculateSensitivity(currentFOV, UniformAimConfig.configFOV.Value) * 0.25f; //(float)(UniformAimConfig.configSens.Value/100)
            
        }
    }
}