Unity project: I'm having error regarding a code

Question

I'm currently working in a Unity project where I need to create an AR project. Also I need to give guidance to the user. In my case, the working of multimeter is working.. but when I try to implement it is only showing the fist step of each mode.. In TipMode currentMeasurement, first show TipcurrentMeasurementRedAdapter and highlight Red Adapter and blue port. once red adapter is connected to blue port, show TipcurrentMeasurementBlackAdapter, and highlight black Adapter and black port. once black adapter is connected to black port, show TipcurrentMeasurementSelectionKnob and highlight selection knob. if in Tipmode current measurement, if red adapter got connected to red port, highlight it the connection in red colour and show ErrorRedAdapterConnection text from localisation table.

using System;
using System.Collections.Generic;
using UnityEngine;
using MixedReality.Toolkit.UX;
using UnityEngine.Localization.Settings;
using TMPro;
using UnityEngine.Localization;
using UnityEngine.Localization.Components;

namespace Assets.Multimeter.Scripts
{
public class MultimeterOrder : MonoBehaviour
{
    public Transform RedAdapterTransform;
    public Transform BlackAdapterTransform;
    public GameObject RedPort;
    public GameObject BlackPort;
    public GameObject BluePort;
    public GameObject SelectionKnob;
    public GameObject TextInstructionGameObject;
    public LocalizeStringEvent TextInstructionLocalizeStringEvent;

    private readonly List<Tuple<Renderer, Color>> rend = new();
    private enum TipMode { None, ResistanceMeasurement, CurrentMeasurement, VoltageMeasurement }
    private TipMode tipModeType = TipMode.None;
    private bool greenBlinkingStartable = true;
    private float greenBlinkingStartTimer;
    private const float greenBlinkingDuration = 1.5f;
    private const float greenBlinkingSpeed = 3f, redBlinkingSpeed = 1f, normalBlinkingSpeed = 2f;
    private DialogPool dialogPool;
    private IDialog dialog;
    private enum Error { NoError, ErrorRedAdapterConnection }
    private Error errorType = Error.NoError;
    private Shader shaderForBlinking, defaultShader;
    private bool colorIsRed;
    private bool colorIsGreen;
    private enum TextInstruction { NoInstruction, MeasureResistanceInstruction, MeasureCurrentInstruction, MeasureVoltageInstruction }
    private TextInstruction currentTextInstruction = TextInstruction.NoInstruction;
    private TipMode currentTextInstructionTipModeType = TipMode.None;
    private ProbeConnection probeConnection;

    private enum ResistanceMeasurementSteps { None, RedAdapter, BlackAdapter, SelectionKnob }
    private ResistanceMeasurementSteps resistanceMeasurementStep = ResistanceMeasurementSteps.None;

    private enum VoltageMeasurementSteps { None, RedAdapter, BlackAdapter, SelectionKnob }
    private VoltageMeasurementSteps voltageMeasurementStep = VoltageMeasurementSteps.None;

    private enum CurrentMeasurementSteps { None, RedAdapter, BlackAdapter, SelectionKnob }
    private CurrentMeasurementSteps currentMeasurementStep = CurrentMeasurementSteps.None;

    private void Start()
    {
        foreach (Renderer rendChild in this.GetComponentsInChildren<Renderer>())
        {
            this.rend.Add(new Tuple<Renderer, Color>(rendChild, rendChild.material.color));
        }

        this.dialogPool = this.GetComponent<DialogPool>();
        this.shaderForBlinking = Shader.Find("Standard");
        this.defaultShader = Shader.Find("glTF/PbrMetallicRoughness");

        probeConnection = FindObjectOfType<ProbeConnection>();
    }

    private void Update()
    {
        ResetDialogs();

        switch (tipModeType)
        {
            case TipMode.ResistanceMeasurement:
                HandleResistanceMeasurement();
                break;
            case TipMode.VoltageMeasurement:
                HandleVoltageMeasurement();
                break;
            case TipMode.CurrentMeasurement:
                HandleCurrentMeasurement();
                break;
            default:
                HandleDefault();
                break;
        }
    }

    private void HandleResistanceMeasurement()
    {
        switch (resistanceMeasurementStep)
        {
            case ResistanceMeasurementSteps.RedAdapter:
                HighlightPortAndAdapter(RedPort, RedAdapterTransform);
                if (IsAdapterConnected(RedAdapterTransform))
                {
                    ActivateTextInstruction("TipResistanceMeasurementBlackAdapter");
                    resistanceMeasurementStep = ResistanceMeasurementSteps.BlackAdapter;
                }
                break;

            case ResistanceMeasurementSteps.BlackAdapter:
                HighlightPortAndCheckConnection(BlackPort, BlackAdapterTransform, () =>
                {
                    ActivateTextInstruction("TipResistanceMeasurementSelectionKnob");
                    resistanceMeasurementStep = ResistanceMeasurementSteps.SelectionKnob;
                });
                break;

            case ResistanceMeasurementSteps.SelectionKnob:
                HighlightSelectionKnob();
                break;
        }
    }

