using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using MongoDB.Bson;
using MongoDB.Driver;
using PolyTrader.Core.Persistence;
using PolyTrader.Core.Persistence.Ef;
using PolyTrader.Core.Persistence.Mongo;
using PolyTrader.Modules.CopyTrading.Persistence;
using PolyTrader.Modules.CopyTrading.Persistence.Ef;
using PolyTrader.Modules.CopyTrading.Persistence.Mongo;
using PolyTraderSharp.Models;

namespace PolyTraderSharp.Services
{
    /// <summary>
    /// Einmalige Config-Migration Mongo → MySQL (Phase 6, Stufe 4).
    /// Kopiert NUR Konfiguration: Accounts, aktive Markets, Master-Trader,
    /// Copytrading-Account-Settings (inkl. Fallback auf Alt-Felder im accounts-Dokument)
    /// und Demo-Positionen (reines App-State). Handels-/Master-Trader-Historie startet leer.
    ///
    /// Aufruf: <c>PolyTraderSharp.exe --migrate-config</c> (kein UI-Start).
    /// Liest die Mongo-Verbindung aus Database:ConnectionString/DatabaseName, die
    /// MySQL-Verbindung aus Database:MySqlConnectionString (appsettings[.Local].json).
    /// Idempotent über Upserts (mehrfacher Aufruf überschreibt, dupliziert nicht).
    /// </summary>
    public static class ConfigMigrator
    {
        public static void Run(string mongoConnection, string mongoDbName, string mySqlConnection)
        {
            Console.WriteLine("=== Config-Migration Mongo -> MySQL ===");
            Console.WriteLine($"Quelle (Mongo): {mongoDbName} @ {mongoConnection}");
            Console.WriteLine($"Ziel   (MySQL): {Redact(mySqlConnection)}");

            // --- Quelle: Mongo ---
            var mongoDb = new MongoClient(mongoConnection).GetDatabase(mongoDbName);
            var srcAccounts = new MongoAccountRepository(mongoDb);
            var srcMarkets = new MongoMarketRepository(mongoDb);
            var srcPositions = new MongoPositionRepository(mongoDb);
            var srcTraders = new MongoTrackedTraderRepository(mongoDb);
            var srcSettings = new MongoCopyTradingAccountSettingsRepository(mongoDb);
            var rawAccounts = mongoDb.GetCollection<BsonDocument>("accounts");

            // --- Ziel: MySQL/EF (eigene Mini-Container für die DbContext-Factories) ---
            var target = new ServiceCollection()
                .AddDbContextFactory<CoreDbContext>(o => o.UseMySql(mySqlConnection, ServerVersion.AutoDetect(mySqlConnection)))
                .AddDbContextFactory<CopyTradingDbContext>(o => o.UseMySql(mySqlConnection, ServerVersion.AutoDetect(mySqlConnection)))
                .BuildServiceProvider();

            var coreFactory = target.GetRequiredService<IDbContextFactory<CoreDbContext>>();
            var ctFactory = target.GetRequiredService<IDbContextFactory<CopyTradingDbContext>>();

            IAccountRepository dstAccounts = new EfAccountRepository(coreFactory);
            IMarketRepository dstMarkets = new EfMarketRepository(coreFactory);
            IPositionRepository dstPositions = new EfPositionRepository(coreFactory);
            ITrackedTraderRepository dstTraders = new EfTrackedTraderRepository(ctFactory);
            ICopyTradingAccountSettingsRepository dstSettings = new EfCopyTradingAccountSettingsRepository(ctFactory);

            dstMarkets.EnsureIndexes();

            // 1) Accounts
            var accounts = srcAccounts.GetAll();
            foreach (var acc in accounts)
                dstAccounts.Upsert(acc);
            Console.WriteLine($"[OK] Accounts: {accounts.Count}");

            // 2) Aktive Markets
            var markets = srcMarkets.GetActive();
            foreach (var m in markets)
                dstMarkets.Upsert(m);
            Console.WriteLine($"[OK] Markets (aktiv): {markets.Count}");

            // 3) Master-Trader
            var traders = srcTraders.GetAll();
            foreach (var t in traders)
                dstTraders.Upsert(t);
            Console.WriteLine($"[OK] Master-Trader: {traders.Count}");

            // 4) Copytrading-Account-Settings (mit Fallback auf Alt-Felder)
            int settingsCount = MigrateSettings(accounts, srcSettings, dstSettings, rawAccounts);
            Console.WriteLine($"[OK] Copytrading-Settings: {settingsCount}");

            // 5) Demo-Positionen (reines App-State; Live-Positionen werden aus der Chain rekonstruiert)
            int demoPos = 0;
            foreach (var acc in accounts.Where(a => a.IsDemo))
            {
                foreach (var pos in srcPositions.GetDemo(acc.AccountId))
                {
                    dstPositions.UpsertDemo(acc.AccountId, pos);
                    demoPos++;
                }
            }
            Console.WriteLine($"[OK] Demo-Positionen: {demoPos}");

            Console.WriteLine("=== Migration abgeschlossen ===");
        }

        private static int MigrateSettings(
            List<AccountState> accounts,
            ICopyTradingAccountSettingsRepository src,
            ICopyTradingAccountSettingsRepository dst,
            IMongoCollection<BsonDocument> rawAccounts)
        {
            var existing = src.GetAll().ToDictionary(s => s.AccountId);
            int count = 0;

            foreach (var acc in accounts)
            {
                if (existing.TryGetValue(acc.AccountId, out var s))
                {
                    dst.Upsert(s);
                    count++;
                    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);
                    }
                }
                catch { }

                dst.Upsert(settings);
                count++;
            }

            return count;
        }

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

        private static string Redact(string conn) =>
            System.Text.RegularExpressions.Regex.Replace(conn, "(?i)(password=)[^;]*", "$1***");
    }
}