using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using FinlyticCore.Dtos;
using FinlyticCore.Dtos.Fundamentals;
using FinlyticCore.Dtos.Sentiment;
using FinlyticCore.Dtos.TechnicalAnalysis;
using FinlyticCore.Dtos.Trading;
using FinlyticCore.Services;
using FinlyticCore.Util;
using FinlyticEngine.Database;
using FinlyticEngine.Database.Entities;
using FinlyticEngine.Services.Ai;
using FinlyticEngine.Services.Derivatives;
using FinlyticEngine.Services.Mqtt;
using FinlyticEngine.Services.Scoring;
using FinlyticEngine.Settings;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;

namespace FinlyticEngine.Services.Trading;

public class TradeLifecycleService : ITradeLifecycleService
{
    private readonly IServiceScopeFactory _scopeFactory;
    private readonly ICompositeOpportunityScorer _scorer;
    private readonly IAiReasoningGateService _aiGate;
    private readonly IKnockOutDerivativeResolver _derivativeResolver;
    private readonly IEngineRpcClient _rpcClient;
    private readonly ISettingsService _settingsService;
    private readonly IFinlyticLogger<TradeLifecycleService> _logger;

    public TradeLifecycleService(
        IServiceScopeFactory scopeFactory,
        ICompositeOpportunityScorer scorer,
        IAiReasoningGateService aiGate,
        IKnockOutDerivativeResolver derivativeResolver,
        IEngineRpcClient rpcClient,
        ISettingsService settingsService,
        IFinlyticLogger<TradeLifecycleService> logger)
    {
        _scopeFactory = scopeFactory;
        _scorer = scorer;
        _aiGate = aiGate;
        _derivativeResolver = derivativeResolver;
        _rpcClient = rpcClient;
        _settingsService = settingsService;
        _logger = logger;
    }

    public async Task<List<TradeProposalDto>> GetProposalsAsync(bool onlyActive = true, int limit = 50, CancellationToken cancellationToken = default)
    {
        using var scope = _scopeFactory.CreateScope();
        var db = scope.ServiceProvider.GetRequiredService<EngineDbContext>();

        var query = db.TradeProposals.AsNoTracking();
        if (onlyActive)
        {
            var now = DateTime.UtcNow;
            query = query.Where(p => p.IsActive && p.ExpiresAtUtc > now);
        }

        var list = await query
            .OrderByDescending(p => p.CompositeScore)
            .Take(limit)
            .ToListAsync(cancellationToken);

        return list.Select(MapProposalEntityToDto).ToList();
    }

    public async Task<List<ActiveTradeDto>> GetActiveTradesAsync(Guid userId, ExecutionMode? mode = null, CancellationToken cancellationToken = default)
    {
        using var scope = _scopeFactory.CreateScope();
        var db = scope.ServiceProvider.GetRequiredService<EngineDbContext>();

        // Tenant boundary: applied before any other predicate so another user's rows are never materialised.
        var query = db.Trades
            .Include(t => t.Fills)
            .AsNoTracking()
            .Where(t => t.UserId == userId)
            .Where(t => t.Status != TradeStatus.Closed && t.Status != TradeStatus.StoppedOut && t.Status != TradeStatus.Invalidated && t.Status != TradeStatus.Expired);

        if (mode.HasValue)
        {
            query = query.Where(t => t.ExecutionMode == mode.Value);
        }

        var list = await query
            .OrderByDescending(t => t.OpenedAtUtc)
            .ToListAsync(cancellationToken);

        return list.Select(MapTradeEntityToDto).ToList();
    }

    /// <summary>
    /// Builds an honest "nothing to evaluate" <see cref="AssetEvaluationResultDto"/> for the cases where the
    /// pipeline could not even produce a real score (blank ISIN, or no technical setups found). All score
    /// fields are <c>0</c>/<c>null</c> rather than fabricated, and <paramref name="reason"/> is prefixed with
    /// the same "<c>[Regelbasiert]</c>" marker <see cref="AiValidationResultDto"/> uses for its
    /// <see cref="ValidationSource.RuleBased"/> fallback, so a caller/UI never mistakes this for a real AI
    /// verdict (Rules.md §4).
    /// </summary>
    private static AssetEvaluationResultDto BuildNoEvaluationResult(string reason)
    {
        return new AssetEvaluationResultDto(
            Proposal: null,
            CompositeScore: 0m,
            TechnicalScore: 0m,
            SentimentScore: 0m,
            FundamentalScore: 0m,
            PassedEarningsLockout: true,
            DaysToNextEarnings: null,
            PassedDividendGate: true,
            DaysToNextExDividend: null,
            AiApproved: false,
            AiThesisSummary: $"[Regelbasiert] {reason}",
            AiIdentifiedRisks: new List<string>()
        );
    }

