PolyTraderSharp/services/StartupHydrationService.cs

using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Hosting;
using MongoDB.Bson;
using MongoDB.Driver;
using PolyTrader.Core.Persistence;
using PolyTrader.Modules.CopyTrading.Persistence;
using PolyTraderSharp.Models;

namespace PolyTraderSharp.Services
{
    /// <summary>
    /// Hydriert den TradingState (Accounts, Demo-Positionen, Trader) EINMALIG beim App-Start.
    /// Registriert als erster IHostedService, damit die Hydration abgeschlossen ist, bevor die
    /// Trading-BackgroundServices (TraderMonitor, CopyTradingEngine, ...) ihre ExecuteAsync
    /// starten. Behebt den Startup-Race, bei dem Services gegen einen leeren State anliefen
    /// (früher lag diese Logik in frm_main.LoadDatabaseAndState und lief erst NACH AppHost.Start()).
    /// </summary>
    public class StartupHydrationService : IHostedService
    {
        private readonly TradingState _state;
        private readonly CopyTradingState _copyState;
        private readonly IAccountRepository _accountRepo;
        private readonly IPositionRepository _positionRepo;
        private readonly ICopyTradingAccountSettingsRepository _accountSettingsRepo;
        private readonly ITrackedTraderRepository _traderRepo;
        private readonly IMongoDatabase _db;
        private readonly TerminalLogger _logger;

        public StartupHydrationService(
            TradingState state,
            CopyTradingState copyState,
            IAccountRepository accountRepo,
            IPositionRepository positionRepo,
            ICopyTradingAccountSettingsRepository accountSettingsRepo,
            ITrackedTraderRepository traderRepo,
            IMongoDatabase db,
            TerminalLogger logger)
        {
            _state = state;
            _copyState = copyState;
            _accountRepo = accountRepo;
            _positionRepo = positionRepo;
            _accountSettingsRepo = accountSettingsRepo;
            _traderRepo = traderRepo;
            _db = db;
            _logger = logger;
        }

        public Task StartAsync(CancellationToken cancellationToken)
        {
            try
            {
                var accounts = _accountRepo.GetAll();
                foreach (var acc in accounts)
                {
                    if (acc.IsDemo)
                    {
                        foreach (var pos in _positionRepo.GetDemo(acc.AccountId))
                        {
                            acc.OpenPositions.TryAdd(pos.TokenId, pos);
                        }
                    }
                    _state.Accounts[acc.AccountId] = acc;
                }

                HydrateAccountSettings(accounts);

                foreach (var trd in _traderRepo.GetAll())
                {
                    _copyState.Traders[trd.Id] = trd;
                }

                _logger.Info($"Startup-Hydration abgeschlossen: {_state.Accounts.Count} Accounts, {_copyState.Traders.Count} Trader geladen.");
            }
            catch (System.Exception ex)
            {
                _logger.Error($"Startup-Hydration fehlgeschlagen: {ex.Message}");
            }

            return Task.CompletedTask;
        }

        /// <summary>
        /// Lädt die Copytrading-Account-Settings in den State. Existiert für einen Account noch
        /// kein Eintrag, werden die Werte einmalig aus den alten AccountState-Feldern des
        /// Roh-Dokuments migriert (damit konfigurierte Limits nach dem Modell-Split erhalten bleiben).
        /// </summary>
        private void HydrateAccountSettings(List<AccountState> accounts)
        {
            var existing = _accountSettingsRepo.GetAll().ToDictionary(s => s.AccountId);
            var rawAccounts = _db.GetCollection<BsonDocument>("accounts");
            int migrated = 0;

            foreach (var acc in accounts)
            {
                if (existing.TryGetValue(acc.AccountId, out var s))
                {
                    _copyState.AccountSettings[acc.AccountId] = s;
                    continue;
                }

                var settings = new CopyTradingAccountSettings { AccountId = acc.AccountId };
                try
                {
                    var raw = rawAccounts.Find(Builders<BsonDocument>.Filter.Eq("_id", acc.AccountId)).FirstOrDefault();
                    if (raw != null)
                    {
                        settings.PerMarketLimit = Dec(raw, "PerMarketLimit", settings.PerMarketLimit);
                        settings.MaxPriceDifference = Dec(raw, "MaxPriceDifference", settings.MaxPriceDifference);
                        settings.MaxBuyPrice = Dec(raw, "MaxBuyPrice", settings.MaxBuyPrice);
                        settings.ProfitTarget = Dec(raw, "ProfitTarget", settings.ProfitTarget);
                        settings.PreRedeemLimit = Dec(raw, "PreRedeemLimit", settings.PreRedeemLimit);
                        settings.PerMasterLimit = Dec(raw, "PerMasterLimit", settings.PerMasterLimit);
                        settings.perMaxTime6h = Dec(raw, "perMaxTime6h", settings.perMaxTime6h);
                        settings.perMaxTime24h = Dec(raw, "perMaxTime24h", settings.perMaxTime24h);
                        settings.perMaxTime72h = Dec(raw, "perMaxTime72h", settings.perMaxTime72h);
                        settings.perMaxTimeNone = Dec(raw, "perMaxTimeNone", settings.perMaxTimeNone);
                        migrated++;
                    }
                }
                catch { }

                _accountSettingsRepo.Upsert(settings);
                _copyState.AccountSettings[acc.AccountId] = settings;
            }

            if (migrated > 0)
                _logger.Info($"Copytrading-Account-Settings: {migrated} Account(s) aus Alt-Feldern migriert.");
        }

        private static decimal Dec(BsonDocument doc, string field, decimal fallback)
        {
            if (doc.TryGetValue(field, out var v))
            {
                try { return v.ToDecimal(); } catch { }
            }
            return fallback;
        }

        public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
    }
}