HoHCI-BikeSteering/Assets/Scripts/Logging/Events/RouteEventLogger.cs

using System;
using System.Collections.Generic;
using System.Linq;
using JetBrains.Annotations;
using Logging.Base;
using Logging.Data;
using Routes;
using UnityEngine;

namespace Logging.Events
{
    public enum RouteEvent
    {
        None,
        Left,
        Right,
        Straight
    }

    public readonly struct RouteEventData : ISerializable
    {
        private readonly long timestamp;
        private readonly RouteEvent eventRoute;

        public RouteEventData(long timestamp, RouteEvent eventRoute)
        {
            this.timestamp = timestamp;
            this.eventRoute = eventRoute;
        }

        public KeyValuePair<long, string[]> Serialize() => new KeyValuePair<long, string[]>(timestamp, new[]
        {
            eventRoute.ToString()
        });
    }

    public class RouteEventLogger : SensorDataLogger<RouteEventData>
    {
        public override string Key => "route_events";
        public GameObject routes;

        [CanBeNull] private Route activeRoute;
        private bool activeRouteAvailable;
        private IEnumerable<Turn> turns;

        public override void Start()
        {
            base.Start();
            activeRoute = routes.GetComponentsInChildren<Route>().FirstOrDefault(r => r.isActiveAndEnabled);
            if (activeRoute == null) return;

            activeRouteAvailable = true;
            turns = activeRoute.items.Select(item => item.turn);
        }

        private void Update()
        {
            var e = activeRouteAvailable ? EventForActiveRoute() : RouteEvent.None;
            /*if (e != RouteEvent.None)
            {
                print($"RouteEvent: {e.ToString()}");
            }*/

            Log(new RouteEventData(Helpers.RoundToLong(Time.time * 1000f), e));
        }

        private RouteEvent EventForActiveRoute()
        {
            var currentTurn = turns.FirstOrDefault(t => t.BikeTriggerState == TriggerState.Inside);
            if (currentTurn == null)
            {
                return RouteEvent.None;
            }

            switch (currentTurn.comingFrom)
            {
                case RoadDirection.West:
                    switch (currentTurn.goingTo)
                    {
                        case RoadDirection.North:
                            return RouteEvent.Left;
                        case RoadDirection.East:
                            return RouteEvent.Straight;
                        case RoadDirection.South:
                            return RouteEvent.Right;
                        default:
                            return RouteEvent.None;
                    }
                case RoadDirection.North:
                    switch (currentTurn.goingTo)
                    {
                        case RoadDirection.East:
                            return RouteEvent.Left;
                        case RoadDirection.South:
                            return RouteEvent.Straight;
                        case RoadDirection.West:
                            return RouteEvent.Right;
                        default:
                            return RouteEvent.None;
                    }
                case RoadDirection.East:
                    switch (currentTurn.goingTo)
                    {
                        case RoadDirection.North:
                            return RouteEvent.Right;
                        case RoadDirection.South:
                            return RouteEvent.Left;
                        case RoadDirection.West:
                            return RouteEvent.Straight;
                        default:
                            return RouteEvent.None;
                    }
                case RoadDirection.South:
                    switch (currentTurn.goingTo)
                    {
                        case RoadDirection.North:
                            return RouteEvent.Straight;
                        case RoadDirection.East:
                            return RouteEvent.Right;
                        case RoadDirection.West:
                            return RouteEvent.Left;
                        default:
                            return RouteEvent.None;
                    }
                default:
                    return RouteEvent.None;
            }
        }


        public override IEnumerable<RouteEventData> ReadLog(IEnumerable<IEnumerable<string>> lines)
        {
            throw new NotImplementedException();
        }
    }
}