    /// <summary>
    /// Persists an <see cref="EngineEvaluationSnapshotEntity"/> row for the two early-return cases in
    /// <see cref="EvaluateAssetAsync"/> (blank ISIN, no technical setups) and returns the same
    /// <see cref="BuildNoEvaluationResult"/> DTO the caller would have received before these rows existed.
    /// All score fields are recorded as <c>0</c>/default - identical to <see cref="BuildNoEvaluationResult"/>'s
    /// own honesty guarantee - since the pipeline never reached scoring for these two cases (Rules.md §4).
    /// </summary>
    /// <param name="isinForRecord">The (possibly blank) ISIN to record on the snapshot row.</param>
    /// <param name="reason">Human-readable reason, reused verbatim from <see cref="BuildNoEvaluationResult"/>.</param>
    /// <param name="triggerSource">Whether this evaluation was automatic or manual.</param>
    /// <param name="triggeredByUserId">The manual caller's identity, or <see langword="null"/> for automatic runs.</param>
    /// <param name="cancellationToken">Propagated to the snapshot insert.</param>
    private async Task<AssetEvaluationResultDto> PersistNoEvaluationSnapshotAsync(
        string isinForRecord,
        string reason,
        TriggerSource triggerSource,
        Guid? triggeredByUserId,
        CancellationToken cancellationToken)
    {
        using var scope = _scopeFactory.CreateScope();
        var db = scope.ServiceProvider.GetRequiredService<EngineDbContext>();

        db.Snapshots.Add(new EngineEvaluationSnapshotEntity
        {
            Id = Guid.NewGuid(),
            Isin = isinForRecord,
            Symbol = string.Empty,
            TechnicalScore = 0m,
            SentimentScore = 0m,
            FundamentalScore = 0m,
            CompositeOpportunityScore = 0m,
            ReliabilityBonus = 0m,
            PassedEarningsLockout = true,
            DaysToNextEarnings = null,
            PassedDividendGate = true,
            DaysToNextExDividend = null,
            UniverseSource = null,
            UniverseEnteredAtUtc = null,
            PassedSimulationVeto = true,
            PassedAiValidation = false,
            AiThesisSummary = $"[Regelbasiert] {reason}",
            TriggerSource = triggerSource,
            TriggeredByUserId = triggerSource == TriggerSource.Manual ? triggeredByUserId : null,
            OutcomeReason = OutcomeReason.NoTechnicalSetups,
            ProposalId = null,
            EvaluatedAtUtc = DateTime.UtcNow
        });

        await db.SaveChangesAsync(cancellationToken);

        return BuildNoEvaluationResult(reason);
    }

    /// <summary>
    /// Derives which <see cref="OutcomeReason"/> best explains a completed evaluation (i.e. one that reached
    /// scoring - the earlier "no technical setup" case always short-circuits to
    /// <see cref="OutcomeReason.NoTechnicalSetups"/> and never reaches this method). Note that a result of
    /// <see cref="OutcomeReason.Approved"/> from this method is provisional: <see cref="EvaluateAssetAsync"/>
    /// downgrades it to <see cref="OutcomeReason.DuplicateActiveProposal"/> immediately afterwards if an
    /// active, non-expired proposal already exists for the same ISIN, since no second proposal row is created
    /// in that case.
    /// <para>
    /// Priority order when more than one gate failed simultaneously (first match wins):
    /// </para>
    /// <list type="number">
    /// <item><description>
    /// <see cref="OutcomeReason.Approved"/> - the AI reasoning gate approved the opportunity.
    /// </description></item>
    /// <item><description>
    /// <see cref="OutcomeReason.EarningsLockout"/> - <paramref name="passedEarningsLockout"/> is
    /// <see langword="false"/>. Checked before the score threshold even though the score gate is evaluated
    /// later in the pipeline, because the lockout's suppression multiplier
    /// (<c>CompositeOpportunityScorer</c>'s <c>mEarnings = 0.15</c>) is usually *why* the score ended up below
    /// threshold in the first place - reporting only "score too low" would hide the actual, actionable cause.
    /// </description></item>
    /// <item><description>
    /// <see cref="OutcomeReason.SimulationVeto"/> - <paramref name="passedSimulationVeto"/> is
    /// <see langword="false"/>, for the same reason as the lockout case above (its own suppression multiplier,
    /// <c>mVeto = 0.20</c>, likewise drives the score down).
    /// </description></item>
    /// <item><description>
    /// <see cref="OutcomeReason.DividendGate"/> - <paramref name="passedDividendGate"/> is
    /// <see langword="false"/>. Checked last among the three suppression gates since it is the mildest
    /// (<c>mDividend = 0.5</c> vs. earnings' 0.15 and the simulation veto's 0.20) - a predictable, mechanical
    /// ex-dividend price adjustment rather than a fundamental surprise or a failed backtest.
    /// </description></item>
    /// <item><description>
    /// <see cref="OutcomeReason.BelowScoreThreshold"/> - none of the three hard gates above fired, but
    /// <paramref name="scoreGateOpened"/> is <see langword="false"/>, meaning the composite score never reached
    /// <c>Engine.MinCompositeScore</c> and the evaluation was not forced, so the AI reasoning gate was never
    /// even consulted (a synthetic rule-based rejection was recorded instead).
    /// </description></item>
    /// <item><description>
    /// <see cref="OutcomeReason.AiRejected"/> - everything upstream cleared (<paramref name="scoreGateOpened"/>
    /// is <see langword="true"/>, both hard gates passed) but the AI reasoning gate itself - whether a real AI
    /// call or one of its own internal rule-based fallbacks (gate disabled, webhook unreachable) - still
    /// declined. This is deliberately the last, most specific fallback: everything else has already been
    /// ruled out by the time this is reached.
    /// </description></item>
    /// </list>
    /// </summary>
    /// <param name="aiApproved"><c>AiValidationResultDto.IsApproved</c> from the (possibly rule-based) AI gate result.</param>
    /// <param name="passedEarningsLockout"><c>ScoringResult.PassedEarningsLockout</c>.</param>
    /// <param name="passedSimulationVeto"><c>ScoringResult.PassedSimulationVeto</c>.</param>
    /// <param name="scoreGateOpened">
    /// Whether the composite score cleared <c>Engine.MinCompositeScore</c> or the evaluation was forced - i.e.
    /// the exact condition under which the AI reasoning gate was actually consulted rather than synthetically
    /// rejected.
    /// </param>
    /// <returns>The single best-matching <see cref="OutcomeReason"/> for this evaluation.</returns>
    private static OutcomeReason DetermineOutcomeReason(
        bool aiApproved,
        bool passedEarningsLockout,
        bool passedSimulationVeto,
        bool passedDividendGate,
        bool scoreGateOpened)
    {
        if (aiApproved) return OutcomeReason.Approved;
        if (!passedEarningsLockout) return OutcomeReason.EarningsLockout;
        if (!passedSimulationVeto) return OutcomeReason.SimulationVeto;
        if (!passedDividendGate) return OutcomeReason.DividendGate;
        if (!scoreGateOpened) return OutcomeReason.BelowScoreThreshold;
        return OutcomeReason.AiRejected;
    }

