using System;
using System.Collections.Generic;
using System.Linq;
using Code.Example.Race.Racer;
using Code.Example.Race.Track;
using Code.Infrastructure.EventBus;
using Code.Infrastructure.Loadings;
using UnityEngine;

namespace Code.Example.Race
{
    public class RaceGame : IRacerLoadedHandle, IDisposable
    {
        private RaceScores _scores;
        
        private IRacerFactory _racerFactory;
        private RaceTrackData _raceTrackData;
        private EventBus _eventBus;

        public RaceGame(EventBus eventBus, IRacerFactory racerFactory, RaceTrackData raceTrackData, RaceScores scores)
        {
            _eventBus = eventBus;
            _racerFactory = racerFactory;
            _raceTrackData = raceTrackData;
            _eventBus.Subscribe(this);

            _scores = scores;
            
            RandomizeRacers(raceTrackData.trackData.RacerPoints.Count);
        }

        private float _timeStart;
        public float RaceTime => Time.time - _timeStart;

        public void StartRacers()
        {
            _timeStart = Time.time;
            foreach (var racer in PlacedRacers)
            {
                racer.StartRacer();
            }
        }

        // DEBUG
        private List<RacerType> _randomizedTypes = new();

        private void RandomizeRacers(int count)
        {
            _raceGameLoading = new Loading(count, RacersLoadCompleted);

            _randomizedTypes.Add(RacerType.Player);

            for (var i = 0; i < count - 1; i++)
                _randomizedTypes.Add((RacerType)UnityEngine.Random.Range(1, 3));

            foreach (var type in _randomizedTypes) _racerFactory.LoadRacer(type);
        }

        private void RacersLoadCompleted() =>
            _eventBus.RaiseEvent<IRaceGameHandle>(x => x.RaceGameReady());

        public List<Racer.Racer> PlacedRacers { get; } = new();

        public void PlaceRacers()
        {
            for (var i = 0; i < _raceTrackData.trackData.RacerPoints.Count; i++)
            {
                PlacedRacers.Add(UnityEngine.Object.Instantiate(
                    _racerPrefabs[_randomizedTypes[i]],
                    _raceTrackData.trackData.RacerPoints[i].transform).GetComponent<Racer.Racer>());
                PlacedRacers[^1].SetData(_racerPrefabs[_randomizedTypes[i]].Data);
                PlacedRacers[^1].Id = i;
                _scores.SubscribeRacer(PlacedRacers[^1]);
            }

            foreach (var racer in PlacedRacers)
            {
                racer.Initialize(_raceTrackData.trackData.Checkpoints.Select(x=> x.transform).ToList());
            }
        }

        private Dictionary<RacerType, Racer.Racer> _racerPrefabs = new();
        private Loading _raceGameLoading;

        public void RacerLoaded(RacerType type, Racer.Racer racer)
        {
            if (racer)
                _racerPrefabs.Add(type, racer);
            
            _raceGameLoading.DoProgress();
        }
  

        public void Dispose()
        {
            foreach (var racer in PlacedRacers) _scores.UnsubscribeRacer(racer);
            
            _eventBus.Unsubscribe(this);
            _racerPrefabs.Clear();
        }
    }

    public interface IRaceGameHandle : IGlobalSubscriber
    {
        void RaceGameReady();
        void RaceGameEnded(RaceScores scores);
    }
}