using System;
using System.Threading;
using System.Threading.Tasks;
using System.Timers;
using FinlyticCore.Dtos.TradeRepublic;
using FinlyticCore.Models.Assets;
using FinlyticCore.Models.Settings;

namespace FinlyticCore.Services.TradeRepublic;

/// <summary>
/// Service for interacting with the Trade Republic API.
/// </summary>
public interface ITradeRepublicService
{
    /// <summary>
    /// Fetches asset metadata from Trade Republic by ISIN.
    /// </summary>
    Task<TradeRepublicAssetResponse?> GetAsset(string isin, CancellationToken cancellationToken = default);

    /// <summary>
    /// Retrieves the total count of available assets grouped by their types.
    /// </summary>
    Task<AssetsCount> GetAssetsCount(CancellationToken cancellationToken = default);

    /// <summary>
    /// Retrieves a paginated chunk of assets filtered by a specific type.
    /// </summary>
    Task<TradeRepublicAssetResponse?> GetAssets(AssetType type, int page, int pageSize, CancellationToken cancellationToken = default);

    /// <summary>
    /// Subscribes to the real-time ticker stream for a specific ISIN.
    /// </summary>
    Task<int?> SubscribeRealtimeTickerAsync(string isin, Action<TradeRepublicTickerResponse> onTick, CancellationToken cancellationToken = default);

    /// <summary>
    /// Unsubscribes from a real-time ticker stream.
    /// </summary>
    Task UnsubscribeRealtimeTickerAsync(int subId);

    /// <summary>
    /// Fetches stock details (company description, events, earnings, analyst ratings) for a specific ISIN.
    /// </summary>
    Task<TradeRepublicStockDetailsResponse?> GetStockDetailsAsync(string isin, CancellationToken cancellationToken = default);

    /// <summary>
    /// Fetches derivative products (KnockOuts, Warrants, Factor Certificates) for an underlying ISIN.
    /// </summary>
    Task<TradeRepublicDerivativesResponse?> GetDerivativesAsync(TradeRepublicDerivativesRequest request, CancellationToken cancellationToken = default);
}

public class TradeRepublicService : ITradeRepublicService, IDisposable
{
    private readonly TradeRepublicClient _client;
    private readonly IFinlyticLogger<TradeRepublicService> _finlyticLogger;
    private readonly System.Timers.Timer _inactivityTimer;
    private readonly SemaphoreSlim _lock = new(1, 1);

    public TradeRepublicService(TradeRepublicClient client, IFinlyticLogger<TradeRepublicService> finlyticLogger)
    {
        _client = client;
        _finlyticLogger = finlyticLogger;

        _inactivityTimer = new System.Timers.Timer(TimeSpan.FromSeconds(461).TotalMilliseconds);
        _inactivityTimer.AutoReset = false;
        _inactivityTimer.Elapsed += OnInactivityTimeout;
    }

    private async Task EnsureConnectedAsync()
    {
        await _lock.WaitAsync();
        try
        {
            _inactivityTimer.Stop();
            if (!_client.IsConnected)
            {
                await _finlyticLogger.LogInfoAsync(CoreSettingKeys.TradeRepublicChannel, "[TradeRepublicService] Connecting to Trade Republic API WebSocket...");
                bool connected = await _client.InitAsync();
                if (!connected)
                {
                    await _finlyticLogger.LogWarningAsync(CoreSettingKeys.TradeRepublicChannel, "[TradeRepublicService] Trade Republic WebSocket connection failed or timed out.");
                    throw new InvalidOperationException("Trade Republic WebSocket is not connected.");
                }
                await _finlyticLogger.LogInfoAsync(CoreSettingKeys.TradeRepublicChannel, "[TradeRepublicService] Successfully connected to Trade Republic API.");
            }
            _inactivityTimer.Start();
        }
        finally
        {
            _lock.Release();
        }
    }

    /// <inheritdoc />
    public async Task<TradeRepublicAssetResponse?> GetAsset(string isin, CancellationToken cancellationToken = default)
    {
        try
        {
            await EnsureConnectedAsync();
            var reqData = new TradeRepublicSearchData
            {
                Query = isin,
                Page = 1,
                PageSize = 1,
                Filter = new[] { new TradeRepublicFilter("jurisdiction", "DE") }
            };
            var request = new TradeRepublicSearchRequest(Data: reqData);
            return await _client.SendRequestAsync<TradeRepublicAssetResponse, TradeRepublicSearchRequest>(request, cancellationToken);
        }
        catch (Exception ex)
        {
            await _finlyticLogger.LogErrorAsync(CoreSettingKeys.TradeRepublicChannel, ex, "[TradeRepublicService] Error while fetching asset metadata for ISIN {Isin}", isin);
            return null;
        }
    }

