
using JetBrains.Annotations;
using System;

namespace UdonSharp
{
    // At the moment Udon syncing is in a very early state.
    // This is very liable to be changed with changes to Udon syncing in the future.
    [PublicAPI]
    public enum UdonSyncMode
    {
        /// <summary>
        /// Not synced, this is the same as not adding the UdonSynced attribute
        /// </summary>
        // [Obsolete("This is getting removed, do not use a UdonSynced attribute with NotSynced")]
        NotSynced,
        /// <summary>
        /// Synced with no interpolation, this is the same as just using `[UdonSynced]`
        /// </summary>
        None,
        /// <summary>
        /// Lerped sync
        /// </summary>
        Linear,
        /// <summary>
        /// Smoothed sync
        /// </summary>
        Smooth,
    }

    [PublicAPI]
    [AttributeUsage(AttributeTargets.Field, AllowMultiple = false, Inherited = false)]
    public class UdonSyncedAttribute : Attribute
    {
        public UdonSyncMode NetworkSyncType { get; }

        public UdonSyncedAttribute(UdonSyncMode networkSyncTypeIn = UdonSyncMode.None)
        {
            NetworkSyncType = networkSyncTypeIn;
        }
    }
    
    /// <summary>
    /// Used to enforce consistent sync modes per behaviour since Udon Behaviours are usually authored with a specific type of sync in mind
    ///   and it's tedious to set and make sure the sync type is correct on each behaviour.
    /// This also allows U# to verify that you're using types and variable tweening modes that are supported for the given sync mode
    /// </summary>
    [PublicAPI]
    public enum BehaviourSyncMode
    {
        /// <summary>
        /// Nothing is enforced and the behaviours can be set to either sync type by the user. This is the default when no BehaviourSyncTypeAttribute is specified on a behaviour
        /// </summary>
        Any,
        /// <summary>
        /// Enforces no synced variables on the behaviour and hides the selection dropdown in the UI for the sync mode. Nothing is synced and SendCustomNetworkEvent will not work on the behaviour
        /// </summary>
        None,
        /// <summary>
        /// Enforces no synced variables on the behaviour and hides the selection dropdown in the UI for the sync mode, SendCustomNetworkEvent() will still work on this behaviour
        /// </summary>
        NoVariableSync,
        /// <summary>
        /// Enforces continuous sync mode on the behaviour
        /// </summary>
        Continuous,
        /// <summary>
        /// Enforces manual sync mode on the behaviour
        /// </summary>
        Manual,
    }

    [PublicAPI]
    [AttributeUsage(AttributeTargets.Class)]
    public class UdonBehaviourSyncModeAttribute : Attribute
    {
        public BehaviourSyncMode behaviourSyncMode = BehaviourSyncMode.Any;

        public UdonBehaviourSyncModeAttribute(BehaviourSyncMode behaviourSyncMode)
        {
            this.behaviourSyncMode = behaviourSyncMode;
        }
    }

    /// <summary>
    /// Marks a method that can be called recursively in U#. 
    /// This should be used on the methods that are being called recursively, you do not need to mark methods that are calling recursive methods with this.
    /// This attribute has a performance overhead which makes the marked method perform slower and usually generate more garbage. So use it only on methods that **need** to be called recursively.
    /// </summary>
    [PublicAPI]
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
    public class RecursiveMethodAttribute : Attribute
    {
    }

    /// <summary>
    /// Calls the target property's setter when the marked field is modified by network sync or SetProgramVariable().
    /// Fields marked with this will instead have the target property's setter called. The setter is expected to set the field if you want the field to change.
    /// </summary>
    [PublicAPI]
    [AttributeUsage(AttributeTargets.Field, AllowMultiple = false)]
    public class FieldChangeCallbackAttribute : Attribute
    {
        public string CallbackPropertyName { get; private set; }

        private FieldChangeCallbackAttribute() { }

        public FieldChangeCallbackAttribute(string targetPropertyName)
        {
            CallbackPropertyName = targetPropertyName;
        }
    }

    /// <summary>
    /// Marks a field to only run its initializer at compile time. This may be used on particularly expensive initializers, or initializers that run code which is not currently valid in Udon.
    /// </summary>
    [PublicAPI]
    [AttributeUsage(AttributeTargets.Field)]
    [Obsolete("This attribute currently does nothing")]
    public class CompileInitAttribute : Attribute
    {}
}

