PolyTraderSharp/services/ConfigMigrator.cs

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text.Json;
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 ===");
        }

        /// <summary>
        /// Config-Migration aus mongoexport-JSON (Ordner mit PolyTraderDB.accounts.json /
        /// .trackers.json) → MySQL. Markets bleiben aussen vor (bereits migriert und werden
        /// vom MarketSync ohnehin laufend aktualisiert). Idempotent via Upserts.
        /// </summary>
        public static void RunFromJson(string folder, string mySqlConnection)
        {
            Console.WriteLine("=== Config-Migration JSON-Export -> MySQL ===");
            Console.WriteLine($"Quelle: {folder}");
            Console.WriteLine($"Ziel   (MySQL): {Redact(mySqlConnection)}");

            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);
            ITrackedTraderRepository dstTraders = new EfTrackedTraderRepository(ctFactory);
            ICopyTradingAccountSettingsRepository dstSettings = new EfCopyTradingAccountSettingsRepository(ctFactory);

            // 1) Accounts + Copytrading-Settings (Limit-Felder haengen im Alt-Dokument am Account)
            var accPath = Path.Combine(folder, "PolyTraderDB.accounts.json");
            int accCount = 0, setCount = 0;
            if (File.Exists(accPath))
            {
                using var doc = JsonDocument.Parse(File.ReadAllText(accPath));
                foreach (var el in doc.RootElement.EnumerateArray())
                {
                    var acc = new AccountState
                    {
                        AccountId = el.GetProperty("_id").GetInt32(),
                        Name = Str(el, "Name"),
                        WalletAddress = Str(el, "WalletAddress"),
                        ApiKey = Str(el, "ApiKey"),
                        ApiSecret = Str(el, "ApiSecret"),
                        ApiPassphrase = Str(el, "ApiPassphrase"),
                        PrivateKey = Str(el, "PrivateKey"),
                        IsDemo = Bool(el, "IsDemo"),
                        IsActive = Bool(el, "IsActive", true),
                        CloseOnlyMode = Bool(el, "CloseOnlyMode"),
                        PayoutAddress = Str(el, "PayoutAddress"),
                        PayoutLimitUsd = Dec(el, "PayoutLimitUsd", 0m),
                        TotalBalance = Dec(el, "TotalBalance", 0m),
                        AvailableBalance = Dec(el, "AvailableBalance", 0m),
                        HasOpenLimitOrders = Bool(el, "HasOpenLimitOrders")
                    };
                    dstAccounts.Upsert(acc);
                    accCount++;

                    var s = new CopyTradingAccountSettings
                    {
                        AccountId = acc.AccountId,
                        PerMarketLimit = Dec(el, "PerMarketLimit", 5.0m),
                        MaxPriceDifference = Dec(el, "MaxPriceDifference", 2.0m),
                        MaxBuyPrice = Dec(el, "MaxBuyPrice", 0.98m),
                        ProfitTarget = Dec(el, "ProfitTarget", 50.0m),
                        PreRedeemLimit = Dec(el, "PreRedeemLimit", 0.0m),
                        PerMasterLimit = Dec(el, "PerMasterLimit", 10.0m),
                        perMaxTime6h = Dec(el, "perMaxTime6h", 20.0m),
                        perMaxTime24h = Dec(el, "perMaxTime24h", 20.0m),
                        perMaxTime72h = Dec(el, "perMaxTime72h", 20.0m),
                        perMaxTimeNone = Dec(el, "perMaxTimeNone", 40.0m)
                    };
                    dstSettings.Upsert(s);
                    setCount++;
                }
            }
            else
            {
                Console.WriteLine($"[WARN] Nicht gefunden: {accPath}");
            }
            Console.WriteLine($"[OK] Accounts: {accCount} | Copytrading-Settings: {setCount}");

            // 2) Master-Trader
            var trPath = Path.Combine(folder, "PolyTraderDB.trackers.json");
            int trCount = 0;
            if (File.Exists(trPath))
            {
                using var doc = JsonDocument.Parse(File.ReadAllText(trPath));
                foreach (var el in doc.RootElement.EnumerateArray())
                {
                    var t = new TrackedTrader
                    {
                        Id = el.GetProperty("_id").GetInt32(),
                        WalletAddress = Str(el, "WalletAddress"),
                        DisplayName = Str(el, "DisplayName"),
                        Category = Str(el, "Category", "NEW_BIG_BET"),
                        Description = Str(el, "Description"),
                        Reasoning = Str(el, "Reasoning"),
                        IsActive = Bool(el, "IsActive", true),
                        IsHidden = Bool(el, "IsHidden"),
                        TotalTrades = Int(el, "TotalTrades"),
                        WinningTrades = Int(el, "WinningTrades"),
                        Winrate30t = Dbl(el, "Winrate30t"),
                        TotalPnl = Dbl(el, "TotalPnl"),
                        AssignedAccountIds = IntSet(el, "AssignedAccountIds")
                    };
                    dstTraders.Upsert(t);
                    trCount++;
                }
            }
            else
            {
                Console.WriteLine($"[WARN] Nicht gefunden: {trPath}");
            }
            Console.WriteLine($"[OK] Master-Trader: {trCount}");
            Console.WriteLine("[INFO] Markets uebersprungen (bereits migriert / MarketSync aktualisiert laufend).");
            Console.WriteLine("=== Migration abgeschlossen ===");
        }

        // --- JSON-Helfer (mongoexport: Dezimalwerte als Strings, null moeglich) ---
        private static string Str(JsonElement el, string name, string fallback = "")
        {
            if (el.TryGetProperty(name, out var v) && v.ValueKind == JsonValueKind.String)
                return v.GetString() ?? fallback;
            return fallback;
        }

        private static bool Bool(JsonElement el, string name, bool fallback = false)
        {
            if (el.TryGetProperty(name, out var v))
            {
                if (v.ValueKind == JsonValueKind.True) return true;
                if (v.ValueKind == JsonValueKind.False) return false;
            }
            return fallback;
        }

        private static int Int(JsonElement el, string name, int fallback = 0)
        {
            if (el.TryGetProperty(name, out var v))
            {
                if (v.ValueKind == JsonValueKind.Number && v.TryGetInt32(out var n)) return n;
                if (v.ValueKind == JsonValueKind.String && int.TryParse(v.GetString(), NumberStyles.Any, CultureInfo.InvariantCulture, out var s)) return s;
            }
            return fallback;
        }

        private static double Dbl(JsonElement el, string name, double fallback = 0)
        {
            if (el.TryGetProperty(name, out var v))
            {
                if (v.ValueKind == JsonValueKind.Number && v.TryGetDouble(out var n)) return n;
                if (v.ValueKind == JsonValueKind.String && double.TryParse(v.GetString(), NumberStyles.Any, CultureInfo.InvariantCulture, out var s)) return s;
            }
            return fallback;
        }

        private static decimal Dec(JsonElement el, string name, decimal fallback)
        {
            if (el.TryGetProperty(name, out var v))
            {
                if (v.ValueKind == JsonValueKind.Number && v.TryGetDecimal(out var n)) return n;
                if (v.ValueKind == JsonValueKind.String && decimal.TryParse(v.GetString(), NumberStyles.Any, CultureInfo.InvariantCulture, out var s)) return s;
            }
            return fallback;
        }

        private static HashSet<int> IntSet(JsonElement el, string name)
        {
            var set = new HashSet<int>();
            if (el.TryGetProperty(name, out var v) && v.ValueKind == JsonValueKind.Array)
            {
                foreach (var item in v.EnumerateArray())
                {
                    if (item.ValueKind == JsonValueKind.Number && item.TryGetInt32(out var n)) set.Add(n);
                    else if (item.ValueKind == JsonValueKind.String && int.TryParse(item.GetString(), NumberStyles.Any, CultureInfo.InvariantCulture, out var s)) set.Add(s);
                }
            }
            return set;
        }

        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***");
    }
}