@using RackPeek.Domain.Git
@using RackPeek.Domain.Git.UseCases
@inject InitRepoUseCase InitRepo
@inject CommitAllUseCase CommitAll
@inject RestoreAllUseCase RestoreAll
@inject PushUseCase PushUseCase
@inject PullUseCase PullUseCase
@inject AddRemoteUseCase AddRemoteUseCase
@inject IGitRepository GitRepo
@implements IDisposable

@if (_status == GitRepoStatus.NotAvailable)
{
    <div class="flex items-center gap-2 text-sm" data-testid="git-init-indicator">
        @if (_confirmInit)
        {
            <span class="text-zinc-400 text-xs">Enable git tracking?</span>
            <button class="px-2 py-0.5 text-xs rounded bg-emerald-600 hover:bg-emerald-500 text-white transition disabled:opacity-50"
                    disabled="@_isInitializing"
                    data-testid="git-init-confirm"
                    @onclick="InitRepoAsync">
                @(_isInitializing ? "..." : "Yes")
            </button>
            <button class="px-2 py-0.5 text-xs rounded text-zinc-400 hover:text-white transition"
                    data-testid="git-init-cancel"
                    @onclick="() => _confirmInit = false">
                No
            </button>
        }
        else
        {
            <button class="px-2 py-1 text-xs rounded text-zinc-500 hover:text-emerald-400 hover:bg-zinc-800 transition"
                    data-testid="git-init-button"
                    @onclick="() => _confirmInit = true">
                Enable Git
            </button>
        }

        @if (_errorMessage is not null)
        {
            <span class="text-red-400 text-xs" data-testid="git-error">@_errorMessage</span>
        }
    </div>
}
else
{
    <div class="relative flex items-center gap-2 text-sm" data-testid="git-status-indicator">

        @if (!string.IsNullOrEmpty(_branch) && _hasRemote)
        {
            <button class="text-zinc-400 text-xs hover:text-emerald-400 transition"
                    data-testid="git-branch"
                    @onclick="ToggleHistoryAsync">
                @_branch
            </button>
        }

        @if (_status == GitRepoStatus.Clean && _hasRemote)
        {
            <span class="inline-block w-2 h-2 rounded-full bg-emerald-400"
                  data-testid="git-status-dot-clean"
                  title="All changes committed"></span>

            <span class="text-zinc-500 text-xs" data-testid="git-status-text">
                Saved
            </span>
        }
        else if (_status == GitRepoStatus.Dirty && _hasRemote)
        {
            <span class="inline-block w-2 h-2 rounded-full bg-amber-400 animate-pulse"
                  data-testid="git-status-dot-dirty"
                  title="Uncommitted changes"></span>

            <div class="relative flex" data-testid="git-save-group">
                <button class="px-2 py-1 text-xs rounded-l bg-emerald-600 hover:bg-emerald-500 text-white transition disabled:opacity-50"
                        disabled="@(_isBusy || !_hasRemote)"
                        data-testid="git-save-button"
                        @onclick="CommitAsync">
                    @(_isCommitting ? "Saving..." : "Save")
                </button>

                <button class="px-1.5 py-1 text-xs rounded-r bg-emerald-700 hover:bg-emerald-600 text-white transition border-l border-emerald-800 disabled:opacity-50"
                        disabled="@(_isBusy || !_hasRemote)"
                        data-testid="git-save-dropdown"
                        @onclick="ToggleDropdown">
                    &#9662;
                </button>

                @if (_showDropdown)
                {
                    <div class="absolute top-full right-0 mt-1 bg-zinc-800 border border-zinc-700 rounded shadow-lg z-50 min-w-[120px]"
                         data-testid="git-dropdown-menu">

                        <button class="w-full text-left px-3 py-2 text-xs text-zinc-300 hover:bg-zinc-700 hover:text-white transition"
                                data-testid="git-diff-button"
                                @onclick="OpenDiffAsync">
                            Diff
                        </button>

                        @if (!_confirmDiscard)
                        {
                            <button class="w-full text-left px-3 py-2 text-xs text-zinc-400 hover:bg-zinc-700 hover:text-red-400 transition"
                                    data-testid="git-discard-button"
                                    @onclick="() => _confirmDiscard = true">
                                Discard
                            </button>
                        }
                        else
                        {
                            <div class="px-3 py-2 flex items-center gap-2">
                                <span class="text-red-400 text-xs">Sure?</span>

                                <button class="px-2 py-0.5 text-xs rounded bg-red-600 hover:bg-red-500 text-white transition"
                                        data-testid="git-discard-confirm"
                                        @onclick="DiscardAsync">
                                    Yes
                                </button>

                                <button class="px-2 py-0.5 text-xs rounded text-zinc-400 hover:text-white transition"
                                        data-testid="git-discard-cancel"
                                        @onclick="() => _confirmDiscard = false">
                                    No
                                </button>
                            </div>
                        }
                    </div>
                }
            </div>
        }

        @if (!_hasRemote)
        {
            <div class="relative flex items-center gap-1" data-testid="git-remote-group">

                @if (_showAddRemote)
                {
                    <input type="text"
                           class="px-2 py-1 text-xs rounded bg-zinc-800 border border-zinc-700 text-zinc-200 placeholder-zinc-500 w-56 focus:outline-none focus:border-emerald-500"
                           placeholder="https://github.com/user/repo.git"
                           @bind="_remoteUrl"
                           @bind:event="oninput"
                           data-testid="git-remote-url" />

                    <button class="px-2 py-0.5 text-xs rounded bg-emerald-600 hover:bg-emerald-500 text-white transition disabled:opacity-50"
                            disabled="@(string.IsNullOrWhiteSpace(_remoteUrl))"
                            data-testid="git-remote-save"
                            @onclick="AddRemoteAsync">
                        Add
                    </button>

                    <button class="px-2 py-0.5 text-xs rounded text-zinc-400 hover:text-white transition"
                            data-testid="git-remote-cancel"
                            @onclick="CancelAddRemote">
                        &times;
                    </button>
                }
                else
                {
                    <button class="px-2 py-1 text-xs rounded text-zinc-500 hover:text-emerald-400 hover:bg-zinc-800 transition"
                            data-testid="git-add-remote-button"
                            @onclick="() => _showAddRemote = true">
                        Add Remote
                    </button>
                }

                <span class="text-xs text-zinc-500">
                    Connect a remote repository to enable saving and sync.
                </span>
            </div>
        }
        else
        {
            <div class="relative flex" data-testid="git-sync-group">

                <button class="px-2 py-1 text-xs rounded text-zinc-400 hover:text-white hover:bg-zinc-700 transition disabled:opacity-50"
                        disabled="@_isSyncing"
                        data-testid="git-sync-button"
                        @onclick="ToggleSyncAsync">

                    @if (_isFetching)
                    {
                        <span>Checking...</span>
                    }
                    else if (_syncStatus.Ahead > 0 || _syncStatus.Behind > 0)
                    {
                        <span>
                            Sync
                            @if (_syncStatus.Ahead > 0) { <span class="text-emerald-400">↑@_syncStatus.Ahead</span> }
                            @if (_syncStatus.Behind > 0) { <span class="text-blue-400">↓@_syncStatus.Behind</span> }
                        </span>
                    }
                    else
                    {
                        <span>Sync</span>
                    }
                </button>

                @if (_showSyncDropdown)
                {
                    <div class="absolute top-full right-0 mt-1 bg-zinc-800 border border-zinc-700 rounded shadow-lg z-50 min-w-[140px]"
                         data-testid="git-sync-dropdown">

                        <button class="w-full text-left px-3 py-2 text-xs text-zinc-300 hover:bg-zinc-700 hover:text-white transition disabled:opacity-50"
                                disabled="@_isSyncing"
                                data-testid="git-push-button"
                                @onclick="PushAsync">
                            @(_isPushing ? "Pushing..." : "Push")
                        </button>

                        <button class="w-full text-left px-3 py-2 text-xs text-zinc-300 hover:bg-zinc-700 hover:text-white transition disabled:opacity-50"
                                disabled="@(_isSyncing || _syncStatus.Error is not null)"
                                data-testid="git-pull-button"
                                @onclick="PullAsync">
                            @(_isPulling ? "Pulling..." : "Pull")
                        </button>
                    </div>
                }
            </div>
        }

        @if (_errorMessage is not null)
        {
            <span class="text-red-400 text-xs">@_errorMessage</span>
        }
    </div>
}