    /// <inheritdoc />
    public async Task<AssetEvaluationResultDto> EvaluateAssetAsync(
        string isin,
        string? ticker = null,
        bool forceAiEvaluation = false,
        TriggerSource triggerSource = TriggerSource.Automatic,
        Guid? triggeredByUserId = null,
        CancellationToken cancellationToken = default)
    {
        // Automatic runs never carry a user identity, enforced here regardless of what a caller passed in, so
        // a programming mistake upstream can never leak a stale/wrong UserId onto an automatic snapshot row.
        var effectiveTriggeredByUserId = triggerSource == TriggerSource.Manual ? triggeredByUserId : null;

        if (string.IsNullOrWhiteSpace(isin))
        {
            return await PersistNoEvaluationSnapshotAsync(
                string.Empty, "Keine gültige ISIN angegeben.", triggerSource, effectiveTriggeredByUserId, cancellationToken);
        }
        var cleanIsin = isin.Trim().ToUpperInvariant();

        await _logger.LogInfoAsync(EngineSettingKeys.EngineChannel,
            "[TradeLifecycle] Starting on-demand evaluation for ISIN {Isin} (Ticker: {Ticker})", cleanIsin, ticker ?? "N/A");


        // 1. Fetch Technical Analysis Setups from FinlyticTechnicals
        var taSetups = await _rpcClient.SendRpcRequestAsync<List<StrategyResultDto>, IsinRequest>(
            MqttTopics.Channels.TaGetSetupsForIsin,
            new IsinRequest(cleanIsin, ticker, ForceRefresh: false),
            TimeSpan.FromSeconds(5)
        );

        if (taSetups == null || taSetups.Count == 0)
        {
            await _logger.LogWarningAsync(EngineSettingKeys.EngineChannel,
                "[TradeLifecycle] No technical setups returned for {Isin}", cleanIsin);
            return await PersistNoEvaluationSnapshotAsync(
                cleanIsin, $"Keine technischen Setups für {cleanIsin} verfügbar.", triggerSource, effectiveTriggeredByUserId, cancellationToken);
        }

        // Pick top technical setup
        var bestSetup = taSetups.OrderByDescending(s => s.QualityScore).First();

        // 2. Parallel Fetch: Sentiment, Fundamentals & Simulation Matrix
        var sentTask = _rpcClient.SendRpcRequestAsync<IsinSentimentSummaryDto, GetSentimentByIsinRequest>(
            MqttTopics.Channels.SentimentGetIsin,
            new GetSentimentByIsinRequest(cleanIsin),
            TimeSpan.FromSeconds(3)
        );

        var fundTask = _rpcClient.SendRpcRequestAsync<AssetFundamentalsDto, IsinRequest>(
            MqttTopics.Channels.FundamentalsGet,
            new IsinRequest(cleanIsin, ticker, ForceRefresh: false),
            TimeSpan.FromSeconds(4)
        );

        var matrixTask = _rpcClient.SendRpcRequestAsync<FinlyticCore.Dtos.Simulation.StrategyAssetReliabilityDto, FinlyticCore.Dtos.Simulation.GetReliabilityRequest>(
            MqttTopics.Channels.SimGetReliability,
            new FinlyticCore.Dtos.Simulation.GetReliabilityRequest(cleanIsin, bestSetup.StrategyKey),
            TimeSpan.FromSeconds(3)
        );

        await Task.WhenAll(sentTask, fundTask, matrixTask);

        var sentiment = await sentTask;
        var fundamentals = await fundTask;
        var reliability = await matrixTask;

        // 3. Multi-Faktor Composite Opportunity Scoring (COS) with Simulation Feedback
        var scoringResult = await _scorer.CalculateCompositeScoreAsync(bestSetup, sentiment, fundamentals, reliability, cancellationToken);
        var minScore = await _settingsService.GetSettingAsync(EngineSettingKeys.MinCompositeScore, cancellationToken);


        // 4. AI Reasoning Gate
        // Captured explicitly (rather than re-evaluating the same expression later) because
        // DetermineOutcomeReason needs to know precisely whether the AI gate was ever consulted, to tell
        // apart OutcomeReason.BelowScoreThreshold (never consulted) from OutcomeReason.AiRejected (consulted,
        // declined) below.
        bool scoreGateOpened = scoringResult.CompositeScore >= minScore || forceAiEvaluation;

        AiValidationResultDto aiValidation;
        if (scoreGateOpened)
        {
            aiValidation = await _aiGate.ValidateOpportunityAsync(bestSetup, sentiment, fundamentals, scoringResult, reliability, cancellationToken);
        }
        else
        {
            aiValidation = new AiValidationResultDto(
                IsApproved: false,
                Confidence: null,
                Source: ValidationSource.RuleBased,
                ThesisSummary: $"[Regelbasiert] Score {scoringResult.CompositeScore:F1} liegt unter Mindestwert ({minScore:F1}).",
                InvalidationReason: "Unzureichende Multi-Faktor Confluence.",
                KeyCatalysts: new List<string>(),
                IdentifiedRisks: new List<string> { "Niedriger Gesamtscore" }
            );
        }

        // 5. Knock-Out Derivative Selection
        DerivativeSelectionDto? selectedDerivative = null;
        if (aiValidation.IsApproved || forceAiEvaluation)
        {
            selectedDerivative = await _derivativeResolver.ResolveOptimalTurboAsync(
                cleanIsin,
                bestSetup.Direction,
                bestSetup.InvalidationPrice,
                bestSetup.CurrentPrice,
                cancellationToken
            );
        }

        // 6. Persist Evaluation Snapshot & Proposal
        using var scope = _scopeFactory.CreateScope();
        var db = scope.ServiceProvider.GetRequiredService<EngineDbContext>();

        var outcomeReason = DetermineOutcomeReason(
            aiValidation.IsApproved, scoringResult.PassedEarningsLockout, scoringResult.PassedSimulationVeto,
            scoringResult.PassedDividendGate, scoreGateOpened);

        var snapshot = new EngineEvaluationSnapshotEntity
        {
            Id = Guid.NewGuid(),
            Isin = cleanIsin,
            Symbol = bestSetup.Symbol,
            TechnicalScore = scoringResult.TechnicalScore,
            SentimentScore = scoringResult.SentimentScore,
            FundamentalScore = scoringResult.FundamentalScore,
            CompositeOpportunityScore = scoringResult.CompositeScore,
            ReliabilityBonus = scoringResult.ReliabilityBonus,
            PassedEarningsLockout = scoringResult.PassedEarningsLockout,
            DaysToNextEarnings = scoringResult.DaysToNextEarnings,
            PassedDividendGate = scoringResult.PassedDividendGate,
            DaysToNextExDividend = scoringResult.DaysToNextExDividend,
            UniverseSource = bestSetup.UniverseSource,
            UniverseEnteredAtUtc = bestSetup.UniverseEnteredAtUtc,
            PassedSimulationVeto = scoringResult.PassedSimulationVeto,
            PassedAiValidation = aiValidation.IsApproved,
            AiThesisSummary = aiValidation.ThesisSummary,
            TriggerSource = triggerSource,
            TriggeredByUserId = effectiveTriggeredByUserId,
            OutcomeReason = outcomeReason,
            ProposalId = null,
            EvaluatedAtUtc = DateTime.UtcNow
        };
        db.Snapshots.Add(snapshot);

        TradeProposalDto? proposalDto = null;

        if (aiValidation.IsApproved)
        {
            // Dedup guard: OpportunityPollerBackgroundService re-evaluates the same technical top-picks on
            // every scan cycle. Without this check, an asset that stays above the approval threshold for hours
            // gets a brand-new, near-identical EngineTradeProposalEntity - and a fresh
            // finlytic/engine/proposals/created broadcast to every connected client - every single cycle. This
            // was confirmed in production as the root cause of a single ISIN generating 1,310 proposal rows in
            // roughly two hours. An active, non-expired proposal already covering the same UnderlyingIsin means
            // the opportunity is already on offer, so no second row/broadcast is created for it.
            var existingActiveProposal = await db.TradeProposals
                .AsNoTracking()
                .Where(p => p.UnderlyingIsin == cleanIsin && p.IsActive && p.ExpiresAtUtc > DateTime.UtcNow)
                .OrderByDescending(p => p.CreatedAtUtc)
                .FirstOrDefaultAsync(cancellationToken);

            if (existingActiveProposal != null)
            {
                // The evaluation itself genuinely cleared every gate (PassedAiValidation on this snapshot row
                // stays true), but OutcomeReason records the real business outcome: no new proposal was made.
                outcomeReason = OutcomeReason.DuplicateActiveProposal;
                snapshot.OutcomeReason = outcomeReason;
                snapshot.ProposalId = existingActiveProposal.Id;

                await db.SaveChangesAsync(cancellationToken);

                // A manual "Analyze now" call for an asset that already has an open proposal should still
                // surface that proposal, not falsely report "no proposal" (Rules.md §4).
                proposalDto = MapProposalEntityToDto(existingActiveProposal);
            }
            else
            {
                var proposalValidityHours = await _settingsService.GetSettingAsync(EngineSettingKeys.ProposalValidityHours, cancellationToken);

                decimal takeProfit1 = bestSetup.ExitPlan.TakeProfitStages.Count > 0
                    ? bestSetup.ExitPlan.TakeProfitStages[0].TargetPrice
                    : (bestSetup.Direction == SignalDirection.Buy ? bestSetup.EntryPrice * 1.05m : bestSetup.EntryPrice * 0.95m);

                var proposalEntity = new EngineTradeProposalEntity
                {
                    Id = Guid.NewGuid(),
                    UnderlyingIsin = cleanIsin,
                    Symbol = bestSetup.Symbol,
                    StrategyKey = bestSetup.StrategyKey,
                    Direction = bestSetup.Direction,
                    QualityScore = bestSetup.QualityScore,
                    CompositeScore = scoringResult.CompositeScore,
                    CurrentPrice = bestSetup.CurrentPrice,
                    EntryPrice = bestSetup.EntryPrice,
                    StopLoss = bestSetup.InvalidationPrice,
                    TakeProfit1 = takeProfit1,
                    RiskRewardRatio = bestSetup.EstimatedRiskRewardRatio,
                    ExitPlan = bestSetup.ExitPlan,
                    SelectedDerivative = selectedDerivative,
                    AiValidation = aiValidation,
                    IsActive = true,
                    CreatedAtUtc = DateTime.UtcNow,
                    ExpiresAtUtc = DateTime.UtcNow.AddHours(proposalValidityHours)
                };

                // Link the snapshot row to the proposal it produced (both are still unsaved/tracked here, so
                // this just needs to happen before the single SaveChangesAsync below persists both).
                snapshot.ProposalId = proposalEntity.Id;

                db.TradeProposals.Add(proposalEntity);
                await db.SaveChangesAsync(cancellationToken);

                proposalDto = MapProposalEntityToDto(proposalEntity);

                // Broadcast MQTT Push Event for new proposal
                await _rpcClient.PublishAsync("finlytic/engine/proposals/created", proposalDto);
            }
        }
        else
        {
            await db.SaveChangesAsync(cancellationToken);
        }

        // Whether approved or rejected, the caller always receives the real, already-computed scores and AI
        // reasoning — never bare silence for a rejection (Rules.md §4).
        return new AssetEvaluationResultDto(
            Proposal: proposalDto,
            CompositeScore: scoringResult.CompositeScore,
            TechnicalScore: scoringResult.TechnicalScore,
            SentimentScore: scoringResult.SentimentScore,
            FundamentalScore: scoringResult.FundamentalScore,
            PassedEarningsLockout: scoringResult.PassedEarningsLockout,
            DaysToNextEarnings: scoringResult.DaysToNextEarnings,
            PassedDividendGate: scoringResult.PassedDividendGate,
            DaysToNextExDividend: scoringResult.DaysToNextExDividend,
            AiApproved: aiValidation.IsApproved,
            AiThesisSummary: aiValidation.ThesisSummary,
            AiIdentifiedRisks: aiValidation.IdentifiedRisks
        );
    }

