using System;
using UnityEngine;
using UnityEngine.Events;
using OctoCore.Save.Data;

namespace OctoCore.Components
{
public class OctoSaveEvent : MonoBehaviour
{
    [SerializeField] private OctoData data;

    [SerializeField] private bool invertValue;

    [SerializeField] private UnityEvent<bool> onInitBool;
    [SerializeField] private UnityEvent<int> onInitInt;
    [SerializeField] private UnityEvent<float> onInitFloat;
    [SerializeField] private UnityEvent<string> onInitString;
    [SerializeField] private UnityEvent<Vector4> onInitVector;

    [SerializeField] private UnityEvent<bool> onChangeBool;
    [SerializeField] private UnityEvent<int> onChangeInt;
    [SerializeField] private UnityEvent<float> onChangeFloat;
    [SerializeField] private UnityEvent<string> onChangeString;
    [SerializeField] private UnityEvent<Vector4> onChangeVector;

    private Action<bool> onValueChangedBool;
    private Action<int> onValueChangedInt;
    private Action<float> onValueChangedFloat;
    private Action<string> onValueChangedString;
    private Action<Vector4> onValueChangedVector;

    void OnEnable()
    {
        if (!OctoCore.Instance) return;

        if (data)
        {
            switch (data)
            {
                case global::OctoCore.Save.Data.OctoDataBool:
                    OnValueInit(OctoCore.Instance.Save.GetBool(data.Id));
                    OctoCore.Instance.Save.Subscribe(data, onValueChangedBool = OnValueChanged);
                    break;

                case global::OctoCore.Save.Data.OctoDataInt:
                    OnValueInit(OctoCore.Instance.Save.GetInt(data.Id));
                    OctoCore.Instance.Save.Subscribe(data, onValueChangedInt = OnValueChanged);
                    break;

                case global::OctoCore.Save.Data.OctoDataFloat:
                    OnValueInit(OctoCore.Instance.Save.GetFloat(data.Id));
                    OctoCore.Instance.Save.Subscribe(data, onValueChangedFloat = OnValueChanged);
                    break;

                case global::OctoCore.Save.Data.OctoDataString:
                    OnValueInit(OctoCore.Instance.Save.GetString(data.Id));
                    OctoCore.Instance.Save.Subscribe(data, onValueChangedString = OnValueChanged);
                    break;

                case global::OctoCore.Save.Data.OctoDataVector:
                    OnValueInit(OctoCore.Instance.Save.GetVector(data.Id));
                    OctoCore.Instance.Save.Subscribe(data, onValueChangedVector = OnValueChanged);
                    break;

                default:
                    if (OctoCore.Instance.Development.Log)
                        Debug.Log($"Unsupported data: {data.Id}");
                    break;
            }

            if (OctoCore.Instance.Development.Log && data)
                Debug.Log($"{name} subscribed on: {data.Id}");
        }
        else if (OctoCore.Instance.Development.Log && data)
        {
            Debug.Log($"Data is null");
        }
    }

    void OnDisable()
    {
        if (!OctoCore.Instance) return;

        if (data)
        {
            if (onValueChangedBool != null)
            {
                OctoCore.Instance.Save.Unsubscribe(data, onValueChangedBool);
                onValueChangedBool = null;
            }

            if (onValueChangedInt != null)
            {
                OctoCore.Instance.Save.Unsubscribe(data, onValueChangedInt);
                onValueChangedInt = null;
            }

            if (onValueChangedFloat != null)
            {
                OctoCore.Instance.Save.Unsubscribe(data, onValueChangedFloat);
                onValueChangedFloat = null;
            }

            if (onValueChangedString != null)
            {
                OctoCore.Instance.Save.Unsubscribe(data, onValueChangedString);
                onValueChangedString = null;
            }

            if (onValueChangedVector != null)
            {
                OctoCore.Instance.Save.Unsubscribe(data, onValueChangedVector);
                onValueChangedVector = null;
            }

            if (OctoCore.Instance.Development.Log && data)
                Debug.Log($"{name} unsubscribed on: {data.Id}");
        }
    }

    void OnValueInit()
    {
        if (OctoCore.Instance.Development.Log && data)
            Debug.Log($"Value initialized on: {data.Id}");
    }

    void OnValueInit(bool value)
    {
        onInitBool?.Invoke(invertValue ? !value : value);
        OnValueInit();
    }

    void OnValueInit(int value)
    {
        onInitInt?.Invoke(value);
        OnValueChanged();
    }

    void OnValueInit(float value)
    {
        onInitFloat?.Invoke(value);
        OnValueChanged();
    }

    void OnValueInit(string value)
    {
        onInitString?.Invoke(value);
        OnValueChanged();
    }

    void OnValueInit(Vector4 value)
    {
        onInitVector?.Invoke(value);
        OnValueInit();
    }

    void OnValueChanged()
    {
        if (OctoCore.Instance.Development.Log && data)
            Debug.Log($"Value changed on: {data.Id}");
    }

    void OnValueChanged(bool value)
    {
        onChangeBool?.Invoke(invertValue ? !value : value);
        OnValueChanged();
    }

    void OnValueChanged(int value)
    {
        onChangeInt?.Invoke(value);
        OnValueChanged();
    }

    void OnValueChanged(float value)
    {
        onChangeFloat?.Invoke(value);
        OnValueChanged();
    }

    void OnValueChanged(string value)
    {
        onChangeString?.Invoke(value);
        OnValueChanged();
    }

    void OnValueChanged(Vector4 value)
    {
        onChangeVector?.Invoke(value);
        OnValueChanged();
    }
}

}