Pickup

using UnityEngine;

public class Pickup : MonoBehaviour
{
    private const float MaxDistance = 100f;
    [SerializeField] private float maxScale = 10f;
    [SerializeField] private LayerMask pickable;
    [SerializeField] private LayerMask pickableScalable;
    [SerializeField] private Transform origin;

    private Transform target;
    private Rigidbody targetRigidbody;
    private Vector3 startScale;
    private float startDistance;
    private Vector3 targetScale;
    private Vector3 bounds;
    private float circumradius;

    private bool IsScaleTooSmall => (targetScale * maxScale).x < startScale.x;
    private bool IsScaleTooBig => (targetScale / maxScale).x > startScale.x;

    private void Update()
    {
        HandleInput();
        ResizeObject();
    }

    private void HandleInput()
    {
        if (Input.GetMouseButtonDown(0))
        {
            if (target == null)
            {
                if (Physics.Raycast(origin.transform.position, origin.transform.forward, out var hit, MaxDistance, pickable))
                {
                    target = hit.transform;
                    targetRigidbody = hit.rigidbody;
                    targetRigidbody.isKinematic = true;
                    bounds = hit.collider.bounds.size;
                    circumradius = Mathf.Max(bounds.x, bounds.y, bounds.z);

                    startDistance = Vector3.Distance(origin.transform.position, target.position);
                    startScale = target.transform.localScale;
                    targetScale = target.transform.localScale;
                }
            }
            else
            {
                CancelDrag();
            }
        }
    }

    private void ResizeObject()
    {
        if (target == null)
        {
            return;
        }

        if (Physics.Raycast(origin.transform.position, origin.transform.forward, out var hit, MaxDistance, ~pickable))
        {
            target.position = hit.point - targetScale.x * origin.transform.forward;

            if (Physics.SphereCast(origin.transform.position, circumradius, origin.transform.forward, out hit, MaxDistance, ~pickable))
            {
                target.position = hit.point + hit.normal * circumradius;
            }

            float currentDistance = Vector3.Distance(origin.transform.position, target.position);
            float scale = currentDistance / startDistance;
            targetScale.x = targetScale.y = targetScale.z = scale;

            // TODO: move MIN/MAX scale check to drag cancel
            if (IsScaleTooBig)
            {
                target.localScale = Vector3.one;
                CancelDrag();
            }
            else
            {
                if (IsScaleTooSmall)
                {
                    target.localScale = Vector3.one;
                    CancelDrag();
                }
                else
                {
                    target.localScale = targetScale * startScale.x;
                }
            }
        }
    }

    private void CancelDrag()
    {
        targetRigidbody.isKinematic = false;
        target = null;
    }
}