    public async Task<ActiveTradeDto?> CreateTradeFromProposalAsync(
        Guid userId,
        Guid proposalId,
        ExecutionMode mode,
        decimal? initialFillPrice = null,
        decimal? initialQuantity = null,
        CancellationToken cancellationToken = default)
    {
        using var scope = _scopeFactory.CreateScope();
        var db = scope.ServiceProvider.GetRequiredService<EngineDbContext>();

        // Only a still-active, non-expired proposal may be accepted. Proposals invalidate themselves purely
        // via ExpiresAtUtc (see EvaluateAssetAsync) — there is no separate "reject" path that deactivates them.
        var now = DateTime.UtcNow;
        var proposal = await db.TradeProposals
            .FirstOrDefaultAsync(p => p.Id == proposalId && p.IsActive && p.ExpiresAtUtc > now, cancellationToken);
        if (proposal == null) return null;

        // A proposal is a system-wide opportunity, not a per-user resource: it is deliberately NOT consumed or
        // deactivated here so other users may still accept it independently. What must be prevented is the same
        // user accepting the same proposal twice, which would otherwise silently create a second, redundant trade.
        var alreadyAccepted = await db.Trades
            .AnyAsync(t => t.UserId == userId && t.ProposalId == proposalId, cancellationToken);
        if (alreadyAccepted)
        {
            throw new InvalidOperationException(
                $"User {userId} has already accepted proposal {proposalId}; a duplicate trade was not created.");
        }

        var fillPrice = initialFillPrice ?? proposal.EntryPrice;
        var fillQty = initialQuantity ?? 1m;

        var trade = new EngineTradeEntity
        {
            Id = Guid.NewGuid(),
            UserId = userId,
            ProposalId = proposal.Id,
            UnderlyingIsin = proposal.UnderlyingIsin,
            Symbol = proposal.Symbol,
            DerivativeIsin = proposal.SelectedDerivative?.DerivativeIsin,
            DerivativeWkn = proposal.SelectedDerivative?.DerivativeWkn,
            ExecutionMode = mode,
            InstrumentType = proposal.SelectedDerivative != null
                ? (proposal.Direction == SignalDirection.Buy ? InstrumentCategoryType.TurboLong : InstrumentCategoryType.TurboShort)
                : InstrumentCategoryType.Stock,
            Direction = proposal.Direction,
            Status = TradeStatus.Active,
            AverageBuyIn = fillPrice,
            TotalQuantity = fillQty,
            InitialStopLoss = proposal.StopLoss,
            CurrentStopLoss = proposal.StopLoss,
            CurrentPrice = fillPrice,
            TakeProfit1 = proposal.TakeProfit1,
            TakeProfit2 = proposal.ExitPlan.TakeProfitStages.Count > 1 ? proposal.ExitPlan.TakeProfitStages[1].TargetPrice : proposal.TakeProfit1 * 1.05m,
            ExitPlan = proposal.ExitPlan,
            OpenedAtUtc = DateTime.UtcNow,
            LastUpdatedAtUtc = DateTime.UtcNow
        };

        var initialFill = new EngineTradeFillEntity
        {
            Id = Guid.NewGuid(),
            TradeId = trade.Id,
            Trade = trade,
            ExecutedAtUtc = DateTime.UtcNow,
            Price = fillPrice,
            Quantity = fillQty,
            Fee = 1.0m,
            Note = "Initial Entry Fill"
        };

        // trade is a brand-new root here, so db.Trades.Add(trade) cascades Added through the whole graph
        // (including Fills) on its own — the explicit db.TradeFills.Add is redundant but keeps this call site
        // consistent with AddTradeFillAsync, where it is NOT redundant (see the comment there).
        trade.Fills.Add(initialFill);
        db.Trades.Add(trade);
        db.TradeFills.Add(initialFill);

        await db.SaveChangesAsync(cancellationToken);

        var tradeDto = MapTradeEntityToDto(trade);
        await _rpcClient.PublishAsync("finlytic/engine/trades/status_changed", tradeDto);

        return tradeDto;
    }

