using System;
using System.Linq;
using UnityEngine;

// This is a VAMDeluxe plugin (see dollmaster)
// Just renamed it to avoid potential namespaces conflicts
// And slightly modified it to avoid triggers with own Autocolliders like the abdomen

namespace VAMMoan2TeaserPlugin
{

    public class TriggerEventArgs : EventArgs
    {
        public Collider collider { get; set; }
        public string evtType { get; set; }
    }

    public class CollideEventArgs : EventArgs
    {
        public Collision collision { get; set; }
        public string evtType { get; set; }
    }

    public class SexTriggerCollide : MonoBehaviour
    {
        TriggerEventArgs lastTriggerEvent;
        CollideEventArgs lastCollideEvent;

        public event EventHandler<TriggerEventArgs> OnTrigger;
        public event EventHandler<CollideEventArgs> OnCollide;

        public float VelocityFilter { get; set; } = 0f;

        void Awake()
        {
            lastTriggerEvent = new TriggerEventArgs
            {
                evtType = "none",
                collider = null
            };

            lastCollideEvent = new CollideEventArgs
            {
                evtType = "none",
                collision = null
            };
        }

        private static bool IsHandOrFoot(string rigidbodyName)
        {
            switch (rigidbodyName)
            {
                case "lThumb1":
                case "lThumb2":
                case "lThumb3":
                case "lIndex1":
                case "lIndex2":
                case "lIndex3":
                case "lMid1":
                case "lMid2":
                case "lMid3":
                case "lRing1":
                case "lRing2":
                case "lRing3":
                case "lPinky1":
                case "lPinky2":
                case "lPinky3":
                case "lCarpal1":
                case "lCarpal2":
                case "lFoot":
                case "lBigToe":
                case "lToe":
                case "lSmallToe1":
                case "lSmallToe2":
                case "lSmallToe3":
                case "lSmallToe4":
                case "rThumb1":
                case "rThumb2":
                case "rThumb3":
                case "rIndex1":
                case "rIndex2":
                case "rIndex3":
                case "rMid1":
                case "rMid2":
                case "rMid3":
                case "rRing1":
                case "rRing2":
                case "rRing3":
                case "rPinky1":
                case "rPinky2":
                case "rPinky3":
                case "rCarpal1":
                case "rCarpal2":
                case "rFoot":
                case "rBigToe":
                case "rToe":
                case "rSmallToe1":
                case "rSmallToe2":
                case "rSmallToe3":
                case "rSmallToe4":
                    return true;
                default:
                    return false;
            }
        }

        private static bool ContactFilter(ContactPoint contact)
        {
            // used for penetration/squishes, seemed to be fine before so we probably don't need to filter the other collider
            switch (contact.thisCollider.attachedRigidbody.name)
            {
                case "Gen1":
                case "Gen2":
                    return true;
            }

            var colliderName = contact.otherCollider.name;
            var rigidbody = contact.otherCollider.attachedRigidbody;
            if (rigidbody == null)
                return false;

            switch (colliderName)
            {
                // VRController collider names should let us skip the atom type lookup.
                case "L_Finger_Index_A":
                case "L_Finger_Index_B":
                case "L_Finger_Index_C":
                case "L_Finger_Middle_A":
                case "L_Finger_Middle_B":
                case "L_Finger_Middle_C":
                case "L_Finger_Pinky_A":
                case "L_Finger_Pinky_B":
                case "L_Finger_Pinky_C":
                case "L_Finger_Ring_A":
                case "L_Finger_Ring_B":
                case "L_Finger_Ring_C":
                case "L_Finger_Thumb_A":
                case "L_Finger_Thumb_B":
                case "L_Finger_Thumb_C":
                case "R_Finger_Index_A":
                case "R_Finger_Index_B":
                case "R_Finger_Index_C":
                case "R_Finger_Middle_A":
                case "R_Finger_Middle_B":
                case "R_Finger_Middle_C":
                case "R_Finger_Pinky_A":
                case "R_Finger_Pinky_B":
                case "R_Finger_Pinky_C":
                case "R_Finger_Ring_A":
                case "R_Finger_Ring_B":
                case "R_Finger_Ring_C":
                case "R_Finger_Thumb_A":
                case "R_Finger_Thumb_B":
                case "R_Finger_Thumb_C":
                    return true;
                // For persons, hand and feet rigidbody names should let us skip the atom type lookup, too.
                case "_Collider":
                    if (IsHandOrFoot(rigidbody.name))
                        return true;
                    break;
            }

            var atomType = rigidbody.GetComponentInParent<Atom>()?.type;
            if (atomType == null)
                return false;

            switch (atomType)
            {
                case "AptBook01":
                case "AptBook02":
                case "CustomUnityAsset":
                case "CyberpunkKeyboard":
                case "CyberpunkLaptop":
                    return true;
                case "Dildo":
                {
                    switch (rigidbody.name)
                    {
                        case "b1":
                        case "b2":
                        case "b3":
                            return true;
                        default:
                            return false;
                    }
                }
                case "Paddle":
                {
                    switch (colliderName)
                    {
                        case "Collider1":
                            return true;
                        default:
                            return false;
                    }
                }
                case "VRController":
                {
                    switch (rigidbody.name)
                    {
                        case "HandPhysical":
                            return true;
                        default:
                            return false;
                    }
                }
                default:
                    return false;
            }
        }


        private void OnTriggerEnter(Collider other)
        {
            DoTriggerEvent("Entered", other);
        }

        private void OnTriggerExit(Collider other)
        {
            DoTriggerEvent("Exited", other);
        }

        private void OnCollisionEnter(Collision collision)
        {
            if (VelocityFilter < collision.relativeVelocity.magnitude && collision.contacts.Any(ContactFilter))
            {
                DoCollisionEvent("CEntered", collision);
            }
        }

        private void OnCollisionExit(Collision collision)
        {
            DoCollisionEvent("CExited", collision);
        }

        // used for pelvic slaps with custom colliders (isTrigger = true)
        private void DoTriggerEvent(string evtType, Collider col)
        {
            if (string.Equals(evtType, lastTriggerEvent.evtType) && col.gameObject == lastTriggerEvent.collider.gameObject)
            {
                return;
            }
            else
            {
                //SuperController.LogMessage( "Collision" + col.gameObject.name );
                // Checking for triggers that are not allowed
                if (col.gameObject.name.Contains("FemaleAutoCollidersabdomen"))
                {
                    return;
                }

                TriggerEventArgs tempEvent = new TriggerEventArgs
                {
                    collider = col,
                    evtType = evtType
                };
                OnTriggerEvent(tempEvent);
                lastTriggerEvent = tempEvent;
            }
        }

        // used for spanks (isTrigger = false)
        private void DoCollisionEvent(string evtType, Collision col)
        {
            if (string.Equals(evtType, lastCollideEvent.evtType) && col.gameObject == lastCollideEvent.collision.gameObject)
            {
                return;
            }
            else
            {
                CollideEventArgs tempEvent = new CollideEventArgs
                {
                    collision = col,
                    evtType = evtType
                };
                OnCollideEvent(tempEvent);
                lastCollideEvent = tempEvent;
            }
        }

        protected virtual void OnTriggerEvent(TriggerEventArgs e)
        {
            EventHandler<TriggerEventArgs> handler = OnTrigger;
            handler?.Invoke(this, e);
        }

        protected virtual void OnCollideEvent(CollideEventArgs e)
        {
            EventHandler<CollideEventArgs> handler = OnCollide;
            handler?.Invoke(this, e);
        }
    }
}