using System;
using System.Collections.Generic;
using Cysharp.Threading.Tasks;

namespace DanieleMarotta.RiversongCodeShowcase
{
    public class BuildingPanelUIController : UIControllerSystem<BuildingPanelUIView>, IDisposable, IUpdatable
    {
        [InjectService]
        private ISignalBus _signalBus;

        [InjectService]
        private IProductCatalog _productCatalog;

        [InjectService]
        private UIState _uiState;

        [InjectService]
        private World _world;

        private BuildingPanelModel _model;

        private List<IBuildingPanelSectionPresenter> _sectionPresenters;

        public BuildingPanelUIController(IServiceLocator serviceLocator) : base(serviceLocator)
        {
        }

        protected override BuildingPanelUIView View => UIRoot.GetView<BuildingPanelUIView>();

        public override async UniTask InitializeAsync()
        {
            await base.InitializeAsync();

            _model = new BuildingPanelModel();
            _sectionPresenters = new List<IBuildingPanelSectionPresenter>
            {
                new HouseBuildingPanelSectionPresenter(_productCatalog),
                new StorageBuildingPanelSectionPresenter(_productCatalog)
            };

            View.SetModel(_model);
            View.Show(false);

            _signalBus.Subscribe<SelectedBuildingChangedSignal>(OnSelectedBuildingChanged);
            _signalBus.Subscribe<BuildingUpgradedSignal>(OnBuildingUpgraded);
        }

        public void Dispose()
        {
            _signalBus.Unsubscribe<SelectedBuildingChangedSignal>(OnSelectedBuildingChanged);
            _signalBus.Unsubscribe<BuildingUpgradedSignal>(OnBuildingUpgraded);
        }

        private void OnSelectedBuildingChanged(SelectedBuildingChangedSignal signal)
        {
            var selectedBuilding = signal.NewSelection;

            if (selectedBuilding != null)
            {
                _model.SetBuilding(selectedBuilding);
                InitializeSections(selectedBuilding);
                UpdateWorkerHousingWarning(selectedBuilding);
            }

            View.Show(selectedBuilding != null, true);
        }

        private void InitializeSections(Building building)
        {
            foreach (var sectionPresenter in _sectionPresenters)
            {
                if (!sectionPresenter.IsSectionRelevant(building)) continue;
                sectionPresenter.InitializeSection(_model, building);
            }
        }

        public void Update()
        {
            var building = _model.Building;
            if (building == null) return;

            foreach (var sectionPresenter in _sectionPresenters)
            {
                if (!sectionPresenter.IsSectionRelevant(building)) continue;
                sectionPresenter.UpdateSection(_model, building);
            }

            UpdateWorkerHousingWarning(building);
        }

        private void OnBuildingUpgraded(BuildingUpgradedSignal signal)
        {
            if (signal.Building != _uiState.SelectedBuilding) return;

            InitializeSections(signal.Building);
        }

        private void UpdateWorkerHousingWarning(Building building)
        {
            _model.ShowNoHouseNearbyWarning = false;

            if (building == null || _world.TimeState.DayNightCycleStep != DayNightCycleStep.Day) return;

            ref var sleepState = ref building.GetSleepStateRW();
            _model.ShowNoHouseNearbyWarning = sleepState.HasHomelessWorkers;
        }
    }
}