@page "/tasks/taskssheet/{tasksSheetId}"
@using Tasks.Module.Models
@using Tasks.Module.Services
@inject IFolderService FolderService
@inject ITodoService TodoService
@inject IDialogService Dialog

<div class="min-h-screen bg-gradient-to-br from-slate-50 to-slate-100">
    <div class="max-w-4xl mx-auto py-8 px-4">
        @* Header *@
        <div class="mb-8">
            <MudButton StartIcon="@Icons.Material.Filled.ArrowBack" Href="/tasks" Color="Color.Default" Class="mb-4">
                Back to Tasks
            </MudButton>
            <h1 class="text-3xl font-bold text-slate-800">@_tasksSheetName</h1>
            <p class="text-slate-500 mt-1">Manage tasks in this sheet</p>
        </div>

        @* Quick Add Input *@
        <div class="bg-white rounded-2xl shadow-lg p-4 mb-6">
            <div class="flex items-center gap-3">
                <div class="flex-shrink-0 w-10 h-10 bg-indigo-100 rounded-full flex items-center justify-center">
                    <MudIcon Icon="@Icons.Material.Filled.Add" Color="Color.Primary" Size="Size.Small" />
                </div>
                <MudTextField T="string" 
                              @bind-Value:get="quickAddTitle"
                              @bind-Value:set="(v) => { quickAddTitle = v; StateHasChanged(); }"
                              Placeholder="Add a task... (press Enter)"
                              DisableUnderLine="true"
                              Class="flex-grow"
                              Adornment="Adornment.None" 
                              OnKeyDown="HandleQuickAdd" />
                <MudButton Variant="Variant.Filled" 
                          Color="Color.Primary" 
                          OnClick="QuickAddTask"
                          Class="rounded-xl">
                    Add
                </MudButton>
                <MudButton Variant="Variant.Outlined" 
                          Color="Color.Primary" 
                          StartIcon="@Icons.Material.Filled.Add"
                          OnClick="OpenCreateDialog"
                          Class="rounded-xl">
                    Add Task
                </MudButton>
            </div>
        </div>

        @* Tasks List *@
        @if (_loading)
        {
            <div class="flex justify-center py-12">
                <MudProgressLinear Color="Color.Primary" Indeterminate="true" />
            </div>
        }
        else if (!_tasksSheetFound)
        {
            <div class="bg-white rounded-2xl shadow-lg p-12 text-center">
                <h3 class="text-lg font-semibold text-slate-700">Tasks sheet not found</h3>
                <MudButton Href="/tasks" Color="Color.Primary" Class="mt-4">Go to Tasks</MudButton>
            </div>
        }
        else
        {
            <div class="space-y-3">
                @foreach (var task in _tasks)
                {
                    <TaskCard Task="task" 
                              OnToggle="ToggleTask" 
                              OnDelete="DeleteTask" 
                              OnUpdate="OpenUpdateDialog"
                              OnAddChild="OpenAddChildDialog"
                              CollapsedTasks="collapsedTasks"
                              ToggleCollapse="ToggleCollapse" />
                }
            </div>
        }
    </div>
</div>