    public async Task<ActiveTradeDto> AcceptProposalAsync(AcceptTradeProposalRequest request, CancellationToken cancellationToken = default)
    {
        // ExecutionMode.ManualTradeRepublic is hardcoded here (rather than taken from the request) because this
        // RPC channel exists specifically for the human-driven Web/App acceptance flow, where a user reviews a
        // proposal in Trade Republic and confirms a manual fill. The autonomous paper-trading bot never calls
        // this endpoint — it executes proposals itself via FinlyticBot, which uses its own dedicated code path
        // instead of AcceptProposalAsync.
        var trade = await CreateTradeFromProposalAsync(
            request.UserId,
            request.ProposalId,
            ExecutionMode.ManualTradeRepublic,
            request.ExecutedPrice,
            request.Quantity,
            cancellationToken);

        if (trade == null)
        {
            throw new InvalidOperationException(
                $"Proposal {request.ProposalId} does not exist, is no longer active, or has expired.");
        }

        return trade;
    }

    public async Task<ActiveTradeDto> CreateManualTradeAsync(CreateManualTradeRequest request, CancellationToken cancellationToken = default)
    {
        if (string.IsNullOrWhiteSpace(request.UnderlyingIsin))
        {
            throw new ArgumentException("UnderlyingIsin must not be blank.", nameof(request));
        }

        if (string.IsNullOrWhiteSpace(request.Symbol))
        {
            throw new ArgumentException("Symbol must not be blank.", nameof(request));
        }

        if (request.EntryPrice <= 0m)
        {
            throw new ArgumentException("EntryPrice must be positive.", nameof(request));
        }

        if (request.Quantity <= 0m)
        {
            throw new ArgumentException("Quantity must be positive.", nameof(request));
        }

        using var scope = _scopeFactory.CreateScope();
        var db = scope.ServiceProvider.GetRequiredService<EngineDbContext>();

        var takeProfit1 = request.TakeProfit1;
        var takeProfit2 = request.TakeProfit2 ?? takeProfit1;

        var exitPlan = new ExitPlan(
            StrategyType: ExitStrategyType.FixedSingleTarget,
            InitialStopLoss: request.InitialStopLoss,
            TakeProfitStages: new List<TakeProfitStage>
            {
                new(StageNumber: 1, TargetPrice: takeProfit1, PercentToClose: 100m, RMultiple: 1m, Description: "Manuelles Kursziel (kein Proposal)")
            });

        var trade = new EngineTradeEntity
        {
            Id = Guid.NewGuid(),
            UserId = request.UserId,
            // No backing proposal: Guid.Empty signals "manually opened" (see doc comment on
            // CreateManualTradeRequest / ITradeLifecycleService.CreateManualTradeAsync).
            ProposalId = Guid.Empty,
            UnderlyingIsin = request.UnderlyingIsin.Trim().ToUpperInvariant(),
            Symbol = request.Symbol,
            DerivativeIsin = request.DerivativeIsin,
            DerivativeWkn = request.DerivativeWkn,
            ExecutionMode = ExecutionMode.ManualTradeRepublic,
            InstrumentType = request.InstrumentType,
            Direction = request.Direction,
            Status = TradeStatus.Active,
            AverageBuyIn = request.EntryPrice,
            TotalQuantity = request.Quantity,
            InitialStopLoss = request.InitialStopLoss,
            CurrentStopLoss = request.InitialStopLoss,
            CurrentPrice = request.EntryPrice,
            TakeProfit1 = takeProfit1,
            TakeProfit2 = takeProfit2,
            TotalFeesEur = request.Fee,
            ExitPlan = exitPlan,
            OpenedAtUtc = DateTime.UtcNow,
            LastUpdatedAtUtc = DateTime.UtcNow
        };

        var initialFill = new EngineTradeFillEntity
        {
            Id = Guid.NewGuid(),
            TradeId = trade.Id,
            Trade = trade,
            ExecutedAtUtc = DateTime.UtcNow,
            Price = request.EntryPrice,
            Quantity = request.Quantity,
            Fee = request.Fee,
            Note = "Manual Entry (no proposal)"
        };

        // trade is a brand-new root here, so db.Trades.Add(trade) cascades Added through the whole graph
        // (including Fills) on its own — the explicit db.TradeFills.Add is redundant but keeps this call site
        // consistent with AddTradeFillAsync, where it is NOT redundant (see the comment there).
        trade.Fills.Add(initialFill);
        db.Trades.Add(trade);
        db.TradeFills.Add(initialFill);

        await db.SaveChangesAsync(cancellationToken);

        var dto = MapTradeEntityToDto(trade);
        await _rpcClient.PublishAsync("finlytic/engine/trades/status_changed", dto);

        return dto;
    }