    private void HandleVoltageMeasurement()
    {
        switch (voltageMeasurementStep)
        {
            case VoltageMeasurementSteps.RedAdapter:
                HighlightPortAndAdapter(RedPort, RedAdapterTransform);
                if (IsAdapterConnected(RedAdapterTransform))
                {
                    ActivateTextInstruction("TipVoltageMeasurementBlackAdapter");
                    voltageMeasurementStep = VoltageMeasurementSteps.BlackAdapter;
                }
                break;

            case VoltageMeasurementSteps.BlackAdapter:
                HighlightPortAndCheckConnection(BlackPort, BlackAdapterTransform, () =>
                {
                    ActivateTextInstruction("TipVoltageMeasurementSelectionKnob");
                    voltageMeasurementStep = VoltageMeasurementSteps.SelectionKnob;
                });
                break;

            case VoltageMeasurementSteps.SelectionKnob:
                HighlightSelectionKnob();
                break;
        }
    }

    private void HandleCurrentMeasurement()
    {
        switch (currentMeasurementStep)
        {
            case CurrentMeasurementSteps.RedAdapter:
                HighlightPortAndAdapter(BluePort, RedAdapterTransform);
                if (IsAdapterConnected(RedAdapterTransform))
                {
                    ActivateTextInstruction("TipCurrentMeasurementBlackAdapter");
                    currentMeasurementStep = CurrentMeasurementSteps.BlackAdapter;
                }
                break;

            case CurrentMeasurementSteps.BlackAdapter:
                HighlightPortAndCheckConnection(BlackPort, BlackAdapterTransform, () =>
                {
                    ActivateTextInstruction("TipCurrentMeasurementSelectionKnob");
                    currentMeasurementStep = CurrentMeasurementSteps.SelectionKnob;
                });
                break;

            case CurrentMeasurementSteps.SelectionKnob:
                HighlightSelectionKnob();
                break;
        }
    }


    private void HighlightPortAndCheckConnection(GameObject port, Transform adapterTransform, Action onConnected)
    {
        if (tipModeType == TipMode.CurrentMeasurement && port == BluePort)
        {
            ColorBlinkBluePort(port.GetComponent<Renderer>(), adapterTransform.GetComponent<Renderer>());
        }
        else
        {
            ColorBlink(port.GetComponent<Renderer>());
            ColorBlink(adapterTransform.GetComponent<Renderer>());
        }

        if (IsAdapterConnected(adapterTransform))
        {
            if (tipModeType == TipMode.ResistanceMeasurement && adapterTransform == RedAdapterTransform && port == BluePort ||
                tipModeType == TipMode.VoltageMeasurement && adapterTransform == RedAdapterTransform && port == BluePort ||
                tipModeType == TipMode.CurrentMeasurement && adapterTransform == RedAdapterTransform && port == RedPort)
            {
                HighlightError(port);
            }
            else
            {
                onConnected?.Invoke();
            }
        }
    }

    private void HighlightPortAndAdapter(GameObject port, Transform adapterTransform)
    {
        if (tipModeType == TipMode.CurrentMeasurement && port == BluePort)
        {
            ColorBlinkBluePort(port.GetComponent<Renderer>(), adapterTransform.GetComponent<Renderer>());
        }
        else
        {
            ColorBlink(port.GetComponent<Renderer>());
            ColorBlink(adapterTransform.GetComponent<Renderer>());
        }
    }

    private void ColorBlinkBluePort(Renderer portRenderer, Renderer adapterRenderer)
    {
        if (portRenderer != null && adapterRenderer != null)
        {
            // Blink the blue port
            portRenderer.material.color = Color.Lerp(Color.blue, Color.white, Mathf.PingPong(Time.time * normalBlinkingSpeed, 1));
            // Blink the red adapter
            adapterRenderer.material.color = Color.Lerp(Color.red, Color.white, Mathf.PingPong(Time.time * normalBlinkingSpeed, 1));
        }
    }

    private bool IsAdapterConnected(Transform adapterTransform)
    {
        return probeConnection.IsAdapterConnected(adapterTransform);
    }

    private void HighlightSelectionKnob()
    {
        if (SelectionKnob.activeInHierarchy)
        {
            GreenColorBlink(tipModeType);
        }
    }

    private void ColorReset()
    {
        if (colorIsRed)
        {
            foreach (var rendComponent in rend)
            {
                rendComponent.Item1.material.color = rendComponent.Item2;
            }

            colorIsRed = false;
            errorType = Error.NoError;
            CloseDialog();
        }
    }

    private void ColorBlink(Renderer renderer)
    {
        if (renderer != null)
        {
            renderer.material.color = Color.Lerp(Color.red, Color.white, Mathf.PingPong(Time.time * normalBlinkingSpeed, 1));
        }
    }

