public class GenerateExperiment : MonoBehaviour
{
   [SerializeField] private int m_blocks = 4;
   [SerializeField] private int m_trialsPerBlock = 1;
   [SerializeField] private bool m_shuffleBlocks = true;


       private void OnValidate()
        {
           if (m_blocks < 1)
            {
               this.Warning("You cannot have fewer than 1 Blocks");
                m_blocks = 1;
            }

           if (m_trialsPerBlock < 1)
            {
               this.Warning("You cannot have fewer than 1 Trial per Block");
                m_trialsPerBlock = 1;
            }
        }


       /// <summary>
       ///     This gets called from the OnSessionBegin event on the [UXF_Rig] GameObject.
      ///     Set it in the Inspector of the Session component.
       /// </summary>
      /// <param name="session"></param>
       public void GenerateSession(Session session)
        {
           this.Info($"Creating {m_blocks} blocks with {m_trialsPerBlock} trials each");//

           var startingBlock = 1;
           var endingBlock = m_blocks;

            session.settings.SetValue("sesh", 10); // You can set Settings on the Session-level: automatically logged to `settings.json`.//

           for (var i = startingBlock; i <= endingBlock; i++)
            {
               var block = session.CreateBlock(m_trialsPerBlock);

               var isFirstHalf = i <= (endingBlock + startingBlock) / 2;
               var isEvenBlock = i % 2 == 0;

               // this is how we can set values to the Blocks, bool in this case.
               block.settings.SetValueStored("poke", isFirstHalf); // this auto-logs itself in the `trial_results.json`, because it registers itself to the "Settings To Log" list.

               if (isEvenBlock)
                {
                    block.settings.SetValueStored("async", 300); // setting the async to 300ms
               }
               else
                {
                    block.settings.SetValueStored("async", 0); // turning async off: 0ms
               }
            }

           if (m_shuffleBlocks)
            {
                session.blocks.Shuffle();
               this.Info("Shuffled blocks to new order");
            }

           foreach (var block in session.blocks)
            {
               foreach (var setting in block.GetSettings())
                {
                   this.Verbose($"Our Block {block.number} has {setting.Key}:{setting.Value}");
                }
            }
       }
}

 [RequireComponent(typeof(Session))]
   public class ExperimentRunner : MonoBehaviour
    {
        [SerializeField] [DisableEditing] public bool m_isPokeBlock;
        [SerializeField] [DisableEditing] public bool m_isAsyncBlock;

        [Tooltip("If set to less than 0, stopping a trial will not automatically start a new one.")]
        [SerializeField] [Range(-1, 10f)] private float m_startNextTrialDelay = 2.5f;
       private Session _session;


       private void Awake()
        {
            _session = GetComponent<Session>();
        }


        [Button]
       public void StartTrial()
        {
           if (!_session.IsInitialised())
            {
               return;
            }

           if (_session.IsLastTrial())
            {
               this.Error("Something is wrong. This should not be possible");

               return;
            }

           if (_session.TrialInProgress())
            {
               this.Warning("We are already in an active Trial. Stop that Trial before starting this new one");

               return;
            }

            _session.BeginNextTrial(); // By itself, this always needs to be at the start, since otherwise the "CurrentTrial" / "currentTrialNum" are either not initialized, or at 0 (and UXF is NON-ZERO-INDEXED!). There's now some other methods to check for this, but it's good to know that quite a few UXF operations won't be possible until at least one Trial has started.

           if (_session.CurrentBlock.GetRelativeTrial(1) == _session.CurrentTrial)
            {
                StartedBlock();
            }

           this.Info($"Starting Trial {_session.currentTrialNum}/{_session.LastTrial.number} (total) / {_session.CurrentBlock.GetCurrentTrialInBlock().numberInBlock}/{_session.CurrentBlock.trials.Count} (relative) of Block {_session.currentBlockNum}/{_session.blocks.Count}");
        }


       private void StartedBlock()
        {
           this.Info($"Starting Block {_session.currentBlockNum}");

            m_isPokeBlock = _session.CurrentBlock.settings.GetBool("poke");
            m_isAsyncBlock = _session.CurrentBlock.settings.GetBool("async");

           foreach (var blockSetting in _session.CurrentBlock.GetSettings())
            {
               this.Verbose($"Our Block has {blockSetting.Key}:{blockSetting.Value}");
            }
        }


        [Button]
       public void StopTrial()
        {
           if (!_session.IsInitialised())
            {
               return;
            }

           if (!_session.TrialInProgress())
            {
               this.Warning("There is currently no Trial in progress, so we cannot stop a Trial either. Start a new Trial first.");

               return;
            }

            _session.EndCurrentTrial();

           this.Info($"Stopping Trial {_session.currentTrialNum}/{_session.LastTrial.number} (total) / {_session.CurrentBlock.GetCurrentTrialInBlock().numberInBlock}/{_session.CurrentBlock.trials.Count} (relative) of Block {_session.currentBlockNum}/{_session.blocks.Count}");

           if (_session.CurrentTrial.IsLastTrialInBlock())
            {
                BlockEnded();
            }

           if (_session.CurrentTrial == _session.LastTrial)
            {
                StopSession();

               return;
            }

           if (m_startNextTrialDelay >= 0)
            {
               this.Info($"Auto-starting next Trial in {m_startNextTrialDelay} seconds");

                Invoke(nameof(StartTrial), m_startNextTrialDelay);
            }
        }


       private void BlockEnded()
        {
           this.Info("That was the last Trial in this Block!");
        }


       private void StopSession()
        {
           this.Info("That was the last Trial in our last Block, will be stopping this Session");

            _session.End();

           // This in turn SHOULD invoke the Session to call the OnSessionEnd event, where I can hook a method that gracefully handles fade to black, scene cleanup, etc.
       }


        [Button]
       public void StopSessionEarly()
        {
           if (_session.IsInitialised())
            {
               var currentTrial = _session.CurrentTrial.number;
               var remaining = _session.LastTrial.number - currentTrial;

               this.Warning($"We're not done yet! We're bailing out of {remaining} Trials!");

               for (var i = currentTrial; i < _session.LastTrial.number; i++)
                {
                    _session.endAfterLastTrial = true;
                    _session.EndCurrentTrial();
                    _session.BeginNextTrialSafe();
                    _session.EndCurrentTrial();
                }

                StopSession();
            }
        }
    }