using System.Net.Http.Headers;
using System.Text;
using Managing.Api.Models.Requests;
using Managing.Application.Abstractions;
using Managing.Application.Abstractions.Services;
using Managing.Application.Shared;
using Managing.Application.Trading.Commands;
using Managing.Domain.MoneyManagements;
using Managing.Domain.Trades;
using Managing.Infrastructure.Evm.Models.Privy;
using MediatR;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using static Managing.Common.Enums;

namespace Managing.Api.Controllers;

/// <summary>
/// Controller for trading operations such as opening and closing positions, and retrieving trade information.
/// Requires authorization for access.
/// </summary>
[ApiController]
[Authorize]
[Route("[controller]")]
public class TradingController : BaseController
{
    private readonly ICommandHandler<OpenPositionRequest, Position> _openTradeCommandHandler;
    private readonly ICommandHandler<ClosePositionCommand, Position> _closeTradeCommandHandler;
    private readonly ITradingService _tradingService;
    private readonly IMoneyManagementService _moneyManagementService;
    private readonly IMediator _mediator;
    private readonly ILogger<TradingController> _logger;
    private readonly IAdminConfigurationService _adminService;
    private readonly IAccountService _accountService;
    private readonly IHttpClientFactory _httpClientFactory;
    private readonly IConfiguration _configuration;

    /// <summary>
    /// Initializes a new instance of the <see cref="TradingController"/> class.
    /// </summary>
    /// <param name="logger">Logger for logging information.</param>
    /// <param name="openTradeCommandHandler">Command handler for opening trades.</param>
    /// <param name="closeTradeCommandHandler">Command handler for closing trades.</param>
    /// <param name="tradingService">Service for trading operations.</param>
    /// <param name="mediator">Mediator for handling commands and requests.</param>
    /// <param name="adminService">Service for checking admin privileges.</param>
    /// <param name="accountService">Service for account operations.</param>
    /// <param name="httpClientFactory">HTTP client factory for making web requests.</param>
    /// <param name="configuration">Application configuration.</param>
    public TradingController(
        ILogger<TradingController> logger,
        ICommandHandler<OpenPositionRequest, Position> openTradeCommandHandler,
        ICommandHandler<ClosePositionCommand, Position> closeTradeCommandHandler,
        ITradingService tradingService,
        IMediator mediator, IMoneyManagementService moneyManagementService,
        IUserService userService, IAdminConfigurationService adminService,
        IAccountService accountService,
        IHttpClientFactory httpClientFactory,
        IConfiguration configuration) : base(userService)
    {
        _logger = logger;
        _openTradeCommandHandler = openTradeCommandHandler;
        _closeTradeCommandHandler = closeTradeCommandHandler;
        _tradingService = tradingService;
        _mediator = mediator;
        _moneyManagementService = moneyManagementService;
        _adminService = adminService;
        _accountService = accountService;
        _httpClientFactory = httpClientFactory;
        _configuration = configuration;
    }


    /// <summary>
    /// Retrieves a specific trade by account name, ticker, and exchange order ID.
    /// </summary>
    /// <param name="accountName">The name of the account.</param>
    /// <param name="ticker">The ticker symbol of the trade.</param>
    /// <param name="exchangeOrderId">The exchange order ID of the trade.</param>
    /// <returns>The requested trade.</returns>
    [HttpGet("GetTrade")]
    public async Task<ActionResult<Trade>> GetTrade(string accountName, Ticker ticker, string exchangeOrderId)
    {
        var result = await _mediator.Send(new GetTradeCommand(accountName, exchangeOrderId, ticker));
        return Ok(result);
    }

    /// <summary>
    /// Retrieves a list of trades for a given account and ticker.
    /// </summary>
    /// <param name="accountName">The name of the account.</param>
    /// <param name="ticker">The ticker symbol of the trades.</param>
    /// <returns>A list of trades.</returns>
    [HttpGet("GetTrades")]
    public async Task<ActionResult<Trade>> GetTrades(string accountName, Ticker ticker)
    {
        var result = await _mediator.Send(new GetTradesCommand(ticker, accountName));
        return Ok(result);
    }