@code {

    private GitRepoStatus _status = GitRepoStatus.NotAvailable;
    private string _branch = "";
    private bool _isCommitting;
    private bool _isRestoring;
    private bool _confirmDiscard;
    private bool _showDropdown;
    private bool _showAddRemote;
    private bool _showSyncDropdown;
    private bool _showHistory;
    private bool _hasRemote;
    private bool _isFetching;
    private bool _isPushing;
    private bool _isPulling;
    private bool _isInitializing;
    private bool _confirmInit;

    private string? _errorMessage;
    private string _remoteUrl = "";
    private string _diffContent = "";
    private string[] _changedFiles = [];
    private GitLogEntry[] _logEntries = [];

    private PeriodicTimer? _timer;
    private CancellationTokenSource? _cts;

    private GitSyncStatus _syncStatus = new(0,0,false);

    private bool _isBusy => _isCommitting || _isRestoring || _isSyncing;
    private bool _isSyncing => _isPushing || _isPulling || _isFetching;

    protected override async Task OnInitializedAsync()
    {
        _status = GitRepo.GetStatus();

        if (_status == GitRepoStatus.NotAvailable)
            return;

        _branch = GitRepo.GetCurrentBranch();
        _hasRemote = GitRepo.HasRemote();

        _cts = new CancellationTokenSource();
        _timer = new PeriodicTimer(TimeSpan.FromSeconds(15));

        _ = PollStatusAsync(_cts.Token);

        await Task.CompletedTask;
    }

    private async Task PollStatusAsync(CancellationToken ct)
    {
        try
        {
            while (_timer != null && await _timer.WaitForNextTickAsync(ct))
            {
                if (_isBusy)
                    continue;

                var newStatus = GitRepo.GetStatus();

                if (newStatus != _status)
                {
                    _status = newStatus;
                    await InvokeAsync(StateHasChanged);
                }
            }
        }
        catch (OperationCanceledException) {}
    }

    private async Task InitRepoAsync()
    {
        _errorMessage = null;
        _isInitializing = true;

        try
        {
            var error = await InitRepo.ExecuteAsync();
            if (error != null)
            {
                _errorMessage = error;
                return;
            }

            _status = GitRepo.GetStatus();
            _branch = GitRepo.GetCurrentBranch();
            _hasRemote = GitRepo.HasRemote();
        }
        catch (Exception ex)
        {
            _errorMessage = $"Init error: {ex.Message}";
        }
        finally
        {
            _isInitializing = false;
        }
    }

    private void CancelAddRemote()
    {
        _showAddRemote = false;
        _remoteUrl = "";
    }

    private async Task AddRemoteAsync()
    {
        _errorMessage = null;

        try
        {
            var error = await AddRemoteUseCase.ExecuteAsync(_remoteUrl);

            if (error != null)
            {
                _errorMessage = error;
                return;
            }

            _hasRemote = true;
            _showAddRemote = false;
            _remoteUrl = "";

            _syncStatus = GitRepo.FetchAndGetSyncStatus();

            if (_syncStatus.Behind > 0)
                await PullAsync();
        }
        catch (Exception ex)
        {
            _errorMessage = $"Remote error: {ex.Message}";
        }
    }

    private async Task CommitAsync()
    {
        if (!_hasRemote)
        {
            _errorMessage = "Add a remote repository before saving.";
            return;
        }

        _errorMessage = null;
        _isCommitting = true;

        try
        {
            var error = await CommitAll.ExecuteAsync(
                $"rackpeek: save config {DateTime.UtcNow:yyyy-MM-dd HH:mm:ss} UTC");

            if (error != null)
                _errorMessage = error;

            _status = GitRepo.GetStatus();
        }
        catch (Exception ex)
        {
            _errorMessage = $"Commit error: {ex.Message}";
        }
        finally
        {
            _isCommitting = false;
        }
    }

    private void ToggleDropdown()
    {
        _showDropdown = !_showDropdown;
        _showSyncDropdown = false;
    }

    private void ToggleSyncAsync()
    {
        _showSyncDropdown = !_showSyncDropdown;
        _showDropdown = false;

        if (_showSyncDropdown)
        {
            _isFetching = true;

            try
            {
                _syncStatus = GitRepo.FetchAndGetSyncStatus();
            }
            finally
            {
                _isFetching = false;
            }
        }
    }

    private async Task PushAsync()
    {
        if (!_hasRemote)
        {
            _errorMessage = "Add a remote first.";
            return;
        }

        _errorMessage = null;
        _isPushing = true;

        try
        {
            var error = await PushUseCase.ExecuteAsync();

            if (error != null)
                _errorMessage = error;

            _syncStatus = GitRepo.FetchAndGetSyncStatus();
        }
        catch (Exception ex)
        {
            _errorMessage = $"Push error: {ex.Message}";
        }
        finally
        {
            _isPushing = false;
        }
    }

    private async Task PullAsync()
    {
        _errorMessage = null;
        _isPulling = true;

        try
        {
            var error = await PullUseCase.ExecuteAsync();

            if (error != null)
                _errorMessage = error;

            _syncStatus = GitRepo.FetchAndGetSyncStatus();
            _status = GitRepo.GetStatus();
        }
        catch (Exception ex)
        {
            _errorMessage = $"Pull error: {ex.Message}";
        }
        finally
        {
            _isPulling = false;
        }
    }

    public void Dispose()
    {
        _cts?.Cancel();
        _cts?.Dispose();
        _timer?.Dispose();
    }
    
    private void OpenDiffAsync()
    {
        _showDropdown = false;

        try
        {
            _changedFiles = GitRepo.GetChangedFiles();
            _diffContent = GitRepo.GetDiff();
        }
        catch (Exception ex)
        {
            _errorMessage = $"Diff error: {ex.Message}";
        }
    }

    private async Task DiscardAsync()
    {
        _errorMessage = null;
        _isRestoring = true;
        _confirmDiscard = false;
        _showDropdown = false;

        try
        {
            var error = await RestoreAll.ExecuteAsync();

            if (error != null)
                _errorMessage = error;

            _status = GitRepo.GetStatus();
        }
        catch (Exception ex)
        {
            _errorMessage = $"Discard error: {ex.Message}";
        }
        finally
        {
            _isRestoring = false;
        }
    }

    private void ToggleHistoryAsync()
    {
        if (_showHistory)
        {
            _showHistory = false;
            return;
        }

        try
        {
            _logEntries = GitRepo.GetLog(20);
            _showHistory = true;
        }
        catch (Exception ex)
        {
            _errorMessage = $"History error: {ex.Message}";
        }
    }
}