using System;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Blazored.LocalStorage;
using FrontOffice.BFF.User.Protobuf.Protos.User;
using FrontOffice.BFF.User.Protobuf.Validator;
using FrontOffice.Main.Utilities;
using Grpc.Core;
using Microsoft.AspNetCore.Components;
using Microsoft.AspNetCore.WebUtilities;
using MudBlazor;

namespace FrontOffice.Main.Pages.Auth;

public partial class Verify : IDisposable
{
    private const int DefaultResendCooldown = 120;
    public const int MaxVerificationAttempts = 5;
    private const string OtpPurpose = "Login";
    private const string PhoneStorageKey = "auth:phone-number";
    private const string RedirectStorageKey = "auth:redirect";
    private const string TokenStorageKey = "auth:token";

    private readonly VerifyOtpTokenRequestValidator _requestValidator = new();
    private readonly VerifyOtpTokenRequest _request = new();

    private MudForm? _form;
    private bool _isBusy;
    private string? _phoneNumber;
    private string? _redirect;
    private string? _errorMessage;
    private string? _infoMessage;
    private Timer? _resendTimer;
    private int _resendSeconds;
    private int _attemptsLeft = MaxVerificationAttempts;
    private CancellationTokenSource? _operationCts;

    [Inject] private ILocalStorageService LocalStorage { get; set; } = default!;
    [Inject] private UserContract.UserContractClient UserClient { get; set; } = default!;

    private bool IsVerificationLocked => _attemptsLeft <= 0;

    protected override async Task OnInitializedAsync()
    {
        _request.Purpose = OtpPurpose;
        var uri = Navigation.ToAbsoluteUri(Navigation.Uri);
        var query = QueryHelpers.ParseQuery(uri.Query);
        if (query.TryGetValue("redirect", out var redirectValues))
        {
            _redirect = redirectValues.LastOrDefault();
        }

        if (query.TryGetValue("phone", out var phoneValues))
        {
            _phoneNumber = phoneValues.LastOrDefault();
        }

        if (string.IsNullOrWhiteSpace(_phoneNumber))
        {
            _phoneNumber = await LocalStorage.GetItemAsync<string>(PhoneStorageKey);
        }

        if (string.IsNullOrWhiteSpace(_phoneNumber))
        {
            await ResetAuthenticationAsync();
            Navigation.NavigateTo(RouteConstants.Auth.Phone, forceLoad: true);
            return;
        }

        await LocalStorage.SetItemAsync(PhoneStorageKey, _phoneNumber);

        if (string.IsNullOrWhiteSpace(_redirect))
        {
            var storedRedirect = await LocalStorage.GetItemAsync<string>(RedirectStorageKey);
            if (!string.IsNullOrWhiteSpace(storedRedirect))
            {
                _redirect = storedRedirect;
            }
        }

        ResetResendCountdown();
    }

    private async Task VerifyOtpAsync()
    {
        _errorMessage = null;
        _infoMessage = null;

        if (_form is null)
        {
            return;
        }

        await _form.Validate();
        if (!_form.IsValid)
        {
            return;
        }

        if (IsVerificationLocked)
        {
            _errorMessage = "تعداد تلاش‌های مجاز شما به پایان رسیده است. لطفاً رمز جدید دریافت کنید.";
            return;
        }

        if (string.IsNullOrWhiteSpace(_phoneNumber))
        {
            await ResetAuthenticationAsync();
            Navigation.NavigateTo(RouteConstants.Auth.Phone, forceLoad: true);
            return;
        }

        _isBusy = true;
        var cancellationToken = PrepareOperationToken();

        try
        {
            _request.Mobile = _phoneNumber;
            var validationResult = _requestValidator.Validate(_request);
            if (!validationResult.IsValid)
            {
                _errorMessage = string.Join(" ", validationResult.Errors.Select(e => e.ErrorMessage).Distinct());
                return;
            }

            var metadata = await BuildAuthMetadataAsync();
            var response = metadata is not null
                ? await UserClient.VerifyOtpTokenAsync(_request, metadata, cancellationToken: cancellationToken)
                : await UserClient.VerifyOtpTokenAsync(_request, cancellationToken: cancellationToken);

            if (response is null)
            {
                _errorMessage = "تأیید رمز پویا انجام نشد. لطفاً دوباره تلاش کنید.";
                return;
            }

            ApplyVerificationState(response);

            if (response.Success)
            {
                await PersistTokenAsync(response.Token);
                await LocalStorage.RemoveItemAsync(PhoneStorageKey);
                await LocalStorage.RemoveItemAsync(RedirectStorageKey);

                var target = !string.IsNullOrWhiteSpace(_redirect) ? _redirect : RouteConstants.Main.MainPage;
                Navigation.NavigateTo(target ?? RouteConstants.Main.MainPage, forceLoad: true);
            }
        }
        catch (RpcException rpcEx)
        {
            await HandleVerifyRpcFailureAsync(rpcEx);
        }
        catch (OperationCanceledException)
        {
        }
        catch (Exception ex)
        {
            _errorMessage = ex.Message;
        }
        finally
        {
            _isBusy = false;
            ClearOperationToken();
            await InvokeAsync(StateHasChanged);
        }
    }