    /// <inheritdoc />
    public async Task<AssetsCount> GetAssetsCount(CancellationToken cancellationToken = default)
    {
        await EnsureConnectedAsync();
        var counts = new AssetsCount();
        foreach (var type in Enum.GetValues<AssetType>())
        {
            var reqData = new TradeRepublicSearchData
            {
                Query = "",
                Page = 1,
                PageSize = 1,
                Filter = new[]
                {
                    new TradeRepublicFilter("type", type.ToString().ToLowerInvariant()),
                    new TradeRepublicFilter("jurisdiction", "DE")
                }
            };
            var request = new TradeRepublicSearchRequest(Data: reqData);
            var response = await _client.SendRequestAsync<TradeRepublicAssetResponse, TradeRepublicSearchRequest>(request, cancellationToken);
            var count = response?.ResultCount ?? 0;
            counts.SetCountOfType(type, count);
            await Task.Delay(TimeSpan.FromMilliseconds(320), cancellationToken);
        }
        return counts;
    }

    /// <inheritdoc />
    public async Task<TradeRepublicAssetResponse?> GetAssets(AssetType type, int page, int pageSize, CancellationToken cancellationToken = default)
    {
        await EnsureConnectedAsync();
        var reqData = new TradeRepublicSearchData
        {
            Query = "",
            Page = page,
            PageSize = pageSize,
            Filter = new[]
            {
                new TradeRepublicFilter("type", type.ToString().ToLowerInvariant()),
                new TradeRepublicFilter("jurisdiction", "DE")
            }
        };
        var request = new TradeRepublicSearchRequest(Data: reqData);
        return await _client.SendRequestAsync<TradeRepublicAssetResponse, TradeRepublicSearchRequest>(request, cancellationToken);
    }

    /// <inheritdoc />
    public async Task<int?> SubscribeRealtimeTickerAsync(string isin, Action<TradeRepublicTickerResponse> onTick, CancellationToken cancellationToken = default)
    {
        await EnsureConnectedAsync();
        return await _client.SubscribeTickerAsync(isin, onTick, cancellationToken);
    }

    /// <inheritdoc />
    public async Task UnsubscribeRealtimeTickerAsync(int subId)
    {
        await _client.UnsubscribeTickerAsync(subId);
    }

    /// <inheritdoc />
    public async Task<TradeRepublicStockDetailsResponse?> GetStockDetailsAsync(string isin, CancellationToken cancellationToken = default)
    {
        try
        {
            await EnsureConnectedAsync();
            var req = new TradeRepublicStockDetailsRequest(Id: isin);
            return await _client.SendRequestAsync<TradeRepublicStockDetailsResponse, TradeRepublicStockDetailsRequest>(req, cancellationToken);
        }
        catch (Exception ex)
        {
            await _finlyticLogger.LogErrorAsync(CoreSettingKeys.TradeRepublicChannel, ex, "[TradeRepublicService] Error while fetching stock details for ISIN {Isin}", isin);
            return null;
        }
    }

    /// <inheritdoc />
    public async Task<TradeRepublicDerivativesResponse?> GetDerivativesAsync(TradeRepublicDerivativesRequest request, CancellationToken cancellationToken = default)
    {
        try
        {
            await EnsureConnectedAsync();
            return await _client.SendRequestAsync<TradeRepublicDerivativesResponse, TradeRepublicDerivativesRequest>(request, cancellationToken);
        }
        catch (Exception ex)
        {
            await _finlyticLogger.LogErrorAsync(CoreSettingKeys.TradeRepublicChannel, ex, "[TradeRepublicService] Error while fetching derivatives for underlying {Underlying}", request.Underlying);
            return null;
        }
    }

    private async void OnInactivityTimeout(object? sender, ElapsedEventArgs e)
    {
        try
        {
            await _lock.WaitAsync();
            if (!_client.IsConnected) return;
            await _finlyticLogger.LogInfoAsync(CoreSettingKeys.TradeRepublicChannel, "[TradeRepublicService] Inactivity timer expired. Auto-disconnecting Trade Republic WebSocket.");
            await _client.DisconnectAsync();
        }
        catch { }
        finally { _lock.Release(); }
    }

    public void Dispose()
    {
        _inactivityTimer.Dispose();
        _lock.Dispose();
        GC.SuppressFinalize(this);
    }
}