    private void GreenColorBlink(TipMode mode)
    {
        TextInstructionGameObject.SetActive(false);
        currentTextInstruction = TextInstruction.NoInstruction;

        if (greenBlinkingStartable)
        {
            greenBlinkingStartTimer = Time.time;
            greenBlinkingStartable = false;
        }

        if (Time.time - greenBlinkingStartTimer < greenBlinkingDuration)
        {
            foreach (var rendComponent in rend)
            {
                if (rendComponent.Item1.material.shader != defaultShader)
                {
                    rendComponent.Item1.material.shader = defaultShader;
                }

                rendComponent.Item1.material.color = Color.Lerp(rendComponent.Item2, Color.green, Mathf.PingPong(Time.time * greenBlinkingSpeed, 1));

                if (!colorIsGreen)
                {
                    colorIsGreen = true;
                }
            }
        }
        else if (colorIsGreen)
        {
            foreach (var rendComponent in rend)
            {
                rendComponent.Item1.material.color = rendComponent.Item2;
            }

            colorIsGreen = false;
        }
    }

    private void HighlightError(GameObject port)
    {
        ActivateTextInstruction("ErrorRedAdapterConnection");
        ColorBlink(port.GetComponent<Renderer>());
        errorType = Error.ErrorRedAdapterConnection;
    }

    private void RedColorBlink()
    {
        TextInstructionGameObject.SetActive(false);
        currentTextInstruction = TextInstruction.NoInstruction;

        foreach (var rendComponent in rend)
        {
            if (rendComponent.Item1.material.shader != defaultShader)
            {
                rendComponent.Item1.material.shader = defaultShader;
            }

            colorIsRed = true;
            rendComponent.Item1.material.color = Color.Lerp(rendComponent.Item2, Color.red, Mathf.PingPong(Time.time * redBlinkingSpeed, 1));
        }
    }

    private void OnDestroy()
    {
        CloseDialog();
    }

    private void ResetDialogs()
    {
        if (dialog != null)
        {
            dialog.Dismiss();
            dialog = null;
        }
    }

    private void ShowDialog(string dialogKey)
    {
        CloseDialog();
    }

    private void CloseDialog()
    {
        if (dialog != null)
        {
            dialog.Dismiss();
            dialog = null;
        }
    }

    public void SetResistanceMeasurementTips(bool pressed)
    {
        if (pressed)
        {
            Debug.Log("Resistance measurement button pressed."); // Add this debug log
            tipModeType = TipMode.ResistanceMeasurement;
            ActivateTextInstruction("TipResistanceMeasurementRedAdapter");
            resistanceMeasurementStep = ResistanceMeasurementSteps.RedAdapter;
        }
        else
        {
            Debug.Log("Resistance measurement button released."); // Add this debug log
            tipModeType = TipMode.None;
            TextInstructionGameObject.SetActive(false);
            currentTextInstruction = TextInstruction.NoInstruction;
            resistanceMeasurementStep = ResistanceMeasurementSteps.None;
        }
    }

    public void SetCurrentMeasurementTips(bool pressed)
    {
        if (pressed)
        {
            Debug.Log("Current measurement button pressed."); // Add this debug log
            tipModeType = TipMode.CurrentMeasurement;
            ActivateTextInstruction("TipCurrentMeasurementRedAdapter");
            currentMeasurementStep = CurrentMeasurementSteps.RedAdapter;
        }
        else
        {
            Debug.Log("Current measurement button released."); // Add this debug log
            tipModeType = TipMode.None;
            TextInstructionGameObject.SetActive(false);
            currentTextInstruction = TextInstruction.NoInstruction;
            currentMeasurementStep = CurrentMeasurementSteps.None;
        }
    }

    public void SetVoltageMeasurementTips(bool pressed)
    {
        if (pressed)
        {
            Debug.Log("Voltage measurement button pressed."); // Add this debug log
            tipModeType = TipMode.VoltageMeasurement;
            ActivateTextInstruction("TipVoltageMeasurementRedAdapter");
            voltageMeasurementStep = VoltageMeasurementSteps.RedAdapter;
        }
        else
        {
            Debug.Log("Voltage measurement button released."); // Add this debug log
            tipModeType = TipMode.None;
            TextInstructionGameObject.SetActive(false);
            currentTextInstruction = TextInstruction.NoInstruction;
            voltageMeasurementStep = VoltageMeasurementSteps.None;
        }
    }

    private void ActivateTextInstruction(string instructionKey)
    {
        TextInstructionGameObject.SetActive(true);
        TextInstructionLocalizeStringEvent.StringReference = new LocalizedString("MultimeterTable", instructionKey);
        TextInstructionLocalizeStringEvent.OnUpdateString.Invoke(TextInstructionLocalizeStringEvent.StringReference.GetLocalizedString());
    }

      private void HandleErrors()
      {
        switch (errorType)
        {
            case Error.NoError:
                errorType = Error.ErrorRedAdapterConnection;
                ShowDialog("ErrorRedAdapterConnection");
                break;
            case Error.ErrorRedAdapterConnection:
                RedColorBlink();
                break;
        }
         }

    private void HandleDefault()
    {
        ColorReset();
      }
   }
}