Assets/Scripts/OptimizationLogic/View/OptimizationController.cs - master - GeekNerd/ServerModelingProject

Assets/Scripts/OptimizationLogic/View/OptimizationController.cs
178 строк6 KB
Gorney-Alex
Init
30 май 2026, 19:05
30 май 2026, 19:053cdcc49
using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using App;
using DataClasses;
using DataClasses.Algorithm;
using OptimizationLogic.App;
using OptimizationLogic.Core;
using UnityEngine;
using Zenject;

namespace OptimizationLogic.View
{
    public sealed class OptimizationController : IInitializable, IDisposable
    {
        private const string RoomConfigFile = "room_config";
        private const string ServerSettingsFile = "server_settings";
        private const string GaSettingsFile = "ga_settings";

        private readonly ProjectService _projectService;
        private readonly RackData _defaultRackData;
        private readonly GaSettings _defaultGaSettings;
        private readonly OptimizationOrchestrator _orchestrator;

        private readonly OptimizationUI _ui;
        private readonly RackSpawner _rackSpawner;
        private readonly HeatMapRenderer _heatMap;
        private readonly MetricsPanel _metrics;

        private CancellationTokenSource _cts;
        private bool _running;

        public OptimizationController(
            ProjectService projectService,
            RackData defaultRackData,
            GaSettings defaultGaSettings,
            OptimizationOrchestrator orchestrator,
            OptimizationUI ui,
            RackSpawner rackSpawner,
            HeatMapRenderer heatMap,
            MetricsPanel metrics)
        {
            _projectService = projectService;
            _defaultRackData = defaultRackData;
            _defaultGaSettings = defaultGaSettings;
            _orchestrator = orchestrator;

            _ui = ui;
            _rackSpawner = rackSpawner;
            _heatMap = heatMap;
            _metrics = metrics;
        }

        public void Initialize()
        {
            if (_ui == null)
            {
                Debug.LogWarning("[OptimizationController] OptimizationUI not found in scene.");
                return;
            }

            _ui.OptimizeClicked += OnOptimizeClicked;
            _ui.CancelClicked += OnCancelClicked;

            _metrics?.Clear();
            _heatMap?.Clear();
            _rackSpawner?.Clear();
        }

        public void Dispose()
        {
            CancelInternal();

            if (_ui != null)
            {
                _ui.OptimizeClicked -= OnOptimizeClicked;
                _ui.CancelClicked -= OnCancelClicked;
            }
        }

        private void OnOptimizeClicked()
        {
            if (_running) return;
            _ = RunOptimizationAsync();
        }

        private void OnCancelClicked()
        {
            CancelInternal();
        }

        private async Task RunOptimizationAsync()
        {
            _running = true;
            _ui.SetRunning(true);
            _ui.SetStatus("Optimization started...");

            _metrics?.Clear();
            _heatMap?.Clear();
            _rackSpawner?.Clear();

            _cts = new CancellationTokenSource();

            try
            {
                RoomConfig room = _projectService.LoadData<RoomConfig>(RoomConfigFile);
                if (room == null)
                {
                    _ui.SetStatus("room_config not found.");
                    return;
                }

                RackData server = _projectService.LoadData<RackData>(ServerSettingsFile) ?? _defaultRackData;
                if (server == null)
                {
                    _ui.SetStatus("server_settings not found.");
                    return;
                }

                GaSettings savedSettings = _projectService.LoadData<GaSettings>(GaSettingsFile) ?? _defaultGaSettings;
                GaSettings settings = _ui.BuildSettings(savedSettings);

                // Persist effective settings (including any new fields/defaults like WeightTopology).
                _projectService.SaveData(settings, GaSettingsFile);

                List<RackData> catalog = new List<RackData> { server };

                IProgress<GaProgress> progress = new Progress<GaProgress>(p =>
                {
                    _ui.SetProgress(p.Generation, p.MaxGenerations, p.BestFitness);
                });

                OptimizationResult result = await _orchestrator.RunAsync(room, catalog, settings, progress, _cts.Token);

                if (_cts.IsCancellationRequested)
                {
                    _ui.SetStatus("Optimization canceled.");
                    _rackSpawner?.Clear();
                    _heatMap?.Clear();
                    _metrics?.Clear();
                    return;
                }

                _rackSpawner?.SpawnRacks(result.Best.Genes, catalog, result.ZoneTemperatures, room.TempLimit);
                _heatMap?.Render(room, result.Zones, result.ZoneTemperatures);
                _metrics?.UpdateMetrics(room, result.Zones, result.Best, catalog, result.MaxTemperature);

                _ui.SetStatus("Optimization finished.");
            }
            catch (Exception ex)
            {
                Debug.LogException(ex);
                _ui.SetStatus($"Optimization error: {ex.Message}");
            }
            finally
            {
                _running = false;
                _ui.SetRunning(false);
                CancelInternal(disposeOnly: true);
            }
        }

        private void CancelInternal(bool disposeOnly = false)
        {
            if (_cts == null) return;
            try
            {
                if (!disposeOnly) _cts.Cancel();
            }
            finally
            {
                _cts.Dispose();
                _cts = null;
            }
        }
    }
}