    public async Task<ActiveTradeDto> AddTradeFillAsync(
        Guid userId,
        Guid tradeId,
        decimal executedPrice,
        decimal quantity,
        decimal fee = 0m,
        string? note = null,
        CancellationToken cancellationToken = default)
    {
        using var scope = _scopeFactory.CreateScope();
        var db = scope.ServiceProvider.GetRequiredService<EngineDbContext>();

        var trade = await db.Trades
            .Include(t => t.Fills)
            .FirstOrDefaultAsync(t => t.Id == tradeId && t.UserId == userId, cancellationToken);

        if (trade == null) throw new InvalidOperationException($"Trade with ID {tradeId} not found.");

        var fill = new EngineTradeFillEntity
        {
            Id = Guid.NewGuid(),
            TradeId = trade.Id,
            Trade = trade,
            ExecutedAtUtc = DateTime.UtcNow,
            Price = executedPrice,
            Quantity = quantity,
            Fee = fee,
            Note = note
        };

        // Explicitly track the new fill as Added via the DbSet, not just via collection-navigation fixup.
        // A fill's Id is a client-generated Guid (set above), so if this entity only entered the change
        // tracker through `trade.Fills.Add(fill)` on an already-tracked trade, EF Core cannot use "default
        // key value => Added" as its heuristic (the key is never default) and instead discovers the object as
        // Unchanged, then promotes it to Modified once DetectChanges sees its properties differ from nothing —
        // producing an UPDATE for a row that was never inserted (DbUpdateConcurrencyException: 0 rows
        // affected). db.TradeFills.Add(fill) marks it Added unambiguously; trade.Fills.Add(fill) is still
        // needed so the in-memory graph/DTO mapping below sees the new fill.
        db.TradeFills.Add(fill);
        trade.Fills.Add(fill);

        // Recalculate Dynamic Average Buy-In: Sum(P * Q) / Sum(Q)
        decimal totalValue = trade.Fills.Sum(f => f.Price * f.Quantity);
        decimal totalQty = trade.Fills.Sum(f => f.Quantity);

        if (totalQty > 0)
        {
            trade.AverageBuyIn = Math.Round(totalValue / totalQty, 4);
            trade.TotalQuantity = totalQty;
        }

        trade.TotalFeesEur = trade.Fills.Sum(f => f.Fee);
        trade.Status = TradeStatus.Active;
        trade.LastUpdatedAtUtc = DateTime.UtcNow;

        // Recalculate Dynamic R-Levels & Take-Profits based on new AverageBuyIn
        decimal unitRisk = Math.Abs(trade.AverageBuyIn - trade.InitialStopLoss);
        if (unitRisk > 0)
        {
            if (trade.Direction == SignalDirection.Buy)
            {
                trade.TakeProfit1 = trade.AverageBuyIn + (1.0m * unitRisk);
                trade.TakeProfit2 = trade.AverageBuyIn + (2.0m * unitRisk);
            }
            else
            {
                trade.TakeProfit1 = trade.AverageBuyIn - (1.0m * unitRisk);
                trade.TakeProfit2 = trade.AverageBuyIn - (2.0m * unitRisk);
            }
        }

        await db.SaveChangesAsync(cancellationToken);

        await _logger.LogInfoAsync(EngineSettingKeys.TradeLifecycleChannel,
            "[TradeLifecycle] Fill added to trade {TradeId}: Qty={Qty}, Price={Price:F2}, New AverageBuyIn={BuyIn:F4}, TotalQty={TotalQty}",
            trade.Id, quantity, executedPrice, trade.AverageBuyIn, trade.TotalQuantity);

        var dto = MapTradeEntityToDto(trade);
        await _rpcClient.PublishAsync("finlytic/engine/trades/status_changed", dto);

        return dto;
    }