    private void ApplyVerificationState(VerifyOtpTokenResponse response)
    {
        if (response.RemainingSeconds > 0)
        {
            StartResendCountdown(response.RemainingSeconds);
        }
        else
        {
            ResetResendCountdown();
        }

        if (response.RemainingAttempts >= 0)
        {
            _attemptsLeft = response.RemainingAttempts;
        }

        if (response.Success)
        {
            _infoMessage = string.IsNullOrWhiteSpace(response.Message)
                ? "ورود با موفقیت انجام شد."
                : response.Message;
        }
        else
        {
            var baseMessage = string.IsNullOrWhiteSpace(response.Message)
                ? "کد وارد شده صحیح نیست."
                : response.Message;

            _errorMessage = _attemptsLeft > 0
                ? $"{baseMessage} {_attemptsLeft} تلاش باقی‌مانده است."
                : $"{baseMessage} تعداد تلاش‌های مجاز شما پایان یافته است. لطفاً رمز جدید دریافت کنید.";
        }
    }

    private async Task HandleVerifyRpcFailureAsync(RpcException rpcEx)
    {
        switch (rpcEx.Status.StatusCode)
        {
            case StatusCode.PermissionDenied:
            case StatusCode.InvalidArgument:
                ApplyVerificationState(new VerifyOtpTokenResponse
                {
                    Success = false,
                    Message = string.IsNullOrWhiteSpace(rpcEx.Status.Detail) ? "کد وارد شده صحیح نیست." : rpcEx.Status.Detail,
                    RemainingAttempts = _attemptsLeft - 1
                });
                break;
            case StatusCode.Unauthenticated:
                await ResetAuthenticationAsync();
                _errorMessage = string.IsNullOrWhiteSpace(rpcEx.Status.Detail)
                    ? "نشست کاربری منقضی شده است. لطفاً دوباره وارد شوید."
                    : rpcEx.Status.Detail;
                Navigation.NavigateTo(RouteConstants.Auth.Phone, forceLoad: true);
                break;
            case StatusCode.DeadlineExceeded:
            case StatusCode.NotFound:
                _errorMessage = "کد منقضی شده است. لطفاً رمز جدید دریافت کنید.";
                break;
            default:
                _errorMessage = !string.IsNullOrWhiteSpace(rpcEx.Status.Detail)
                    ? rpcEx.Status.Detail
                    : "تأیید رمز پویا انجام نشد. لطفاً دوباره تلاش کنید.";
                break;
        }
    }

    private async Task ResendOtpAsync()
    {
        if (_resendSeconds > 0 || _isBusy || string.IsNullOrWhiteSpace(_phoneNumber))
        {
            return;
        }

        _errorMessage = null;
        _infoMessage = null;
        _isBusy = true;
        var cancellationToken = PrepareOperationToken();

        try
        {
            var request = new CreateNewOtpTokenRequest
            {
                Mobile = _phoneNumber,
                Purpose = OtpPurpose
            };

            var metadata = await BuildAuthMetadataAsync();
            var response = metadata is not null
                ? await UserClient.CreateNewOtpTokenAsync(request, metadata, cancellationToken: cancellationToken)
                : await UserClient.CreateNewOtpTokenAsync(request, cancellationToken: cancellationToken);

            if (response?.Success != true)
            {
                _errorMessage = !string.IsNullOrWhiteSpace(response?.Message)
                    ? response!.Message
                    : "ارسال مجدد رمز با خطا مواجه شد.";
            }
            else
            {
                _infoMessage = string.IsNullOrWhiteSpace(response.Message)
                    ? "رمز جدید ارسال شد."
                    : response.Message;
            }

            ApplyResendState(response);
        }
        catch (RpcException rpcEx)
        {
            await HandleResendRpcFailureAsync(rpcEx);
        }
        catch (OperationCanceledException)
        {
        }
        catch (Exception ex)
        {
            _errorMessage = ex.Message;
        }
        finally
        {
            _isBusy = false;
            ClearOperationToken();
            await InvokeAsync(StateHasChanged);
        }
    }