    /// <summary>
    /// Closes a position identified by its unique identifier.
    /// </summary>
    /// <param name="identifier">The unique identifier of the position to close.</param>
    /// <returns>The closed position.</returns>
    [HttpPost("ClosePosition")]
    public async Task<ActionResult<Position>> ClosePosition(Guid identifier)
    {
        var position = await _tradingService.GetPositionByIdentifierAsync(identifier);

        var result = await _closeTradeCommandHandler.Handle(new ClosePositionCommand(position, position.AccountId));
        return Ok(result);
    }

    /// <summary>
    /// Opens a new position based on the provided parameters.
    /// </summary>
    /// <param name="accountName">The name of the account to open the position for.</param>
    /// <param name="moneyManagementName">The name of the money management strategy to use.</param>
    /// <param name="direction">The direction of the trade (Buy or Sell).</param>
    /// <param name="ticker">The ticker symbol for the trade.</param>
    /// <param name="riskLevel">The risk level for the trade.</param>
    /// <param name="isForPaperTrading">Indicates whether the trade is for paper trading.</param>
    /// <param name="moneyManagement">The money management strategy details (optional).</param>
    /// <param name="openPrice">The opening price for the trade (optional).</param>
    /// <returns>The opened position.</returns>
    [HttpPost("OpenPosition")]
    public async Task<ActionResult<Position>> Trade(
        string accountName,
        string moneyManagementName,
        TradeDirection direction,
        Ticker ticker,
        RiskLevel riskLevel,
        bool isForPaperTrading,
        MoneyManagement? moneyManagement = null,
        decimal? openPrice = null)
    {
        if (string.IsNullOrEmpty(accountName))
        {
            throw new ArgumentException($"'{nameof(accountName)}' cannot be null or empty.", nameof(accountName));
        }

        if (string.IsNullOrEmpty(moneyManagementName) && moneyManagement == null)
        {
            throw new ArgumentException($"'{nameof(moneyManagementName)}' cannot be null or empty.",
                nameof(moneyManagementName));
        }

        var user = await GetUser();
        if (moneyManagement != null)
        {
            moneyManagement = await _moneyManagementService.GetMoneyMangement(user, moneyManagementName);
        }

        var command = new OpenPositionRequest(
            accountName,
            moneyManagement,
            direction,
            ticker,
            PositionInitiator.User,
            DateTime.UtcNow,
            user,
            100m, // Default trading balance for user-initiated trades
            isForPaperTrading: isForPaperTrading,
            price: openPrice);
        var result = await _openTradeCommandHandler.Handle(command);
        return Ok(result);
    }

    /// <summary>
    /// Initializes a Privy wallet address for the user.
    /// Only admins can initialize any address, regular users can only initialize their own addresses.
    /// </summary>
    /// <param name="publicAddress">The public address of the Privy wallet to initialize.</param>
    /// <returns>The initialization response containing success status and transaction hashes.</returns>
    [HttpPost("InitPrivyWallet")]
    public async Task<ActionResult<PrivyInitAddressResponse>> InitPrivyWallet([FromBody] string publicAddress)
    {
        if (string.IsNullOrEmpty(publicAddress))
        {
            return BadRequest("Public address cannot be null or empty.");
        }

        try
        {
            var user = await GetUser();
            if (user == null)
            {
                return Unauthorized("User not found");
            }

            // Check if user has permission to initialize this address
            if (!await CanUserInitializeAddress(user.Name, publicAddress))
            {
                return Forbid(
                    "You don't have permission to initialize this wallet address. You can only initialize your own wallet addresses.");
            }

            var result = await _tradingService.InitPrivyWallet(publicAddress, TradingExchanges.GmxV2);
            return Ok(result);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error initializing Privy wallet address: {Address}", publicAddress);
            return StatusCode(500, new PrivyInitAddressResponse
            {
                Success = false,
                Error = "An error occurred while initializing the Privy wallet address."
            });
        }
    }