@code {
    [Parameter] public string tasksSheetId { get; set; } = string.Empty;
    
    private string _tasksSheetName = string.Empty;
    private bool _loading = true;
    private bool _tasksSheetFound = false;
    private CreateTodoItemDto editTask = new();
    private string currentTaskId = string.Empty;
    private string quickAddTitle = string.Empty;
    private HashSet<string> collapsedTasks = new();
    private List<TodoItemDto> _tasks = new();
    private string _lastTasksSheetId = string.Empty;

    protected override async Task OnInitializedAsync()
    {
        await LoadTasksSheet();
    }

    protected override async Task OnParametersSetAsync()
    {
        if (tasksSheetId != _lastTasksSheetId)
        {
            _lastTasksSheetId = tasksSheetId;
            collapsedTasks.Clear();
            await LoadTasksSheet();
        }
    }

    private async Task LoadTasksSheet()
    {
        _loading = true;
        try
        {
            var tasksSheet = await FolderService.GetTasksSheetByIdAsync(tasksSheetId);
            if (tasksSheet != null)
            {
                _tasksSheetName = tasksSheet.Title;
                _tasks = tasksSheet.Tasks;
                _tasksSheetFound = true;
            }
            else
            {
                _tasksSheetFound = false;
            }
        }
        finally
        {
            _loading = false;
        }
    }

    private async Task HandleQuickAdd(KeyboardEventArgs e)
    {
        if (e.Key == "Enter" && !string.IsNullOrWhiteSpace(quickAddTitle))
        {
            await QuickAddTask();
        }
    }

    private async Task QuickAddTask()
    {
        if (string.IsNullOrWhiteSpace(quickAddTitle))
            return;

        var newTask = new CreateTodoItemDto
        {
            Title = quickAddTitle.Trim(),
            Priority = 0,
            ParentId = null
        };

        await FolderService.AddTaskToTasksSheetAsync(tasksSheetId, newTask);
        quickAddTitle = string.Empty;
        await LoadTasksSheet();
    }

    private void ToggleCollapse(string taskId)
    {
        if (collapsedTasks.Contains(taskId))
            collapsedTasks.Remove(taskId);
        else
            collapsedTasks.Add(taskId);
    }

    private async Task ToggleTask(string id)
    {
        await FolderService.ToggleTaskInTasksSheetAsync(id);
        await LoadTasksSheet();
    }

    private async Task DeleteTask(string id)
    {
        await FolderService.DeleteTaskInTasksSheetAsync(id);
        await LoadTasksSheet();
    }

    private async Task OpenCreateDialog()
    {
        editTask = new CreateTodoItemDto();
        
        var parameters = new DialogParameters<CreateTaskDialog> 
        { 
            { x => x.Task, editTask },
            { x => x.IsUpdate, false }
        };
        
        var options = new DialogOptions { CloseOnEscapeKey = true, MaxWidth = MaxWidth.Small, FullWidth = true };
        var dialog = await Dialog.ShowAsync<CreateTaskDialog>("Create Task", parameters, options);
        var result = await dialog.Result;
        
        if (result is { Canceled: false })
        {
            await FolderService.AddTaskToTasksSheetAsync(tasksSheetId, editTask);
            await LoadTasksSheet();
        }
    }

    private async Task OpenAddChildDialog(TodoItemDto parentTask)
    {
        editTask = new CreateTodoItemDto { ParentId = parentTask.Id };
        
        var parameters = new DialogParameters<CreateTaskDialog> 
        { 
            { x => x.Task, editTask },
            { x => x.IsUpdate, false },
            { x => x.IsChild, true },
            { x => x.ParentTitle, parentTask.Title }
        };
        
        var options = new DialogOptions { CloseOnEscapeKey = true, MaxWidth = MaxWidth.Small, FullWidth = true };
        var dialog = await Dialog.ShowAsync<CreateTaskDialog>("Add Sub-task", parameters, options);
        var result = await dialog.Result;
        
        if (result is { Canceled: false })
        {
            await LoadTasksSheet();
        }
    }

    private async Task OpenUpdateDialog(TodoItemDto task)
    {
        currentTaskId = task.Id;
        editTask = new CreateTodoItemDto
        {
            Title = task.Title,
            Description = task.Description,
            Priority = task.Priority,
            DueDate = task.DueDate,
            ParentId = task.ParentId,
            CategoryId = task.CategoryId,
            TagIds = task.TagIds.ToList(),
            FileId = task.FileId
        };
        
        var parameters = new DialogParameters<CreateTaskDialog> 
        { 
            { x => x.Task, editTask },
            { x => x.IsUpdate, true }
        };
        
        var options = new DialogOptions { CloseOnEscapeKey = true, MaxWidth = MaxWidth.Small, FullWidth = true };
        var dialog = await Dialog.ShowAsync<CreateTaskDialog>("Update Task", parameters, options);
        var result = await dialog.Result;
        
        if (result is { Canceled: false })
        {
            await TodoService.UpdateTodoAsync(new UpdateTodoItemDto
            {
                Id = currentTaskId,
                Title = editTask.Title,
                Description = editTask.Description,
                Priority = editTask.Priority,
                DueDate = editTask.DueDate,
                IsCompleted = task.IsCompleted,
                ParentId = editTask.ParentId,
                CategoryId = editTask.CategoryId,
                TagIds = editTask.TagIds,
                FileId = editTask.FileId
            });
            await LoadTasksSheet();
        }
    }
}