    private async Task HandleResendRpcFailureAsync(RpcException rpcEx)
    {
        switch (rpcEx.Status.StatusCode)
        {
            case StatusCode.Unauthenticated:
                await ResetAuthenticationAsync();
                _errorMessage = string.IsNullOrWhiteSpace(rpcEx.Status.Detail)
                    ? "نشست کاربری منقضی شده است. لطفاً دوباره وارد شوید."
                    : rpcEx.Status.Detail;
                Navigation.NavigateTo(RouteConstants.Auth.Phone, forceLoad: true);
                break;
            default:
                _errorMessage = !string.IsNullOrWhiteSpace(rpcEx.Status.Detail)
                    ? rpcEx.Status.Detail
                    : "ارسال مجدد رمز با خطا مواجه شد.";
                break;
        }
    }

    private void ApplyResendState(CreateNewOtpTokenResponse? response)
    {
        if (response?.RemainingAttempts >= 0)
        {
            _attemptsLeft = response.RemainingAttempts;
        }

        if (response?.RemainingSeconds > 0)
        {
            StartResendCountdown(response.RemainingSeconds);
        }
        else
        {
            StartResendCountdown(DefaultResendCooldown);
        }
    }

    private void StartResendCountdown(int seconds)
    {
        _resendSeconds = seconds;
        _resendTimer?.Dispose();
        _resendTimer = new Timer(_ =>
        {
            var remaining = Interlocked.Decrement(ref _resendSeconds);
            if (remaining <= 0)
            {
                Interlocked.Exchange(ref _resendSeconds, 0);
                _resendTimer?.Dispose();
                _resendTimer = null;
            }

            _ = InvokeAsync(StateHasChanged);
        }, null, 1000, 1000);
    }

    private void ResetResendCountdown()
    {
        _resendTimer?.Dispose();
        _resendTimer = null;
        _resendSeconds = 0;
    }

    private async Task<Metadata?> BuildAuthMetadataAsync()
    {
        var token = await LocalStorage.GetItemAsync<string>(TokenStorageKey);
        if (string.IsNullOrWhiteSpace(token))
        {
            return null;
        }

        return new Metadata
        {
            { "Authorization", $"Bearer {token}" }
        };
    }

    private async Task PersistTokenAsync(string? token)
    {
        if (!string.IsNullOrWhiteSpace(token))
        {
            await LocalStorage.SetItemAsync(TokenStorageKey, token);
        }
        else
        {
            await LocalStorage.RemoveItemAsync(TokenStorageKey);
        }
    }

    private async Task ChangePhoneAsync()
    {
        await LocalStorage.RemoveItemAsync(PhoneStorageKey);
        NavigateBackToPhone();
    }

    private async Task ResetAuthenticationAsync()
    {
        await LocalStorage.RemoveItemAsync(TokenStorageKey);
        await LocalStorage.RemoveItemAsync(PhoneStorageKey);
        await LocalStorage.RemoveItemAsync(RedirectStorageKey);
    }

    private void NavigateBackToPhone()
    {
        var target = RouteConstants.Auth.Phone;
        if (!string.IsNullOrWhiteSpace(_redirect))
        {
            target += "?redirect=" + Uri.EscapeDataString(_redirect);
        }

        Navigation.NavigateTo(target, forceLoad: false);
    }

    private CancellationToken PrepareOperationToken()
    {
        _operationCts?.Cancel();
        _operationCts?.Dispose();
        _operationCts = new CancellationTokenSource();
        return _operationCts.Token;
    }

    private void ClearOperationToken()
    {
        _operationCts?.Dispose();
        _operationCts = null;
    }

    public void Dispose()
    {
        _operationCts?.Cancel();
        _operationCts?.Dispose();
        _resendTimer?.Dispose();
    }
}