using ContractConfigurator.Parameters;
using Contracts;
using UnityEngine;

namespace ContractConfigurator.RP0
{
    public class AvionicsCheckFactory : ParameterFactory
    {
        protected bool continuousControlRequired;

        public override bool Load(ConfigNode configNode)
        {
            bool valid = base.Load(configNode);

            valid &= ConfigNodeUtil.ParseValue<bool>(configNode, "continuousControlRequired", x => continuousControlRequired = x, this);

            return valid;
        }

        public override ContractParameter Generate(Contract contract)
        {
            return new AvionicsCheckParameter(title, continuousControlRequired);
        }
    }
    public class AvionicsCheckParameter : VesselParameter
    {
        protected bool vesselHasControl = true;
        protected bool controlHasLapsed = false;
        protected bool continuousControlRequired = false;

        private float lastUpdate = -5.0f;
        private const float UPDATE_FREQUENCY = 1f;

        public AvionicsCheckParameter() : base(null) { }

        public AvionicsCheckParameter(string title, bool continuousControlRequired) : base(title)
        {
            this.continuousControlRequired = continuousControlRequired;
            this.title = GetParameterTitle();
        }

        protected override void OnParameterSave(ConfigNode node)
        {
            base.OnParameterSave(node);
        }

        protected override void OnParameterLoad(ConfigNode node)
        {
            base.OnParameterLoad(node);
        }

        private void OnLockModifiedHandler(GameEvents.FromToAction<ControlTypes, ControlTypes> data)
        {
            CheckVessel(FlightGlobals.ActiveVessel);
        }

        protected override void OnRegister()
        {
            base.OnRegister();
            GameEvents.onInputLocksModified.Add(OnLockModifiedHandler);
        }

        protected override void OnUnregister()
        {
            base.OnUnregister();
            GameEvents.onInputLocksModified.Remove(OnLockModifiedHandler);
        }

        protected override string GetParameterTitle()
        {
            return continuousControlRequired ? $"Maintain sufficient avionics (do not lose control)" : $"Have sufficient avionics for control";
        }

        protected override void OnUpdate()
        {
            Vessel v = FlightGlobals.ActiveVessel;

            if (v == null) return;

            base.OnUpdate();


            if (Time.fixedTime - lastUpdate > UPDATE_FREQUENCY)
            {
                lastUpdate = Time.fixedTime;

                bool controlIsLocked = InputLockManager.GetControlLock("RP0ControlLocker") != 0;

                controlHasLapsed = controlIsLocked || controlHasLapsed;

                vesselHasControl = continuousControlRequired ? !controlHasLapsed && !controlIsLocked : !controlIsLocked;

                GetTitle();
            }
        }
        protected override bool VesselMeetsCondition(Vessel vessel)
        {
            OnUpdate();

            Debug.Log(vesselHasControl ? "Avionics check: control locked" : "Avionics check: no control locks");

            return vesselHasControl;
        }
    }
}