using Dpz.Core.EnumLibrary;
using Dpz.Core.MessageQueue.Abstractions;
using Dpz.Core.Public.ViewModel;
using Dpz.Core.Public.ViewModel.Messages;
using Dpz.Core.Public.ViewModel.Response;
using Dpz.Core.Web.Models;

namespace Dpz.Core.Web.Controllers;

public class CodeController(
    ICodeFileSystemEntryService codeFileSystemEntryService,
    IMessagePublisher<AnalyzeCodeMessage> analyzeCodePublisher
) : Controller
{
    [Route("code/{**path}")]
    [HttpGet]
    public async Task<IActionResult> Index(
        string path = "",
        CancellationToken cancellationToken = default
    )
    {
        ViewBag.Menu = MenuItem.Code;
        this.SetTitle(string.IsNullOrEmpty(path) ? "网站源码" : path + " 网站源码");

        var pathArray = path.Split("/").Where(x => !string.IsNullOrWhiteSpace(x)).ToArray();
        var model = await codeFileSystemEntryService.BuildCodeNoteTreeAsync(
            pathArray,
            cancellationToken: cancellationToken
        );

        if (
            model is { CodeContainer.CodeContent: not null, FileName: not null }
            && await codeFileSystemEntryService.ShouldAnalyzeAsync(
                model.CurrentPaths.ToArray(),
                model.FileName,
                model.CodeContainer,
                cancellationToken
            )
        )
        {
            // 重新查询获取文件Hash用于消息去重
            var entry = await codeFileSystemEntryService.FindByPathAsync(
                model.CurrentPaths.ToArray(),
                cancellationToken
            );
            if (entry?.Hash != null)
            {
                var parentPath = model.ParentPaths.ToArray();
                await analyzeCodePublisher.PublishAsync(
                    new AnalyzeCodeMessage
                    {
                        Path = parentPath,
                        FileName = model.FileName,
                        FileHash = entry.Hash,
                        CodeContent = model.CodeContainer.CodeContent,
                    },
                    cancellationToken: cancellationToken
                );
            }
        }

        if (model is not { Type: FileSystemType.FileSystem })
        {
            return NotFound();
        }

        if (!string.IsNullOrWhiteSpace(model.CodeContainer?.AiAnalyzeResult))
        {
            var pageMetaPage = new VmPageMetadata
            {
                Description = model.CodeContainer?.AiAnalyzeResult,
                Keywords = [.. pathArray],
                Relations = ["Code", "Index"],
            };
            ViewData["PageMetadata"] = pageMetaPage;
        }

        var sidebarTree = await BuildSidebarTreeAsync(pathArray, HttpContext.RequestAborted);
        return View(new CodeIndexViewModel { NoteTree = model, SidebarTree = sidebarTree });
    }

    [Route("get/code/children")]
    [HttpGet]
    public async Task<IActionResult> TreeChildren(
        string path = "",
        CancellationToken cancellationToken = default
    )
    {
        var pathArray = string.IsNullOrWhiteSpace(path)
            ? []
            : path.Split("/").Where(x => !string.IsNullOrWhiteSpace(x)).ToArray();

        if (pathArray.Length > 0)
        {
            // 若该路径真实存在，则交回正常页面处理，避免路由抢占真实目录
            var entry = await codeFileSystemEntryService.FindByPathAsync(
                pathArray,
                cancellationToken
            );
            if (entry != null)
            {
                return RedirectToAction(nameof(Index), new { path });
            }
        }

        var children = await codeFileSystemEntryService.GetChildrenAsync(
            pathArray,
            cancellationToken
        );
        var directories = children
            .Where(x => x.IsDirectory)
            .Select(ToChildrenTree)
            .OrderBy(x => x.Name)
            .ToList();
        var files = children
            .Where(x => !x.IsDirectory)
            .Select(ToChildrenTree)
            .OrderBy(x => x.Name)
            .ToList();
        return PartialView("_CodeTreeRowsPartial", (directories, files));
    }

    [Route("search/code")]
    [HttpGet]
    public async Task<IActionResult> Search(
        string keyword = "",
        CancellationToken cancellationToken = default
    )
    {
        var matchList = await codeFileSystemEntryService.SearchAsync(keyword, cancellationToken);
        var model = CodeSearchResultsViewModel.FromSearch(keyword, matchList);
        return PartialView("_CodeSearchResultsPartial", model);
    }

    /// <summary>
    /// 构建侧边栏初始树：根级 + 当前路径各级，逐级展开
    /// </summary>
    private async Task<List<CodeTreeNodeViewModel>> BuildSidebarTreeAsync(
        string[] pathSegments,
        CancellationToken cancellationToken
    )
    {
        var rootItems = await BuildLevelItemsAsync([], cancellationToken);
        var levelItems = rootItems;

        for (var i = 0; i < pathSegments.Length; i++)
        {
            var segment = pathSegments[i];
            var node = levelItems.FirstOrDefault(x =>
                x.IsFolder && string.Equals(x.Name, segment, StringComparison.OrdinalIgnoreCase)
            );
            if (node == null)
            {
                break;
            }

            node.Children = await BuildLevelItemsAsync(pathSegments[..(i + 1)], cancellationToken);
            levelItems = node.Children;
        }

        return rootItems;
    }

    private async Task<List<CodeTreeNodeViewModel>> BuildLevelItemsAsync(
        string[] pathSegments,
        CancellationToken cancellationToken
    )
    {
        var children = await codeFileSystemEntryService.GetChildrenAsync(
            pathSegments,
            cancellationToken
        );
        return children
            .OrderBy(x => x.IsDirectory ? 0 : 1)
            .ThenBy(x => x.Name)
            .Select(x => new CodeTreeNodeViewModel
            {
                Name = x.Name,
                Path = x.PathSegments.ToList(),
                IsFolder = x.IsDirectory,
            })
            .ToList();
    }

    private static ChildrenTree ToChildrenTree(CodeFileSystemEntryResponse entry)
    {
        return new ChildrenTree
        {
            Name = entry.Name,
            CurrentPath = entry.PathSegments.ToList(),
            LastUpdateTime = entry.LastWriteTime,
            Note = entry.Description ?? "",
        };
    }
}