    /// <summary>
    /// Checks if the user can initialize the given public address.
    /// Admins can initialize any address, regular users can only initialize their own addresses.
    /// </summary>
    /// <param name="userName">The username to check</param>
    /// <param name="publicAddress">The public address to initialize</param>
    /// <returns>True if the user can initialize the address, false otherwise</returns>
    private async Task<bool> CanUserInitializeAddress(string userName, string publicAddress)
    {
        // Admin users can initialize any address
        if (await _adminService.IsUserAdminAsync(userName))
        {
            _logger.LogInformation("Admin user {UserName} initializing address {Address}", userName, publicAddress);
            return true;
        }

        try
        {
            // Regular users can only initialize their own addresses
            // Check if the address belongs to one of the user's accounts
            var account = await _accountService.GetAccountByKey(publicAddress, true, false);

            if (account?.User?.Name == userName)
            {
                _logger.LogInformation("User {UserName} initializing their own address {Address}", userName,
                    publicAddress);
                return true;
            }

            _logger.LogWarning("User {UserName} attempted to initialize address {Address} that doesn't belong to them",
                userName, publicAddress);
            return false;
        }
        catch (Exception ex)
        {
            _logger.LogWarning(ex, "Unable to verify ownership of address {Address} for user {UserName}", publicAddress,
                userName);
            return false;
        }
    }

    /// <summary>
    /// Submits a request for a new indicator to be developed via N8n webhook.
    /// </summary>
    /// <param name="request">The indicator request details including name, strategy, documentation, and requester information.</param>
    /// <returns>A success response indicating the request was submitted.</returns>
    [HttpPost("RequestIndicator")]
    public async Task<ActionResult<object>> RequestIndicator([FromBody] IndicatorRequestDto request)
    {
        if (request == null)
        {
            return BadRequest("Request cannot be null.");
        }

        if (string.IsNullOrWhiteSpace(request.IndicatorName))
        {
            return BadRequest("Indicator name is required.");
        }

        if (string.IsNullOrWhiteSpace(request.StrategyDescription))
        {
            return BadRequest("Strategy is required.");
        }

        if (string.IsNullOrWhiteSpace(request.RequesterName))
        {
            return BadRequest("Requester name is required.");
        }

        try
        {
            var webhookUrl = _configuration["N8n:IndicatorRequestWebhookUrl"];

            if (string.IsNullOrEmpty(webhookUrl))
            {
                _logger.LogError("N8n indicator request webhook URL is not configured");
                return StatusCode(500, new { Success = false, Error = "Webhook URL is not configured." });
            }

            var httpClient = _httpClientFactory.CreateClient();

            // Add basic authentication if credentials are provided
            var username = _configuration["N8n:Username"];
            var password = _configuration["N8n:Password"];
            
            if (!string.IsNullOrEmpty(username) && !string.IsNullOrEmpty(password))
            {
                var credentials = Convert.ToBase64String(Encoding.UTF8.GetBytes($"{username}:{password}"));
                httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", credentials);
            }

            _logger.LogInformation(
                "Submitting indicator request: {IndicatorName} - {Strategy} by {Requester}",
                request.IndicatorName,
                request.StrategyDescription,
                request.RequesterName);

            // Send as JSON payload
            var response = await httpClient.PostAsJsonAsync(webhookUrl, request);

            if (response.IsSuccessStatusCode)
            {
                _logger.LogInformation(
                    "Successfully submitted indicator request: {IndicatorName} by {Requester}",
                    request.IndicatorName,
                    request.RequesterName);

                return Ok(new
                {
                    Success = true,
                    Message = "Indicator request submitted successfully.",
                    IndicatorName = request.IndicatorName,
                    Strategy = request.StrategyDescription,
                    Requester = request.RequesterName
                });
            }
            else
            {
                var responseContent = await response.Content.ReadAsStringAsync();
                _logger.LogError(
                    "Failed to submit indicator request. Status: {StatusCode}, Response: {Response}",
                    response.StatusCode,
                    responseContent);

                return StatusCode(500, new
                {
                    Success = false,
                    Error = $"Failed to submit indicator request. Status: {response.StatusCode}"
                });
            }
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error submitting indicator request: {IndicatorName}", request.IndicatorName);
            return StatusCode(500, new
            {
                Success = false,
                Error = "An error occurred while submitting the indicator request."
            });
        }
    }
}