    public async Task<ActiveTradeDto> UpdateStopLossAsync(
        Guid userId,
        Guid tradeId,
        decimal newStopLoss,
        string reason,
        CancellationToken cancellationToken = default)
    {
        using var scope = _scopeFactory.CreateScope();
        var db = scope.ServiceProvider.GetRequiredService<EngineDbContext>();

        var trade = await db.Trades
            .Include(t => t.Fills)
            .FirstOrDefaultAsync(t => t.Id == tradeId && t.UserId == userId, cancellationToken);

        if (trade == null) throw new InvalidOperationException($"Trade with ID {tradeId} not found.");

        decimal oldSl = trade.CurrentStopLoss;
        trade.CurrentStopLoss = newStopLoss;
        trade.LastUpdatedAtUtc = DateTime.UtcNow;

        await db.SaveChangesAsync(cancellationToken);

        await _logger.LogInfoAsync(EngineSettingKeys.TradeLifecycleChannel,
            "[TradeLifecycle] Stop Loss updated for trade {TradeId} from {OldSl:F2} to {NewSl:F2}. Reason: {Reason}",
            trade.Id, oldSl, newStopLoss, reason);

        var dto = MapTradeEntityToDto(trade);
        await _rpcClient.PublishAsync("finlytic/engine/trades/status_changed", dto);

        return dto;
    }

    public async Task<ActiveTradeDto> CloseTradeAsync(
        Guid userId,
        Guid tradeId,
        decimal closePrice,
        string reason,
        CancellationToken cancellationToken = default)
    {
        using var scope = _scopeFactory.CreateScope();
        var db = scope.ServiceProvider.GetRequiredService<EngineDbContext>();

        var trade = await db.Trades
            .Include(t => t.Fills)
            .FirstOrDefaultAsync(t => t.Id == tradeId && t.UserId == userId, cancellationToken);

        if (trade == null) throw new InvalidOperationException($"Trade with ID {tradeId} not found.");

        trade.Status = TradeStatus.Closed;
        trade.ClosedAtUtc = DateTime.UtcNow;
        trade.CurrentPrice = closePrice;
        trade.LastUpdatedAtUtc = DateTime.UtcNow;

        // Realized PnL Calculation
        if (trade.Direction == SignalDirection.Buy)
        {
            trade.RealizedPnlEur = ((closePrice - trade.AverageBuyIn) * trade.TotalQuantity) - trade.TotalFeesEur;
        }
        else
        {
            trade.RealizedPnlEur = ((trade.AverageBuyIn - closePrice) * trade.TotalQuantity) - trade.TotalFeesEur;
        }

        await db.SaveChangesAsync(cancellationToken);

        await _logger.LogInfoAsync(EngineSettingKeys.TradeLifecycleChannel,
            "[TradeLifecycle] Trade {TradeId} closed at {Price:F2} (PnL: {PnL:F2} €). Reason: {Reason}",
            trade.Id, closePrice, trade.RealizedPnlEur, reason);

        var dto = MapTradeEntityToDto(trade);
        await _rpcClient.PublishAsync("finlytic/engine/trades/status_changed", dto);

        return dto;
    }

    private static TradeProposalDto MapProposalEntityToDto(EngineTradeProposalEntity e)
    {
        return new TradeProposalDto(
            ProposalId: e.Id,
            UnderlyingIsin: e.UnderlyingIsin,
            Symbol: e.Symbol,
            StrategyKey: e.StrategyKey,
            Direction: e.Direction,
            QualityScore: e.QualityScore,
            CompositeScore: e.CompositeScore,
            CurrentPrice: e.CurrentPrice,
            EntryPrice: e.EntryPrice,
            InvalidationPrice: e.StopLoss,
            ExitPlan: e.ExitPlan,
            SelectedDerivative: e.SelectedDerivative,
            AiValidation: e.AiValidation,
            CreatedAtUtc: e.CreatedAtUtc,
            ExpiresAtUtc: e.ExpiresAtUtc
        );
    }

    private static ActiveTradeDto MapTradeEntityToDto(EngineTradeEntity e)
    {
        decimal unrealizedPnlEur = 0m;
        decimal unrealizedPnlPercent = 0m;

        if (e.AverageBuyIn > 0 && e.TotalQuantity > 0 && e.CurrentPrice > 0)
        {
            if (e.Direction == SignalDirection.Buy)
            {
                unrealizedPnlEur = (e.CurrentPrice - e.AverageBuyIn) * e.TotalQuantity;
                unrealizedPnlPercent = ((e.CurrentPrice - e.AverageBuyIn) / e.AverageBuyIn) * 100m;
            }
            else
            {
                unrealizedPnlEur = (e.AverageBuyIn - e.CurrentPrice) * e.TotalQuantity;
                unrealizedPnlPercent = ((e.AverageBuyIn - e.CurrentPrice) / e.AverageBuyIn) * 100m;
            }
        }

        return new ActiveTradeDto(
            TradeId: e.Id,
            ProposalId: e.ProposalId,
            UnderlyingIsin: e.UnderlyingIsin,
            Symbol: e.Symbol,
            DerivativeIsin: e.DerivativeIsin,
            DerivativeWkn: e.DerivativeWkn,
            ExecutionMode: e.ExecutionMode,
            InstrumentType: e.InstrumentType,
            Direction: e.Direction,
            Status: e.Status,
            AverageBuyIn: e.AverageBuyIn,
            TotalQuantity: e.TotalQuantity,
            InitialStopLoss: e.InitialStopLoss,
            CurrentStopLoss: e.CurrentStopLoss,
            CurrentPrice: e.CurrentPrice,
            UnrealizedPnlEur: Math.Round(unrealizedPnlEur, 2),
            UnrealizedPnlPercent: Math.Round(unrealizedPnlPercent, 2),
            RealizedPnlEur: Math.Round(e.RealizedPnlEur, 2),
            ExitPlan: e.ExitPlan,
            Fills: e.Fills.Select(f => new TradeFillDto(
                FillId: f.Id,
                ExecutedAtUtc: f.ExecutedAtUtc,
                Price: f.Price,
                Quantity: f.Quantity,
                Fee: f.Fee,
                Note: f.Note
            )).ToList(),
            OpenedAtUtc: e.OpenedAtUtc,
            ClosedAtUtc: e.ClosedAtUtc
        );
    }
}